1D Arrays

IB Syllabus: B2.2.2 - Describe the characteristics of a 1D array. Construct algorithms using 1D arrays.

Key Concepts

An array stores a fixed number of values of the same type in contiguous memory. Each element is accessed by its index, starting at 0. (Python has no fixed-size array - its equivalent is the list, which grows and shrinks dynamically. Indexing works the same way.)

Declaration 

// Declare with a fixed size - all elements default to 0
int[] scores = new int[5];

// Declare and initialise with known values
int[] scores = {85, 72, 91, 60, 78};

# Python lists grow dynamically - there is no fixed-size declaration.
# The twin of new int[5] is a pre-built list of five zeros:
scores = [0, 0, 0, 0, 0]

# Create a list with known values
scores = [85, 72, 91, 60, 78]

Access and Modification 

System.out.println(scores[0]);   // 85 - first element
System.out.println(scores[4]);   // 78 - last element
scores[2] = 95;                  // modify an element

print(scores[0])   # 85 - first element
print(scores[4])   # 78 - last element
scores[2] = 95     # modify an element

Array Length 

System.out.println(scores.length);   // 5 - note: no parentheses, it's a property

print(len(scores))   # 5 - len() works on lists AND strings, no .length trap in Python

length is a field (no parentheses), not a method. Writing scores.length() is a compile error. Compare with String: str.length() uses parentheses because it is a method call.

Traversal

The standard pattern to visit every element:

for (int i = 0; i < scores.length; i++) {
    System.out.println("scores[" + i + "] = " + scores[i]);
}

for i in range(len(scores)):
    print("scores[" + str(i) + "] = " + str(scores[i]))

Index i runs from 0 to scores.length - 1. Accessing scores[scores.length] causes an ArrayIndexOutOfBoundsException.

Visual Layout 

Index:    0     1     2     3     4
        ┌─────┬─────┬─────┬─────┬─────┐
scores: │  85 │  72 │  95 │  60 │  78 │
        └─────┴─────┴─────┴─────┴─────┘

scores.length = 5
Last valid index = scores.length - 1 = 4

Worked Examples

Example 1: Find Maximum

Start by assuming the first element is the largest, then compare against every other element.

int[] numbers = {34, 67, 12, 89, 45};

int max = numbers[0];   // assume first element is the largest
for (int i = 1; i < numbers.length; i++) {
    if (numbers[i] > max) {
        max = numbers[i];
    }
}
System.out.println("Maximum: " + max);   // Maximum: 89

numbers = [34, 67, 12, 89, 45]

# max is a built-in function name in Python, so we call it largest
largest = numbers[0]   # assume first element is the largest
for i in range(1, len(numbers)):
    if numbers[i] > largest:
        largest = numbers[i]
print("Maximum:", largest)   # Maximum: 89

The loop starts at index 1 because index 0 is already our initial guess. The same pattern works for minimum - just flip > to <.

Example 2: Sum and Average 

int[] numbers = {34, 67, 12, 89, 45};

int sum = 0;
for (int i = 0; i < numbers.length; i++) {
    sum = sum + numbers[i];
}
double average = (double) sum / numbers.length;
System.out.println("Sum: " + sum + ", Average: " + average);
// Sum: 247, Average: 49.4

numbers = [34, 67, 12, 89, 45]

# sum is a built-in function name in Python, so we call it total
total = 0
for i in range(len(numbers)):
    total = total + numbers[i]
average = total / len(numbers)   # / always gives a decimal in Python - no cast needed
print("Sum: " + str(total) + ", Average: " + str(average))
# Sum: 247, Average: 49.4

The (double) cast is essential - without it, integer division would truncate the result. 247 / 5 gives 49 in integer arithmetic, but 247.0 / 5 gives 49.4.

Example 3: Count Occurrences 

int[] numbers = {34, 67, 12, 67, 45};

int target = 67;
int count = 0;
for (int i = 0; i < numbers.length; i++) {
    if (numbers[i] == target) {
        count++;
    }
}
System.out.println(target + " appears " + count + " time(s).");
// 67 appears 2 time(s).

numbers = [34, 67, 12, 67, 45]

target = 67
count = 0
for i in range(len(numbers)):
    if numbers[i] == target:
        count = count + 1
print(str(target) + " appears " + str(count) + " time(s).")
# 67 appears 2 time(s).

Example 4: Copying Arrays (The Reference Trap)

Arrays in Java are objects. Assigning one array to another copies the reference, not the data.

// WRONG - both variables point to the same array
int[] original = {1, 2, 3, 4, 5};
int[] copy = original;
copy[0] = 99;
System.out.println(original[0]);   // 99 - original changed too!

# WRONG - both variables point to the same list (Python lists are references too)
original = [1, 2, 3, 4, 5]
copy = original
copy[0] = 99
print(original[0])   # 99 - original changed too!

The correct way - element-by-element copy:

int[] original = {1, 2, 3, 4, 5};
int[] copy = new int[original.length];

for (int i = 0; i < original.length; i++) {
    copy[i] = original[i];
}

copy[0] = 99;
System.out.println(original[0]);   // 1 - original is untouched

original = [1, 2, 3, 4, 5]
copy = []   # start empty - Python lists grow with append()

for i in range(len(original)):
    copy.append(original[i])

copy[0] = 99
print(original[0])   # 1 - original is untouched

This reference vs copy distinction is one of the most commonly tested concepts in IB exams. Always create a new array and copy elements individually.

Example 5: Resizing an Array

Arrays have a fixed size. To “grow” an array, create a larger one and copy the data across:

int[] data = {10, 20, 30};

// Step 1: Create a larger array
int[] temp = new int[data.length + 2];

// Step 2: Copy elements
for (int i = 0; i < data.length; i++) {
    temp[i] = data[i];
}

// Step 3: Reassign the reference
data = temp;

System.out.println(data.length);   // 5

data = [10, 20, 30]

# Python lists grow dynamically, so the manual resize pattern is not needed.
# Appending two extra slots gives the same result as Java's copy-and-grow:
data.append(0)
data.append(0)

print(len(data))   # 5

This resize pattern is exactly how ArrayList works internally - it just does it automatically behind the scenes. Understanding it manually is the point.

Example 6: Duplicate Detection

Compare every pair using nested loops:

int[] numbers = {34, 67, 12, 67, 45};
boolean duplicateFound = false;

for (int i = 0; i < numbers.length - 1 && !duplicateFound; i++) {
    for (int j = i + 1; j < numbers.length && !duplicateFound; j++) {
        if (numbers[i] == numbers[j]) {
            duplicateFound = true;
            System.out.println("Duplicate found: " + numbers[i]
                               + " at index " + i + " and index " + j);
        }
    }
}
// Duplicate found: 67 at index 1 and index 3

numbers = [34, 67, 12, 67, 45]
duplicate_found = False

# while loops keep the early-exit check in the loop condition (no break needed)
i = 0
while i < len(numbers) - 1 and duplicate_found == False:
    j = i + 1
    while j < len(numbers) and duplicate_found == False:
        if numbers[i] == numbers[j]:
            duplicate_found = True
            print("Duplicate found: " + str(numbers[i])
                  + " at index " + str(i) + " and index " + str(j))
        j = j + 1
    i = i + 1
# Duplicate found: 67 at index 1 and index 3

The && !duplicateFound condition provides an early exit - no point continuing once a match is found.

Quick Code Check

Q1. Given int[] arr = new int[6], what is the last valid index?

Q2. After int[] b = a; b[0] = 99; - what is a[0]?

Q3. What is arr[0] after int[] arr = new int[4];?

Q4. Which is the correct way to get the size of an array arr?

Q5. What happens when this code runs?

int[] numbers = {10, 20, 30, 40, 50};
for (int i = 0; i <= numbers.length; i++) {
    System.out.println(numbers[i]);
}

Q6. Why does the find-maximum algorithm initialise max = numbers[0] instead of max = 0?

Trace Exercise

Trace this code that finds the maximum value in an array. Fill in the value of numbers[i] and max after each comparison.

int[] numbers = {34, 67, 12, 89, 45};

int max = numbers[0];   // max = 34
for (int i = 1; i < numbers.length; i++) {
    if (numbers[i] > max) {
        max = numbers[i];
    }
}
System.out.println("Maximum: " + max);

numbers = [34, 67, 12, 89, 45]

largest = numbers[0]   # largest = 34 (max is a built-in name in Python)
for i in range(1, len(numbers)):
    if numbers[i] > largest:
        largest = numbers[i]
print("Maximum:", largest)
inumbers[i]numbers[i] > max?max after
--- (initial)
1
2
3
4

Final output: Maximum:

Code Completion

Complete the code that creates a reversed copy of an array without modifying the original.

This algorithm maps each element from the original array to its mirror position in a new array. Fill in the blanks to complete the reversed copy:

int[] original = {1, 2, 3, 4, 5};
int[] reversed = new int[];

for (int i = 0; i < original.length; i++) {
    reversed[] = original[i];
}

System.out.println(reversed[0]);  // prints

Spot the Bug

This code attempts to create an independent copy of an array so the original stays unchanged, but it falls into Java's reference-vs-value trap - modifying the "copy" also changes the original. Click the buggy line, then pick the fix.

1int[] original = {10, 20, 30, 40, 50}; 2 3// Make a copy so we can modify it safely 4// without affecting the original 5int[] copy = original; 6 7copy[0] = 99; 8System.out.println(original[0]); // expects 10

Pick the correct fix for line 5:

Option (a) creates a new array but doesn’t copy the data - all elements would be 0. Option (b) uses .clone() which works but is not covered in IB. The correct IB approach is a loop copy (option c).

Output Prediction

This code demonstrates the accumulator pattern - it traverses an array and builds a running total by adding each element to a sum variable. What is the exact output?

int[] arr = {10, 20, 30, 40, 50};
int sum = 0;
for (int i = 0; i < arr.length; i++) {
    sum = sum + arr[i];
}
System.out.println("Sum: " + sum);

Type your answer:

Practice Exercises

Core

  1. Input and Print - Write code in main that creates an array of 5 integers with the values {8, 3, 15, 7, 12}. Print each element on its own line with its index (e.g., [0] = 8).

  2. Find Minimum - Given int[] temps = {22, 18, 25, 15, 20}, find and print the minimum value and the index where it occurs.

  3. Count Above Threshold - Given int[] scores = {72, 85, 60, 91, 45, 78}, count and print how many scores are 70 or above.

  4. Sum of Even Elements - Given an array of integers, calculate and print the sum of only the even values.

Extension

  1. Reverse Copy - Create a reversed copy of {1, 2, 3, 4, 5} without modifying the original. Print both arrays to verify.

  2. Remove Duplicates - Given {3, 7, 3, 2, 7, 5, 2}, create a new array containing only the unique values (in order of first appearance). Print the result.

Challenge

  1. Resize and Insert - Given int[] data = {10, 20, 30, 40, 50}, write code that creates a new array one element larger, inserts the value 25 at index 2, and shifts the remaining elements right. The result should be {10, 20, 25, 30, 40, 50}.

GitHub Classroom

1D Arrays
15 exercises across 6 Java files: traversal, counting, transformation, copying, resizing, plus the GradeArray mini-project. Autograded with 58 JUnit tests.
Core Open in GitHub
Codespace Setup Instructions (click to expand)

First Time Setup

  1. Click “Open in GitHub” above, then click the green “Accept this assignment” button
  2. Check the email registered with your GitHub account: click the link there to open your repository. This avoids access issues and means your teacher does not need to share links manually
  3. Wait for your repository to be created, then click “Open in Codespace”
  4. Wait for the Codespace to finish loading (you’ll see VS Code in your browser)

Important: Switch to Standard Mode

  1. Look at the bottom status bar. If it says Java: Lightweight Mode, click on it and select Standard
  2. Wait for Java to finish loading (status bar will say Java: Ready)
  3. Without Standard Mode, the Run button won’t work and you’ll get “Main method not found” errors

Dismiss Popups

You’ll see two notification popups. Dismiss them both:

  • “Would you like VS Code to periodically run git fetch?” → Click No
  • “There’s a pull request associated with main” → Click Don’t Show Again

These are housekeeping popups, not part of the assignment.

How to Code

  1. Open src/ArraysCore.java. This is the only file you need to edit
  2. Complete each // TODO sectionOpen src/ArraysCore.java first, implement the TODOs, then run ./run-tests.sh in the Codespaces Terminal.
  3. Click the Run button (▶ above main) to test your output
  4. Compare your output with the expected output written in the comments above each task

How to Check Your Code

You can check your work in two ways:

Option A: Run your code directly

  • Click the Run button (▶) above main in ArraysCore.java
  • Compare your printed output with the expected output shown in the comments above each task

Option B: Run the autograder tests

  • Open the Terminal (Menu → Terminal → New Terminal)
  • Type bash run-tests.sh and press Enter
  • Green ✓ = test passed, Red ✗ = test failed
  • Each test tells you what it expected. Read the error message to fix your code

How to Submit

  1. Click the Source Control icon (branch icon) in the left sidebar
  2. Type a message like completed tasks in the message box
  3. Click the green Commit button
  4. If asked “stage all changes?” → click Always
  5. Click Sync Changes → if asked about push/pull → click OK, Don’t Show Again
  6. Done! Autograding runs automatically. Your teacher can see your results in the GitHub Classroom dashboard

How to Review Feedback

  1. Go to your repository on GitHub
  2. Click the “Pull requests” tab at the top
  3. Open the pull request called “Feedback”
  4. Click the “Files changed” tab. You’ll see your teacher’s comments on specific lines of your code
  5. Read through each comment carefully, then fix your code in Codespaces
  6. Run bash run-tests.sh in your Codespaces Terminal to check your fixes
  7. Commit and push again (repeat steps 12-17). The autograder will re-run automatically

Connections

© EduCS.me — A resource hub for Computer Science education

This site uses Just the Docs, a documentation theme for Jekyll.