Résultats d'apprentissage:

1. Explain base-2 using place values and compare to base-10 with small examples.

2. Evaluate sample binary numbers and state their decimal value to check understanding.

Résultats d'apprentissage:

1. Convert a given decimal integer (0–255) to binary manually using repeated division by 2 and record remainders.

2. Validate results by reconverting the binary back to decimal using place values.

Résultats d'apprentissage:

1. Compute decimal values from binary strings by summing weighted bits (1s times powers of two).

2. Trace the conversion step by step for 8-bit inputs and verify with a calculator or code.

3. Detect invalid binary input (characters not 0/1) and prompt for correction.

4. Demonstrate how leading zeros do not change the decimal value and verify with examples.

5. Cross-check conversions by round-tripping: decimal -> binary -> decimal for sample numbers.

6. Explain common mistakes (bit order, missing weights) and show how to avoid them.

Résultats d'apprentissage:

1. Declare and initialize int, double, char, bool, and std::string variables for simple classroom scenarios.

2. Select data types that best represent provided values (e.g., age as int, price as double) and justify the choice.

3. Print variable values with labels using std::cout and format readable output with spaces and std::endl.

4. Predict the result of implicit conversions in small expressions and verify with code runs.

5. Trace variable updates step by step and confirm final values using targeted print statements.

6. Apply consistent, descriptive variable names that follow a beginner-friendly naming convention.

Résultats d'apprentissage:

1. Construct user prompts that clearly state expected input type and example values.

Résultats d'apprentissage:

1. Construct if and if/else statements that react to user input (e.g., pass/fail based on score).

2. Integrate relational and logical operators in condition checks and justify each condition.

3. Trace branches with sample inputs and annotate which path executes and why.

4. Eliminate redundant checks by simplifying boolean expressions without altering outcomes.

5. Print friendly feedback for each branch so users understand program decisions.

6. Draft a mini scenario (e.g., age-based ticket price) and implement it with clear branching.

Résultats d'apprentissage:

1. Combine nested if/else constructs to handle multiple criteria (e.g., grade letters with ranges).

2. Diagram decision trees that map inputs to branches and verify paths with test cases.

3. Prevent unreachable code by reorganizing conditions logically and checking range overlaps.

4. Instrument decision code with trace prints to show which conditions evaluated true.

5. Refactor nested code into readable blocks with consistent indentation and comments.

6. Evaluate edge cases at boundaries (e.g., 59/60/100) and confirm correct branch selection.

Résultats d'apprentissage:

1. Construct for loops that iterate a specified number of times and print iteration counters.

2. Avoid off-by-one errors by testing boundary values and adjusting start/end conditions.

3. Generate multiplication tables or number sequences and validate results.

4. Refactor repetitive prints into compact for loops without changing output.

5. Annotate loop parts (init, condition, update) and predict loop length for given settings.

6. Embed simple computations inside loops and verify totals with hand calculations.

Résultats d'apprentissage:

1. Produce text patterns (e.g., stars, grids) using nested for loops and controlled spacing.

2. Generate 2D tables (e.g., addition table) and format columns for readability.

3. Explain how inner and outer loop indices interact by tracing sample iterations.

4. Detect and fix alignment issues by adjusting spacing and width outputs.

5. Measure performance informally by counting iterations for small sizes.

6. Package repeated formatting code into helper prints for reuse.

Résultats d'apprentissage:

1. Define functions with appropriate return types and parameters and write matching prototypes above main.

2. Call functions with arguments and store returned results in variables.

3. Separate input, processing, and output into distinct functions and verify behavior.

4. Trace parameter passing by value and confirm the caller’s variables remain unchanged.

5. Document function purpose with header comments that state inputs, outputs, and effects.

6. Organize functions in a logical order and compile to confirm proper prototype placement.

Résultats d'apprentissage:

1. Differentiate local and global scope by writing examples that shadow names safely.

2. Explain variable lifetime within a function and demonstrate with printed entry/exit messages.

3. Prevent name collisions by using clear, unique identifiers and minimal globals.

4. Refactor a single-function program into modular functions and compare readability.

5. Apply a simple file structure plan (e.g., main plus helpers in same file for beginners) and justify it.

Résultats d'apprentissage:

1. Declare fixed-size arrays of int and initialize them with sample values.

2. Iterate over arrays with for loops and print indices and elements safely.

3. Apply bounds checks to avoid out-of-range access and explain why limits matter.

4. Input elements from the user into an array and echo them back for confirmation.

5. Compute the length using a constant or tracked size variable in beginner-friendly code.

6. Trace array state before and after updates to verify correctness.

Résultats d'apprentissage:

1. Accumulate sum and count to compute an average and print with clear labels.

2. Track current minimum and maximum in a single pass and validate with test arrays.

3. Handle empty or zero-sized cases with a friendly message and safe defaults.

4. Format results neatly, including units or context (e.g., scores, temperatures).

5. Compare results against manual calculations to confirm accuracy.

6. Package repeated aggregation logic into helper functions for reuse.

Résultats d'apprentissage:

1. Draft a simple project brief that lists goals, target users, and success criteria.

2. Specify program inputs, outputs, and example user interactions as sample transcripts.

3. Outline a scope that fits within a class period or two and identify stretch goals.

4. Prioritize must-have vs. nice-to-have features using a short checklist.

5. Collect peer feedback on the plan and revise features for clarity and feasibility.

6. Identify risks (time, input validation) and propose mitigation steps.

Résultats d'apprentissage:

1. Break the project into functions and basic data structures aligned with course concepts.

2. Write pseudocode that sequences input, processing, and output clearly.

3. Draw a simple flowchart for main logic and one subroutine, labeling decisions and loops.

4. Map pseudocode steps to expected console prompts and outputs.