x ← 5
y ← 10
temp ← x
x ← y
y ← temp
DISPLAY(x)  // Outputs: 10
DISPLAY(y)  // Outputs: 5

x = 5
y = 10
temp = x
x = y
y = temp
print(x)  # Outputs: 10
print(y)  # Outputs: 5

let x = 5;
let y = 10;
let temp = x;
x = y;
y = temp;
console.log(x);  // Outputs: 10
console.log(y);  // Outputs: 5

age ← 16
hasLicense ← true

canDrive ← (age ≥ 16) AND hasLicense
DISPLAY(canDrive)  // Outputs: true

age = 16
has_license = True

can_drive = (age >= 16) and has_license
print(can_drive)  # Outputs: True

let age = 16;
let hasLicense = true;

let canDrive = (age >= 16) && hasLicense;
console.log(canDrive);  // Outputs: true

score ← 85

IF (score ≥ 90)
{
    grade ← "A"
}
ELSE IF (score ≥ 80)
{
    grade ← "B"
}
ELSE
{
    grade ← "C"
}

DISPLAY(grade)  // Outputs: B

score = 85

if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
else:
    grade = "C"

print(grade)  # Outputs: B

let score = 85;
let grade;

if (score >= 90) {
    grade = "A";
} else if (score >= 80) {
    grade = "B";
} else {
    grade = "C";
}

console.log(grade);  // Outputs: B

count ← 0

REPEAT 5 TIMES
{
    count ← count + 1
    DISPLAY(count)
}

count = 0

for i in range(5):
    count = count + 1
    print(count)

let count = 0;

for (let i = 0; i < 5; i++) {
    count = count + 1;
    console.log(count);
}

num ← 1

REPEAT UNTIL (num > 5)
{
    DISPLAY(num)
    num ← num + 1
}

num = 1

while num <= 5:
    print(num)
    num = num + 1

let num = 1;

while (num <= 5) {
    console.log(num);
    num = num + 1;
}

numbers ← [4, 7, 2, 9, 1]
sum ← 0
count ← 0

FOR EACH num IN numbers
{
    sum ← sum + num
    count ← count + 1
}

average ← sum / count
DISPLAY("Average: " + average)

numbers = [4, 7, 2, 9, 1]
total = 0
count = 0

for num in numbers:
    total = total + num
    count = count + 1

average = total / count
print("Average:", average)

let numbers = [4, 7, 2, 9, 1];
let total = 0;
let count = 0;

for (let num of numbers) {
    total = total + num;
    count = count + 1;
}

let average = total / count;
console.log("Average:", average);

scores ← [85, 92, 78, 95, 88]
highCount ← 0

FOR EACH score IN scores
{
    IF (score ≥ 90)
    {
        highCount ← highCount + 1
    }
}

DISPLAY("Scores 90+: " + highCount)

scores = [85, 92, 78, 95, 88]
high_count = 0

for score in scores:
    if score >= 90:
        high_count = high_count + 1

print("Scores 90+:", high_count)

let scores = [85, 92, 78, 95, 88];
let highCount = 0;

for (let score of scores) {
    if (score >= 90) {
        highCount = highCount + 1;
    }
}

console.log("Scores 90+:", highCount);

rows ← 3
cols ← 4

REPEAT rows TIMES
{
    line ← ""
    REPEAT cols TIMES
    {
        line ← line + "* "
    }
    DISPLAY(line)
}

rows = 3
cols = 4

for r in range(rows):
    line = ""
    for c in range(cols):
        line = line + "* "
    print(line)

let rows = 3;
let cols = 4;

for (let r = 0; r < rows; r++) {
    let line = "";
    for (let c = 0; c < cols; c++) {
        line = line + "* ";
    }
    console.log(line);
}

fruits ← ["apple", "banana", "cherry"]

// Remember: AP CSP is 1-indexed!
first ← fruits[1]   // "apple"
second ← fruits[2]  // "banana"
third ← fruits[3]   // "cherry"

DISPLAY(first)
DISPLAY(second)
DISPLAY(third)
DISPLAY(LENGTH(fruits))

APPEND(fruits, "date")
DISPLAY(fruits[4])
DISPLAY(LENGTH(fruits))

fruits = ["apple", "banana", "cherry"]

# Python is 0-indexed!
first = fruits[0]   # "apple"
second = fruits[1]  # "banana"
third = fruits[2]   # "cherry"

print(first)
print(second)
print(third)
print(len(fruits))

fruits.append("date")
print(fruits[3])
print(len(fruits))

let fruits = ["apple", "banana", "cherry"];

// JavaScript is 0-indexed!
let first = fruits[0];   // "apple"
let second = fruits[1];  // "banana"
let third = fruits[2];   // "cherry"

console.log(first);
console.log(second);
console.log(third);
console.log(fruits.length);

fruits.push("date");
console.log(fruits[3]);
console.log(fruits.length);

temps ← [72, 85, 68, 91, 77]
hot ← 0

FOR EACH t IN temps
{
    IF (t > 80)
    {
        hot ← hot + 1
    }
}

DISPLAY("Hot days: " + hot)

temps = [72, 85, 68, 91, 77]
hot = 0

for t in temps:
    if t > 80:
        hot = hot + 1

print("Hot days:", hot)

let temps = [72, 85, 68, 91, 77];
let hot = 0;

for (let t of temps) {
    if (t > 80) {
        hot = hot + 1;
    }
}

console.log("Hot days:", hot);

values ← [34, 67, 23, 89, 45]
max ← values[1]

FOR EACH val IN values
{
    IF (val > max)
    {
        max ← val
    }
}

DISPLAY("Maximum: " + max)

values = [34, 67, 23, 89, 45]
max_val = values[0]  # Python is 0-indexed

for val in values:
    if val > max_val:
        max_val = val

print("Maximum:", max_val)

let values = [34, 67, 23, 89, 45];
let maxVal = values[0];  // JS is 0-indexed

for (let val of values) {
    if (val > maxVal) {
        maxVal = val;
    }
}

console.log("Maximum:", maxVal);

votes ← ["A", "B", "A", "C", "A", "B", "A"]
countA ← 0

FOR EACH vote IN votes
{
    IF (vote = "A")
    {
        countA ← countA + 1
    }
}

DISPLAY("Votes for A: " + countA)

votes = ["A", "B", "A", "C", "A", "B", "A"]
count_a = 0

for vote in votes:
    if vote == "A":
        count_a = count_a + 1

print(f"Votes for A: {count_a}")

let votes = ["A", "B", "A", "C", "A", "B", "A"];
let countA = 0;

for (let vote of votes) {
    if (vote === "A") {
        countA = countA + 1;
    }
}

console.log("Votes for A:", countA);

numbers ← [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
evens ← []  // Start with empty list

FOR EACH num IN numbers
{
    IF (num MOD 2 = 0)
    {
        APPEND(evens, num)
    }
}

DISPLAY(evens)  // [2, 4, 6, 8, 10]

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
evens = []

for num in numbers:
    if num % 2 == 0:
        evens.append(num)

print(evens)  # [2, 4, 6, 8, 10]

let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let evens = [];

for (let num of numbers) {
    if (num % 2 === 0) {
        evens.push(num);
    }
}

console.log(evens);  // [2, 4, 6, 8, 10]

PROCEDURE displayWelcome()
{
    DISPLAY("Welcome to AP CSP!")
    DISPLAY("Let's learn about procedures.")
}

// Call the procedure
displayWelcome()

def display_welcome():
    print("Welcome to AP CSP!")
    print("Let's learn about procedures.")

# Call the function
display_welcome()

function displayWelcome() {
    console.log("Welcome to AP CSP!");
    console.log("Let's learn about procedures.");
}

// Call the function
displayWelcome();

PROCEDURE greet(name)
{
    DISPLAY("Hello, " + name + "!")
}

// Call with different arguments
greet("Alice")  // Output: Hello, Alice!
greet("Bob")    // Output: Hello, Bob!

def greet(name):
    print(f"Hello, {name}!")

# Call with different arguments
greet("Alice")  # Output: Hello, Alice!
greet("Bob")    # Output: Hello, Bob!

function greet(name) {
    console.log(`Hello, ${name}!`);
}

// Call with different arguments
greet("Alice");  // Output: Hello, Alice!
greet("Bob");    // Output: Hello, Bob!

PROCEDURE square(x)
{
    result ← x * x
    RETURN result
}

answer ← square(5)  // answer = 25
DISPLAY(answer)

def square(x):
    result = x * x
    return result

answer = square(5)  # answer = 25
print(answer)

function square(x) {
    let result = x * x;
    return result;
}

let answer = square(5);  // answer = 25
console.log(answer);

PROCEDURE findMax(numbers)
{
    max ← numbers[1]
    
    FOR EACH num IN numbers
    {
        IF (num > max)
        {
            max ← num
        }
    }
    
    RETURN max
}

scores ← [87, 92, 78, 95, 88]
highest ← findMax(scores)
DISPLAY(highest)  // Output: 95

def find_max(numbers):
    max_val = numbers[0]
    
    for num in numbers:
        if num > max_val:
            max_val = num
    
    return max_val

scores = [87, 92, 78, 95, 88]
highest = find_max(scores)
print(highest)  # Output: 95

function findMax(numbers) {
    let max = numbers[0];
    
    for (let num of numbers) {
        if (num > max) {
            max = num;
        }
    }
    
    return max;
}

let scores = [87, 92, 78, 95, 88];
let highest = findMax(scores);
console.log(highest);  // Output: 95

PROCEDURE linearSearch(list, target)
{
    i ← 1
    
    REPEAT UNTIL (i > LENGTH(list))
    {
        IF (list[i] = target)
        {
            RETURN i
        }
        i ← i + 1
    }
    
    RETURN -1  // Not found
}

def linear_search(lst, target):
    for i in range(len(lst)):
        if lst[i] == target:
            return i
    
    return -1  # Not found

function linearSearch(list, target) {
    for (let i = 0; i < list.length; i++) {
        if (list[i] === target) {
            return i;
        }
    }
    
    return -1;  // Not found
}

// Check if ALL values are positive
PROCEDURE allPositive(numbers)
{
    FOR EACH num IN numbers
    {
        IF (num ≤ 0)
        {
            RETURN false  // Found one that isn't!
        }
    }
    
    RETURN true  // All were positive
}

// Check if list is sorted (ascending)
PROCEDURE isSorted(list)
{
    i ← 1
    
    REPEAT UNTIL (i ≥ LENGTH(list))
    {
        IF (list[i] > list[i + 1])
        {
            RETURN false  // Out of order!
        }
        i ← i + 1
    }
    
    RETURN true
}

# Check if ALL values are positive
def all_positive(numbers):
    for num in numbers:
        if num <= 0:
            return False  # Found one that isn't!
    
    return True  # All were positive

# Check if list is sorted (ascending)
def is_sorted(lst):
    for i in range(len(lst) - 1):
        if lst[i] > lst[i + 1]:
            return False  # Out of order!
    
    return True

// Check if ALL values are positive
function allPositive(numbers) {
    for (let num of numbers) {
        if (num <= 0) {
            return false;  // Found one that isn't!
        }
    }
    
    return true;  // All were positive
}

// Check if list is sorted (ascending)
function isSorted(list) {
    for (let i = 0; i < list.length - 1; i++) {
        if (list[i] > list[i + 1]) {
            return false;  // Out of order!
        }
    }
    
    return true;
}