leetcode.ca

SQL (Structured Query Language) is the standard language for querying, manipulating, and transforming data stored in a relational database. It's used by both technical and non-technical people, and because of its simplicity, SQL databases power the storage behind millions of websites and mobile applications. If you want to read, filter, combine, or change structured data, SQL is the tool you'll reach for.

What a relational database actually is

Before the syntax makes sense, you need a mental model. A relational database is a collection of related two-dimensional tables. Each table looks a lot like an Excel spreadsheet:

• A fixed number of named columns (the attributes or properties of the table)
• Any number of rows of data

For example, a Department of Motor Vehicles database might have a Vehicles table storing the make/model, number of wheels, number of doors, and type of every registered vehicle:

The "relational" part means tables can be linked to each other, which is what makes it possible to pull related data together in a single query.

What SQL lets you do

SQL covers the full lifecycle of working with data, not just reading it. The main categories of tasks are:

• Query rows from one or more tables
• Filter and sort results with constraints
• Aggregate data (counts, sums, averages) and use expressions
• Join multiple tables, including outer joins
• Insert, update, and delete rows
• Create, alter, and drop tables and other structures

A simple starting point is the SELECT query, which retrieves data. From there you layer on constraints, sorting, joins, and aggregates.

One language, many databases

There are many popular SQL databases, including SQLite, MySQL, Postgres, Oracle, and Microsoft SQL Server. All of them support the common SQL language standard, so the core syntax you learn transfers between them. Each implementation can differ in the additional features and storage types it supports, so vendor-specific behavior is worth checking when you move to a new system.

How to start learning

A practical path is to begin with SELECT and build up in this order:

1. SELECT queries (retrieving columns from a table)
2. Queries with constraints (WHERE filtering)
3. Filtering and sorting results
4. Multi-table queries with JOINs, then OUTER JOINs
5. A note on NULLs
6. Queries with expressions
7. Queries with aggregates
8. Order of execution of a query
9. Inserting, updating, and deleting rows
10. Creating, altering, and dropping tables

SQLBolt is one option for this: it provides a set of interactive lessons and exercises you run directly in your browser, starting with an introduction to SQL and SELECT queries and progressing through joins, aggregates, and table operations.

When SQL is the right fit

Choose SQL when your data is structured and relational — records with consistent attributes that need to be queried, filtered, combined across tables, or modified reliably. It's a strong fit for application backends, reporting, and analysis over tabular data. If your data has no fixed schema or you only need to store and retrieve whole documents by key, a relational database may be more structure than you need.

An alg (short for algorithm) in speedcubing is a fixed sequence of moves that transforms a specific cube state into another — usually solving a case or advancing toward a solve. It is not a general math algorithm; it is a memorized motor routine. You need algs once you move past beginner layer-by-layer methods and start learning case-based systems like CFOP, Roux, or ZZ. This guide explains how algs are written, where to find them, and how to actually learn them.

What an alg actually is

An alg is a string of move instructions tied to a case — a specific arrangement of pieces. For example, an OLL alg assumes the last layer is oriented in a particular pattern; applied to that pattern, it produces a solved (or further-advanced) state.

Two consequences follow:

• An alg is case-specific. The same string applied to a different case gives a different, usually worse, result.
• An alg is orientation-specific. Most algs assume a defined cube orientation (e.g., the unsolved face facing you). Rotate the cube and the same moves no longer solve the case.

Reading alg notation

Standard notation lets you read any alg sheet. Each letter is a face; a prime (') means counterclockwise; a number means repeat.

A sample alg like R U R' U' reads: right clockwise, up clockwise, right counterclockwise, up counterclockwise. That four-move sequence is the "sexy move," the building block of many beginner and advanced algs.

Where to find algs by puzzle and case

Algs are organized by puzzle and by case. Speed Cube Database (speedcubedb.com) is one example of a free online database covering algorithms and reconstructions for 2x2 through 6x6, plus SQ1, Pyraminx, and Megaminx. Its keyword set — alg, algorithm, algsheet, cubing, speedcubing, fingertricks, video — reflects what such databases typically offer: alg sheets per case, fingertrick notes, and video demonstrations.

When searching for algs, match three things:

1. Puzzle (3x3, 4x4, etc.) — algs are not interchangeable across sizes.
2. Method/system (CFOP OLL/PLL, Roux CMLL, etc.) — the same case may have different algs per system.
3. Case name or diagram — use the visual to confirm you have the right one.

How to learn algs effectively

Memorizing the string is the easy part; making it fast is the work.

• Chunk the alg. Break it into 2–4 move groups rather than 15 separate moves. R U R' U' is one chunk, not four.
• Learn fingertricks. Each chunk maps to a finger motion (index push, ring pull, etc.). Databases that include fingertrick notes or video are more useful than raw text for this reason.
• Drill in isolation first. Repeat the alg slowly until it is accurate, then build speed. Accuracy before speed prevents locking in bad habits.
• Then drill in context. Apply it to scrambled cases so you practice recognition, not just execution.
• Space your practice. Short daily sessions beat one long cram; algs are muscle memory and decay without repetition.

Troubleshooting an alg that doesn't work

If an alg fails, check in this order:

1. Notation errors — a missed prime or a 2 read as a single turn is the most common cause.
2. Wrong case — confirm the piece arrangement matches the alg's diagram.
3. Cube orientation — verify which face is "front" and whether a rotation (x/y/z) is implied.
4. Wide vs. slice confusion — lowercase r is not the same as R or M.
5. Setup moves — some algs assume a preceding rotation or setup; check the full entry, not just the move string.

Work through these before assuming the alg itself is wrong — most failures are notation or orientation, not the sequence.

LeetCode is an online platform of coding challenges that companies use as a proxy for technical interviews. You use it by picking problems by topic and difficulty, solving them in an in-browser editor, and repeating until common patterns become automatic. It is the right tool if you are preparing for software engineering interviews at large tech companies; it is less useful if you are practicing system design, behavioral questions, or domain-specific work.

What LeetCode actually is

LeetCode hosts thousands of algorithm and data-structure problems. Each problem gives you a statement, one or more examples, constraints, and a code editor with a test runner. You submit a solution, and the platform judges it against hidden test cases and reports runtime and memory relative to other submissions.

Two things make it useful for interview prep:

• The problem set mirrors real interview questions. Many companies draw from similar patterns, so practice transfers.
• The judge gives immediate, objective feedback. You find out quickly whether your logic handles edge cases, not just the examples shown.

Problem categories and difficulty levels

Problems are tagged by topic and rated Easy, Medium, or Hard. The rating reflects how hard the problem is to solve correctly, not how long it takes.

Common topic tags you will see:

• Arrays and strings — two pointers, sliding window, prefix sums
• Hashing — frequency maps, deduplication, lookups
• Linked lists — traversal, reversal, cycle detection
• Trees and graphs — BFS, DFS, recursion, topological sort
• Dynamic programming — memoization, tabulation, state design
• Sorting and searching — binary search, custom comparators
• Heaps and stacks — priority queues, monotonic stacks

If you are new, do not sort by difficulty alone. Sort by topic, pick one pattern, and do several problems in a row so the pattern sticks.

A practical workflow for solving one problem

Use the same loop every time so it becomes a habit you can repeat under pressure.

1. Read the problem twice. Identify the input, the output, and the constraints. Constraints often tell you the intended complexity — for example, an input size in the tens of thousands usually rules out an O(n²) solution.
2. Restate it in your own words. If you cannot, you do not understand it yet.
3. Work small examples by hand. Take the given examples and one edge case (empty input, single element, duplicates, negative numbers).
4. Plan before coding. Name the pattern and write the approach in a sentence or two. Decide the data structures.
5. Code it. Write clean, readable code. Name variables meaningfully.
6. Test against your examples. Trace the code manually before running it.
7. Submit and read the result. If it fails, look at which case failed and why — do not just tweak until it passes.
8. Optimize if needed. Check the time and memory report. If you are in the slow tail, ask what the bottleneck is.
9. Review the editorial or top solutions. Compare your approach to the accepted ones. Note anything you missed.

The step most people skip is step 4. Planning before typing is what separates a calm interview from a scramble.

Using LeetCode to prepare for top-company interviews

• Practice by pattern, not by random problem. Group problems by tag and do five to ten of the same type in one session.
• Time yourself. Give Medium problems about 30 minutes. If you exceed it, look at the solution, then re-solve from scratch the next day.
• Re-solve problems you failed. A problem you solved once and forgot is not learned. Spaced repetition matters more than volume.
• Talk out loud. Interviews are verbal. Practice explaining your approach as if someone is listening.
• Mix topics in later sessions. Real interviews do not tell you which pattern to use, so your practice should not either.

Common pitfalls

• Grinding without reviewing. Solving 300 problems and reviewing none is worse than solving 100 and reviewing all of them.
• Memorizing solutions. Interviewers change the problem slightly. Memorized code breaks; understood patterns adapt.
• Skipping Easy problems. Easy problems build the fluency that Medium problems assume.
• Ignoring constraints. Misreading constraints is the most common cause of a wrong complexity choice.
• Only practicing alone in silence. You will not have silence in the interview.
• Neglecting communication. A correct solution you cannot explain reads as luck.

Where AI tools fit

Some candidates use AI copilots during live interviews to get real-time suggestions. Interview Solver, for example, markets itself as an AI interview copilot that stays invisible to screen sharing and provides real-time LeetCode solutions. Whether you use such a tool is a personal and ethical decision, and many companies explicitly prohibit it. For preparation, the safer and more durable approach is to build the skill yourself, because you cannot rely on assistance in every round or every format.

Quick start

If you are starting today: create an account, pick the Arrays and Hashing tag, filter to Easy, and solve three problems using the nine-step workflow above. Then move to Medium. Track which patterns you fail and revisit them weekly. That loop, repeated consistently, is what LeetCode preparation actually is.

ViaVersion is a protocol translator for Minecraft: Java Edition. It sits between the client and the server and rewrites network packets so that a client running one Minecraft version can join a server running a different one. According to the ViaVersion Project, its software supports "all common platforms and our own standalone proxy to join from basically any client version on any server version from the past decade." You need it when you run a server and want players on older or newer Java Edition clients to connect without asking everyone to match versions exactly.

The core problem it solves

Minecraft: Java Edition changes its network protocol with most updates. A vanilla server only accepts clients speaking its own protocol version, so after an update, players who haven't updated (or who deliberately stay on an older version) get a version-mismatch error and can't join. The ViaVersion homepage frames this directly with the heading "Why Lose Players After a Minecraft Update?" — the project exists so a server update doesn't cut off part of your player base.

How the translation works

The mechanism is packet-level translation, not a game-content mod:

1. A client connects and reports its protocol version.
2. ViaVersion intercepts the packets flowing between client and server.
3. It converts packet formats, IDs, and data structures from the client's version into what the server expects, and back again for outbound traffic.
4. The server sees a compatible client, and the client sees a compatible server.

Because this happens at the protocol layer, the server software itself doesn't need to be rewritten. That's why the same project can ship as plugins, mods, and a standalone proxy rather than one single build.

What "any version on any version" means in practice

The project describes support for client and server versions spanning roughly the past decade. In practice this means:

• A player on an older client can join a server running a newer version.
• A player on a newer client can join a server still running an older version.
• You don't have to force every player onto one exact version to play together.

Exact version coverage shifts as Minecraft releases new updates, so check the current documentation rather than assuming a specific pair of versions is supported.

What software is included

ViaVersion is an umbrella project, not a single download. The site lists several categories:

The project was founded in 2016 by FormallyMyles and has been maintained by a team of developers since. It also publishes Javadocs, a repository, a Jenkins CI instance, and community spaces on Discord, GitHub, Hangar, and Modrinth.

Do you actually need it?

Use this as a quick decision guide:

• You run a server and players are on mixed versions → you likely want ViaVersion, installed as the plugin, mod, or proxy that matches your platform.
• You run a server where everyone is already on the same version → you don't need it for compatibility, though it can still help absorb future updates.
• You're a player on a server you don't control → you can't install it yourself; the server owner decides. Your options are updating, downgrading, or using a client-side solution the server supports.
• You want to connect across versions without a specific server platform → the standalone proxy is the relevant piece.

The first real decision is your server platform, because that determines whether you install a plugin, a mod, or run the proxy.

Getting started

The homepage points to an installation guide for people who "don't know where to start." The general flow is:

1. Identify your server platform and the Minecraft version it runs.
2. Pick the matching ViaVersion component (plugin, mod, or proxy).
3. Follow the official setup instructions for that component.
4. Start the server and confirm it loads without errors.
5. Test by connecting with a client on a different version than the server.

Verification: the clearest success signal is a client on a mismatched version reaching the server without a version-mismatch disconnect. If it fails, the version pair you're testing may simply not be covered, or the component may not match your platform.

Common sticking points

• Wrong component for your platform. A plugin won't help a setup that needs the proxy, and vice versa.
• Assuming every version pair works. Coverage is broad but not infinite; confirm your specific versions in the docs.
• Expecting content parity. Protocol translation handles connectivity. Features that don't exist in an older client version still won't appear there.
• Skipping the setup guide. The project maintains its own installation documentation, which is the authoritative source over third-party tutorials.

Where to get help

If something breaks, the project's own channels are the place to look: the documentation, the GitHub repository for issues and pull requests, and the community Discord. The team also states it welcomes contributions via pull requests, donations, and services, and lists Javadocs, Jenkins CI, Hangar, and Modrinth as part of its infrastructure.

raylib is a C library for videogame programming that works directly in C++ projects, and the fastest way to start is to install it, compile a minimal window program, then learn the API from the official cheatsheet and examples rather than from formal documentation. This guide fits you if you already know some C++ and want a lightweight library with no GUI editor, no visual helpers, and no engine overhead — just code. If you prefer a drag-and-drop engine or need a full editor workflow, raylib is the wrong tool.

What raylib actually is

raylib describes itself as "a simple and easy-to-use library to enjoy videogames programming." Two things about that description matter for your decision:

• It is a library, not an engine. The project states there is "no fancy interface, no visual helpers, no gui tools or editors... just coding in pure spartan-programmers way." You write C or C++ code and call functions.
• It is written in C. That is why it drops into C++ projects without wrappers, and why the same library is available through 60+ language bindings if you ever switch languages.

Because it is minimal, raylib does not ship the typical API documentation or a large tutorial set. The project's own guidance is that the library "is designed to be minimalistic and be learned just from a cheatsheet with all required functionality and a big collection of examples." Plan your learning around reading code, not reading manuals.

Setting up raylib for C++

The site points to a raylib Windows Installer that "install[s] raylib in seconds." That is the shortest path on Windows. On other systems, or if you prefer managing dependencies yourself, you install raylib through your platform's package manager or build it from source — the site does not spell out those commands, so treat the installer as the documented quick route and check the wiki for your platform.

What you need before writing code:

1. A C++ compiler (any compiler that supports C++ and links against C works, since raylib is a C library).
2. raylib installed so your compiler can find its headers and link its library.
3. OpenGL support on your machine — raylib requires C language and OpenGL graphics (or similar), and the site notes that "technically, any platform that supports C language and OpenGL graphics (or similar) can run raylib."

The site lists a set of tested supported platforms but does not enumerate them in the material available here, so verify your target against the supported-platforms list on raylib.com before committing.

Your first raylib program in C++

The input, action, and expected result are the same for every raylib program: you include the header, open a window, run a loop until the window should close, draw, and close.

#include "raylib.h"

int main() {
    InitWindow(800, 450, "My first raylib game");
    SetTargetFPS(60);

    while (!WindowShouldClose()) {
        BeginDrawing();
        ClearBackground(RAYWHITE);
        DrawText("Hello, raylib!", 190, 200, 20, LIGHTGRAY);
        EndDrawing();
    }

    CloseWindow();
    return 0;
}

• Input: the window size, title, and target frame rate you pass in.
• Action: InitWindow creates the window and graphics context; the while loop runs once per frame; BeginDrawing/EndDrawing bracket your drawing calls.
• Expected result: an 800×450 window showing the text, which closes when you click the close button or press Escape.

Compile it by linking raylib the same way you link any C library in your toolchain. If the compiler cannot find raylib.h, your include path is wrong; if it fails at link time with undefined references, your library path or link flags are wrong. Those two errors cover most first-run failures.

Learning the API without formal docs

Since raylib intentionally skips conventional API documentation, use these resources in this order:

The project's own advice is blunt: "Best way to learn to code is reading code." If you feel lost among the choices, the raylib game template is the recommended starting point because it "provides some structure and a Makefile that are quick and easy to pick up and use."

Extending raylib and going further

raylib is designed to be combined with extra libraries for additional functionality. Most of those are single-file, header-only, and have no external dependencies, and some are already used internally by raylib itself. That means you can add capability without restructuring your project or pulling in a dependency tree.

raylib is also the base technology behind the raylib technologies tools, several multiplatform tools built with raylib and raygui — useful to look at if you want to see what larger projects built on the same foundation look like.

When raylib is the right choice

Choose raylib if you want to write game code in C++ with minimal abstraction, you are comfortable reading examples instead of documentation, and you do not need a visual editor. Look elsewhere if you want a scene editor, asset pipeline, or a large built-in API surface — those are explicitly not what raylib provides. The project is open to corporate sponsorship and donations, but the material here contains no pricing information, so do not assume any commercial tier or cost structure from this page.