examples

/**
 * =====================================================
 * 4.4 WHILE AND DO-WHILE LOOPS - EXAMPLES
 * =====================================================
 * Condition-based iteration
 */

// =====================================================
// 1. BASIC WHILE LOOP
// =====================================================

console.log('--- Basic While Loop ---');

let count = 0;

while (count < 5) {
  console.log(`Count is: ${count}`);
  count++;
}

console.log('Final count:', count); // 5

// =====================================================
// 2. BASIC DO-WHILE LOOP
// =====================================================

console.log('\n--- Basic Do-While Loop ---');

let num = 0;

do {
  console.log(`Number is: ${num}`);
  num++;
} while (num < 5);

console.log('Final number:', num); // 5

// =====================================================
// 3. KEY DIFFERENCE: MINIMUM EXECUTIONS
// =====================================================

console.log('\n--- While vs Do-While with False Condition ---');

// While loop - condition checked first
let a = 10;
console.log('While loop (a=10, condition: a < 5):');
while (a < 5) {
  console.log("This won't print");
  a++;
}
console.log("While loop didn't execute");

// Do-while loop - body executed first
let b = 10;
console.log('\nDo-while loop (b=10, condition: b < 5):');
do {
  console.log('This prints once! b =', b);
  b++;
} while (b < 5);
console.log('Do-while executed once');

// =====================================================
// 4. COUNTDOWN EXAMPLES
// =====================================================

console.log('\n--- Countdown ---');

// While countdown
console.log('While countdown:');
let countdown = 5;
while (countdown > 0) {
  console.log(countdown);
  countdown--;
}
console.log('Liftoff!');

// Do-while countdown
console.log('\nDo-while countdown:');
let timer = 3;
do {
  console.log(timer);
  timer--;
} while (timer > 0);
console.log('Done!');

// =====================================================
// 5. PROCESSING UNTIL CONDITION
// =====================================================

console.log('\n--- Process Until Condition ---');

// Sum numbers until exceeding 100
let sum = 0;
let value = 1;

while (sum <= 100) {
  sum += value;
  console.log(`Added ${value}, sum is now ${sum}`);
  value++;
}

console.log(`Final sum: ${sum}, last value added: ${value - 1}`);

// =====================================================
// 6. SIMULATED USER INPUT
// =====================================================

console.log('\n--- Simulated User Input ---');

// Simulating getting valid input
const validInputs = ['quit', 'invalid', '', 'valid'];
let inputIndex = 0;

function getSimulatedInput() {
  const input = validInputs[inputIndex];
  inputIndex++;
  return input;
}

// Process until "quit"
let userInput = getSimulatedInput();
while (userInput !== 'quit') {
  console.log(`Processing: "${userInput}"`);
  userInput = getSimulatedInput();
}
console.log('User quit');

// =====================================================
// 7. DO-WHILE FOR MENU SYSTEMS
// =====================================================

console.log('\n--- Menu System Pattern ---');

const menuOptions = ['view', 'edit', 'delete', 'exit'];
let optionIndex = 0;

function displayMenu() {
  console.log('1. View  2. Edit  3. Delete  4. Exit');
}

function getMenuChoice() {
  const choice = menuOptions[optionIndex];
  optionIndex++;
  return choice;
}

let choice;
do {
  displayMenu();
  choice = getMenuChoice();
  console.log(`Selected: ${choice}`);

  if (choice !== 'exit') {
    console.log(`Executing ${choice} action...`);
  }
} while (choice !== 'exit');

console.log('Goodbye!');

// =====================================================
// 8. SEARCHING IN DATA
// =====================================================

console.log('\n--- Searching ---');

const data = [3, 7, 2, 9, 5, 1, 8, 4, 6];
const target = 5;
let index = 0;

while (index < data.length && data[index] !== target) {
  console.log(`Checking index ${index}: ${data[index]}`);
  index++;
}

if (index < data.length) {
  console.log(`Found ${target} at index ${index}`);
} else {
  console.log(`${target} not found`);
}

// =====================================================
// 9. QUEUE PROCESSING
// =====================================================

console.log('\n--- Queue Processing ---');

const queue = ['task1', 'task2', 'task3'];

while (queue.length > 0) {
  const task = queue.shift(); // Remove first element
  console.log(`Processing: ${task}`);

  // Simulating task spawning subtasks
  if (task === 'task2') {
    queue.push('subtask2.1');
    console.log('Added subtask2.1 to queue');
  }
}

console.log('Queue empty, all tasks processed');

// =====================================================
// 10. RANDOM NUMBER GENERATION
// =====================================================

console.log('\n--- Random Until Condition ---');

// Keep generating until we get a number > 0.9
let random;
let attempts = 0;

do {
  random = Math.random();
  attempts++;
  console.log(`Attempt ${attempts}: ${random.toFixed(4)}`);
} while (random <= 0.9 && attempts < 20); // Safety limit

if (random > 0.9) {
  console.log(`Got ${random.toFixed(4)} > 0.9 after ${attempts} attempts`);
} else {
  console.log('Reached max attempts');
}

// =====================================================
// 11. DIGIT MANIPULATION
// =====================================================

console.log('\n--- Digit Manipulation ---');

// Sum of digits
let number = 12345;
let digitSum = 0;
let temp = number;

while (temp > 0) {
  const digit = temp % 10; // Get last digit
  digitSum += digit;
  console.log(`Digit: ${digit}, Running sum: ${digitSum}`);
  temp = Math.floor(temp / 10); // Remove last digit
}

console.log(`Sum of digits of ${number}: ${digitSum}`);

// Reverse a number
let original = 12345;
let reversed = 0;
temp = original;

while (temp > 0) {
  reversed = reversed * 10 + (temp % 10);
  temp = Math.floor(temp / 10);
}

console.log(`Reversed ${original}: ${reversed}`);

// =====================================================
// 12. BREAK AND CONTINUE
// =====================================================

console.log('\n--- Break and Continue ---');

// Break example
console.log('Break at 5:');
let i = 0;
while (i < 10) {
  if (i === 5) {
    console.log('Breaking!');
    break;
  }
  console.log(i);
  i++;
}

// Continue example
console.log('\nSkip evens:');
let j = 0;
while (j < 10) {
  j++;
  if (j % 2 === 0) {
    continue; // Skip even numbers
  }
  console.log(j);
}

// =====================================================
// 13. NESTED WHILE LOOPS
// =====================================================

console.log('\n--- Nested While Loops ---');

// Print a rectangle pattern
let rows = 3;
let row = 0;

while (row < rows) {
  let col = 0;
  let line = '';

  while (col < 5) {
    line += '*';
    col++;
  }

  console.log(line);
  row++;
}

// =====================================================
// 14. LABELED LOOPS
// =====================================================

console.log('\n--- Labeled Loops ---');

outer: while (true) {
  console.log('Outer loop');
  let inner = 0;

  while (inner < 3) {
    console.log(`  Inner: ${inner}`);
    inner++;

    if (inner === 2) {
      console.log('  Breaking outer!');
      break outer;
    }
  }
}

console.log('After loops');

// =====================================================
// 15. GAME-LIKE EXAMPLE
// =====================================================

console.log('\n--- Simple Game Loop ---');

let health = 100;
let turns = 0;
const maxTurns = 5;

while (health > 0 && turns < maxTurns) {
  turns++;
  const damage = Math.floor(Math.random() * 30) + 10;
  health -= damage;

  console.log(
    `Turn ${turns}: Took ${damage} damage, health: ${Math.max(0, health)}`
  );
}

if (health <= 0) {
  console.log('Game Over!');
} else {
  console.log('Survived all turns!');
}

// =====================================================
// 16. RETRY PATTERN
// =====================================================

console.log('\n--- Retry Pattern ---');

function simulateOperation() {
  // 30% chance of success
  return Math.random() < 0.3;
}

const maxRetries = 5;
let retryCount = 0;
let success = false;

do {
  retryCount++;
  console.log(`Attempt ${retryCount}...`);
  success = simulateOperation();

  if (!success && retryCount < maxRetries) {
    console.log('Failed, retrying...');
  }
} while (!success && retryCount < maxRetries);

if (success) {
  console.log(`Succeeded on attempt ${retryCount}`);
} else {
  console.log('All attempts failed');
}

// =====================================================
// 17. COMPARISON WITH FOR LOOP
// =====================================================

console.log('\n--- Comparison with For Loop ---');

// For loop
console.log('For loop:');
for (let x = 0; x < 3; x++) {
  console.log(x);
}

// Equivalent while loop
console.log('\nEquivalent while loop:');
let x = 0;
while (x < 3) {
  console.log(x);
  x++;
}

// =====================================================
// SUMMARY
// =====================================================

console.log('\n--- Summary ---');
console.log(`
While Loop:
  - Checks condition BEFORE each iteration
  - May not execute at all if condition is initially false
  - Good for: unknown iterations, condition-first scenarios

Do-While Loop:
  - Executes body FIRST, then checks condition
  - Always executes at least once
  - Good for: menus, validation, retry patterns
  - Don't forget the semicolon at the end!

Both loops:
  - Need manual initialization before the loop
  - Need manual update inside the loop
  - Support break and continue
  - Can be used with labels for nested loop control
`);