Episode 7 — DSA with JavaScript / 7.1 — Conditional Statements

7.1 — Exercise Questions: Conditional Statements

Easy

E1. Even or Odd

Write a function that returns "even" or "odd" for a given integer.

Hint: Use modulo operator %.

Solution (JS)

function evenOrOdd(n) {
    return n % 2 === 0 ? "even" : "odd";
}
console.log(evenOrOdd(4));  // "even"
console.log(evenOrOdd(7));  // "odd"
console.log(evenOrOdd(0));  // "even"
console.log(evenOrOdd(-3)); // "odd"

Solution (C++)

#include <iostream>
#include <string>
using namespace std;

string evenOrOdd(int n) {
    return n % 2 == 0 ? "even" : "odd";
}

int main() {
    cout << evenOrOdd(4) << endl;   // even
    cout << evenOrOdd(7) << endl;   // odd
    cout << evenOrOdd(-3) << endl;  // odd
    return 0;
}

Complexity: O(1) time, O(1) space.

E2. Maximum of Three Numbers

Write a function that returns the maximum of three numbers.

Hint: Compare pairs or use nested ternaries.

Solution (JS)

function maxOfThree(a, b, c) {
    if (a >= b && a >= c) return a;
    if (b >= c) return b;
    return c;
}
// Or simply: Math.max(a, b, c)

console.log(maxOfThree(3, 7, 2));  // 7
console.log(maxOfThree(5, 5, 5));  // 5

Solution (C++)

int maxOfThree(int a, int b, int c) {
    if (a >= b && a >= c) return a;
    if (b >= c) return b;
    return c;
}

E3. Leap Year

Write a function that returns true if a year is a leap year.

Rules:
- Divisible by 4 → potential leap
- Divisible by 100 → NOT leap (unless...)
- Divisible by 400 → YES leap

Solution (JS)

function isLeapYear(year) {
    return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
}

console.log(isLeapYear(2024)); // true
console.log(isLeapYear(1900)); // false
console.log(isLeapYear(2000)); // true
console.log(isLeapYear(2023)); // false

Solution (C++)

bool isLeapYear(int year) {
    return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
}

E4. Grade Calculator

Given a score (0-100), return the letter grade.

Score	Grade
90-100	A
80-89	B
70-79	C
60-69	D
0-59	F

Solution (JS)

function getGrade(score) {
    if (score < 0 || score > 100) return "Invalid";
    if (score >= 90) return "A";
    if (score >= 80) return "B";
    if (score >= 70) return "C";
    if (score >= 60) return "D";
    return "F";
}

E5. FizzBuzz

For numbers 1 to n, return "Fizz" for multiples of 3, "Buzz" for multiples of 5, "FizzBuzz" for both, or the number as a string.

Solution (JS)

function fizzBuzz(n) {
    const result = [];
    for (let i = 1; i <= n; i++) {
        if (i % 15 === 0) result.push("FizzBuzz");
        else if (i % 3 === 0) result.push("Fizz");
        else if (i % 5 === 0) result.push("Buzz");
        else result.push(String(i));
    }
    return result;
}

console.log(fizzBuzz(15));
// ["1","2","Fizz","4","Buzz","Fizz","7","8","Fizz","Buzz","11","Fizz","13","14","FizzBuzz"]

Solution (C++)

#include <iostream>
#include <string>
#include <vector>
using namespace std;

vector<string> fizzBuzz(int n) {
    vector<string> result;
    for (int i = 1; i <= n; i++) {
        if (i % 15 == 0) result.push_back("FizzBuzz");
        else if (i % 3 == 0) result.push_back("Fizz");
        else if (i % 5 == 0) result.push_back("Buzz");
        else result.push_back(to_string(i));
    }
    return result;
}

Medium

E6. Day of the Week

Given a number 1-7, return the day name using a switch statement.

Solution (JS)

function dayName(n) {
    switch (n) {
        case 1: return "Monday";
        case 2: return "Tuesday";
        case 3: return "Wednesday";
        case 4: return "Thursday";
        case 5: return "Friday";
        case 6: return "Saturday";
        case 7: return "Sunday";
        default: return "Invalid day";
    }
}

E7. Simple Calculator

Build a calculator that takes two numbers and an operator (+, -, *, /) and returns the result. Handle division by zero.

Solution (JS)

function calculate(a, op, b) {
    switch (op) {
        case "+": return a + b;
        case "-": return a - b;
        case "*": return a * b;
        case "/":
            if (b === 0) return "Error: Division by zero";
            return a / b;
        default:
            return "Error: Unknown operator";
    }
}

Solution (C++)

#include <string>
#include <stdexcept>
using namespace std;

double calculate(double a, char op, double b) {
    switch (op) {
        case '+': return a + b;
        case '-': return a - b;
        case '*': return a * b;
        case '/':
            if (b == 0) throw runtime_error("Division by zero");
            return a / b;
        default:
            throw runtime_error("Unknown operator");
    }
}

E8. Number to Words (1-20)

Convert an integer 1-20 to its English word.

Solution (JS)

function numberToWord(n) {
    const words = [
        "", "one", "two", "three", "four", "five",
        "six", "seven", "eight", "nine", "ten",
        "eleven", "twelve", "thirteen", "fourteen", "fifteen",
        "sixteen", "seventeen", "eighteen", "nineteen", "twenty"
    ];
    if (n < 1 || n > 20) return "out of range";
    return words[n];
}

E9. Rock Paper Scissors

Given two player choices, determine the winner.

Solution (JS)

function rps(p1, p2) {
    if (p1 === p2) return "Draw";
    const wins = { rock: "scissors", scissors: "paper", paper: "rock" };
    if (wins[p1] === p2) return "Player 1 wins";
    return "Player 2 wins";
}

console.log(rps("rock", "scissors"));  // "Player 1 wins"
console.log(rps("paper", "paper"));    // "Draw"

E10. Password Strength Checker

Check if a password meets all requirements: min 8 chars, has uppercase, has lowercase, has digit, has special character.

Solution (JS)

function passwordStrength(pw) {
    const checks = {
        length: pw.length >= 8,
        uppercase: /[A-Z]/.test(pw),
        lowercase: /[a-z]/.test(pw),
        digit: /\d/.test(pw),
        special: /[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>?]/.test(pw),
    };
    const passed = Object.values(checks).filter(Boolean).length;
    if (passed === 5) return "Strong";
    if (passed >= 3) return "Medium";
    return "Weak";
}

Hard

E11. Roman Numeral Converter (1-3999)

Convert an integer to a Roman numeral string.

Solution (JS)

function toRoman(num) {
    const values = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1];
    const symbols = ["M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"];
    let result = "";
    for (let i = 0; i < values.length; i++) {
        while (num >= values[i]) {
            result += symbols[i];
            num -= values[i];
        }
    }
    return result;
}

console.log(toRoman(1994)); // "MCMXCIV"
console.log(toRoman(58));   // "LVIII"

Solution (C++)

#include <string>
#include <vector>
using namespace std;

string toRoman(int num) {
    vector<int> values = {1000,900,500,400,100,90,50,40,10,9,5,4,1};
    vector<string> symbols = {"M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"};
    string result;
    for (int i = 0; i < values.size(); i++) {
        while (num >= values[i]) {
            result += symbols[i];
            num -= values[i];
        }
    }
    return result;
}

Complexity: O(1) — bounded by 3999 max value.

E12. Validate a Date

Given day, month, year, determine if the date is valid. Account for leap years and month-specific day limits.

Solution (JS)

function isValidDate(day, month, year) {
    if (year < 1 || month < 1 || month > 12 || day < 1) return false;
    const daysInMonth = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
    if ((year % 4 === 0 && year % 100 !== 0) || year % 400 === 0) {
        daysInMonth[2] = 29;
    }
    return day <= daysInMonth[month];
}

console.log(isValidDate(29, 2, 2024)); // true (leap year)
console.log(isValidDate(29, 2, 2023)); // false
console.log(isValidDate(31, 4, 2024)); // false (April has 30)

Solution (C++)

bool isValidDate(int day, int month, int year) {
    if (year < 1 || month < 1 || month > 12 || day < 1) return false;
    int daysInMonth[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
    if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
        daysInMonth[2] = 29;
    return day <= daysInMonth[month];
}

E13. Tax Calculator with Progressive Brackets

Income         Tax Rate
0 - 10,000     0%
10,001 - 40,000   12%
40,001 - 80,000   22%
80,001+           32%

Calculate the total tax (not flat rate — progressive brackets).

Solution (JS)

function calculateTax(income) {
    if (income <= 0) return 0;
    let tax = 0;
    const brackets = [
        { limit: 10000, rate: 0 },
        { limit: 40000, rate: 0.12 },
        { limit: 80000, rate: 0.22 },
        { limit: Infinity, rate: 0.32 },
    ];
    let prev = 0;
    for (const { limit, rate } of brackets) {
        if (income <= prev) break;
        const taxable = Math.min(income, limit) - prev;
        tax += taxable * rate;
        prev = limit;
    }
    return Math.round(tax * 100) / 100;
}

console.log(calculateTax(50000));
// 0*10000 + 0.12*30000 + 0.22*10000 = 0 + 3600 + 2200 = 5800

Solution (C++)

#include <vector>
#include <algorithm>
#include <climits>
using namespace std;

double calculateTax(double income) {
    if (income <= 0) return 0;
    struct Bracket { double limit; double rate; };
    vector<Bracket> brackets = {
        {10000, 0}, {40000, 0.12}, {80000, 0.22}, {1e18, 0.32}
    };
    double tax = 0, prev = 0;
    for (auto& b : brackets) {
        if (income <= prev) break;
        double taxable = min(income, b.limit) - prev;
        tax += taxable * b.rate;
        prev = b.limit;
    }
    return tax;
}

E14. Implement a Mini Rule Engine

Given a list of rules (conditions + actions), evaluate them against an object.

Solution (JS)

function evaluateRules(data, rules) {
    const results = [];
    for (const rule of rules) {
        if (rule.condition(data)) {
            results.push({ rule: rule.name, action: rule.action(data) });
        }
    }
    return results;
}

const rules = [
    {
        name: "High temperature alert",
        condition: (d) => d.temp > 40,
        action: () => "ALERT: Temperature critical!",
    },
    {
        name: "Low battery",
        condition: (d) => d.battery < 20,
        action: (d) => `Battery at ${d.battery}%`,
    },
];

console.log(evaluateRules({ temp: 45, battery: 15 }, rules));
// Both rules fire

E15. Vending Machine State Machine

Implement a vending machine with states: IDLE, COIN_INSERTED, ITEM_SELECTED, DISPENSING. Handle events: INSERT_COIN, SELECT_ITEM, DISPENSE, CANCEL.

Solution (JS)

function vendingMachine(state, event) {
    switch (state) {
        case "IDLE":
            if (event === "INSERT_COIN") return "COIN_INSERTED";
            return state;
        case "COIN_INSERTED":
            if (event === "SELECT_ITEM") return "ITEM_SELECTED";
            if (event === "CANCEL") return "IDLE";
            return state;
        case "ITEM_SELECTED":
            if (event === "DISPENSE") return "DISPENSING";
            if (event === "CANCEL") return "IDLE";
            return state;
        case "DISPENSING":
            if (event === "COMPLETE") return "IDLE";
            return state;
        default:
            return "IDLE";
    }
}