1D Arrays (တန်းတစ်တန်းတည်းမှာ စီထားတဲ့ ဒေတာအစုများ)

B2.2.2 - Construct programs that apply arrays and Lists. This page: one-dimensional (1D) arrays.
မြန်မာလို: array (အရွယ်အစား ပုံသေ၊ အမျိုးအစားတူ ဒေတာစု) တွေနဲ့ List (ကြီးလာ၊ သေးသွားနိုင်တဲ့ ဒေတာစု) တွေကို သုံးတဲ့ program တွေကို ကိုယ်တိုင် တည်ဆောက်နိုင်ရပါမယ်။ ဒီစာမျက်နှာမှာတော့ one-dimensional (1D) array (တန်းတစ်တန်းတည်းမှာ စီထားတဲ့ ဒေတာအစု) တွေကို လေ့လာပါမယ်။

အဓိက အယူအဆများ

Array က အမျိုးအစားတူ တန်ဖိုးတွေကို ပုံသေ အရေအတွက်နဲ့ contiguous memory (memory ထဲမှာ ကြားမပြတ် ဆက်တိုက် ရှိတဲ့ နေရာ) ထဲမှာ သိမ်းပါတယ်။ Element (အစုထဲက အချက်) တစ်ခုချင်းကို သူ့ရဲ့ index (နေရာအမှတ်) နဲ့ ယူသုံးပြီး index က 0 ကနေ စပါတယ်။ (Python မှာ အရွယ်အစား ပုံသေ array မရှိပါဘူး။ Array နဲ့ အသုံးတူတာက list ဖြစ်ပြီး list က လိုသလို ကြီးလာ၊ သေးသွားနိုင်ပါတယ်။ Index နဲ့ ယူသုံးပုံကတော့ အတူတူပါပဲ။)

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]

Code ထဲက comment တွေက ဒီလို ပြောထားပါတယ်: Java မှာ အရွယ်အစား ပုံသေနဲ့ ကြေညာရင် element အားလုံးရဲ့ default value (သတ်မှတ်မထားရင် သုံးတဲ့ တန်ဖိုး) က 0 ဖြစ်ပါတယ်၊ ဒါမှမဟုတ် သိပြီးသား တန်ဖိုးတွေနဲ့ ကြေညာပြီး initialise (ပထမဆုံး တန်ဖိုး ထည့်) လုပ်လို့ ရပါတယ်။ Python list တွေကတော့ လိုသလို ကြီးလာလို့ အရွယ်အစား ပုံသေနဲ့ ကြေညာတာ မရှိပါဘူး။ new int[5] နဲ့ ညီတာက သုည ငါးခု ကြိုထည့်ထားတဲ့ list ပါ။

Element တွေကို ယူသုံးခြင်းနဲ့ ပြင်ခြင်း 

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

Comment တွေအရ scores[0] က ပထမ element (85)၊ scores[4] က နောက်ဆုံး element (78) ဖြစ်ပြီး scores[2] = 95 က element တစ်ခုကို ပြင်လိုက်တာပါ။

Array Length (array ထဲက element အရေအတွက်) 

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

Java code ထဲက comment အရ scores.length နောက်မှာ ကွင်း မပါပါဘူး၊ property (array ကိုယ်တိုင် သိမ်းထားတဲ့ တန်ဖိုး) ဖြစ်လို့ပါ။ Python ရဲ့ len() က list ရော string (စာသား) ရော နှစ်မျိုးလုံးမှာ သုံးလို့ရလို့ Python မှာ .length ထောင်ချောက် မရှိပါဘူး။

length က method (သီးခြား အလုပ်တစ်ခု လုပ်ပေးတဲ့ code အပိုင်း) မဟုတ်ဘဲ field (object ထဲက အချက်အလက် အကွက်) ဖြစ်ပါတယ် (ကွင်း မပါပါ)။ scores.length() လို့ ရေးရင် compile error (compile လုပ်ချိန်မှာ ဖြစ်တဲ့ error) ဖြစ်ပါတယ်။ String နဲ့ ယှဉ်ကြည့်ပါ: str.length() က method call (method ကို ခေါ်သုံးခြင်း) ဖြစ်လို့ ကွင်း ပါပါတယ်။

Traversal (element တိုင်းကို တစ်ခုချင်း ဖြတ်သွားခြင်း)

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 က 0 ကနေ scores.length - 1 အထိ သွားပါတယ်။ scores[scores.length] ကို ယူသုံးရင် ArrayIndexOutOfBoundsException (array ရဲ့ နယ်နိမိတ်ကို ကျော်ပြီး ယူလို့ ဖြစ်တဲ့ အမှား) ဖြစ်ပါတယ်။

Array ကို ပုံနဲ့ ကြည့်ခြင်း

scores ထဲမှာ index 0 မှာ 85၊ index 1 မှာ 72၊ index 2 မှာ 95၊ index 3 မှာ 60 နဲ့ index 4 မှာ 78 ရှိပါတယ်။ scores.length က 5 ဖြစ်လို့ သုံးလို့ရတဲ့ နောက်ဆုံး index က scores.length နုတ် 1၊ ဆိုလိုတာက 4 ပါ။ index 0 85 1 72 2 95 3 60 4 78 scores scores.length = 5 len(scores) = 5 last valid index = scores.length - 1 = 4 last valid index = len(scores) - 1 = 4

ပုံထဲက English စာတွေရဲ့ အဓိပ္ပာယ်: “index” က နေရာအမှတ်၊ “last valid index = scores.length - 1 = 4” က သုံးလို့ရတဲ့ နောက်ဆုံး index က scores.length - 1 = 4 ဖြစ်တယ်လို့ ဆိုလိုပါတယ်။ Python ကို ရွေးထားရင် ပုံက scores.length အစား len(scores) ကို ပြပါတယ်။

အဆင့်ဆင့် ရှင်းပြထားတဲ့ ဥပမာများ

ဥပမာ 1: အကြီးဆုံး တန်ဖိုးကို ရှာခြင်း

ပထမ element က အကြီးဆုံးလို့ အရင် ယူဆထားပြီး ကျန်တဲ့ 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

max က built-in function (Python မှာ အသင့်ပါတဲ့ function) ရဲ့ နာမည် ဖြစ်လို့ Python code မှာ variable (တန်ဖိုး သိမ်းထားတဲ့ နာမည်ပေးထားတဲ့ နေရာ) ကို largest လို့ နာမည်ပေးထားပါတယ်။

Index 0 ကို စတင် ခန့်မှန်းချက်အဖြစ် ယူထားပြီးသား ဖြစ်လို့ loop (ထပ်ခါထပ်ခါ run တဲ့ code အပိုင်း) က index 1 ကနေ စပါတယ်။ အငယ်ဆုံး တန်ဖိုး ရှာဖို့လည်း ဒီပုံစံကိုပဲ သုံးလို့ရပါတယ်၊ > ကို < လို့ ပြောင်းလိုက်ရုံပါပဲ။

ဥပမာ 2: ပေါင်းလဒ်နဲ့ ပျမ်းမျှ 

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

Python မှာ sum ကလည်း built-in function နာမည် ဖြစ်လို့ total လို့ နာမည်ပေးထားပါတယ်။ Python ရဲ့ / က ဒသမ ပါတဲ့ ရလဒ်ကို အမြဲ ပေးလို့ cast (type ပြောင်း) လုပ်စရာ မလိုပါဘူး။

(double) cast က မရှိမဖြစ် လိုပါတယ်။ မပါရင် integer division (ကိန်းပြည့် အချင်းချင်း စားရင် ဒသမ ပျောက်သွားတာ) ကြောင့် ရလဒ်ကို truncate (ဒသမ အပိုင်းကို ဖြတ်ပစ်) လုပ်သွားပါလိမ့်မယ်။ Integer (ကိန်းပြည့်) တွက်နည်းမှာ 247 / 5 က 49 ရပေမယ့် 247.0 / 5 ကတော့ 49.4 ရပါတယ်။

ဥပမာ 3: တန်ဖိုး တစ်ခု ဘယ်နှစ်ကြိမ် ပါလဲ ရေတွက်ခြင်း 

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).

ဥပမာ 4: Array ကို copy ကူးခြင်း (reference ထောင်ချောက်)

Java မှာ array တွေက object (class တစ်ခုကနေ ဖန်တီးထားတဲ့ instance) တွေ ဖြစ်ပါတယ်။ Array တစ်ခုကို နောက် array variable တစ်ခုထဲ ထည့်တဲ့ assignment (variable ထဲ တန်ဖိုး ထည့်ခြင်း) က ဒေတာကို copy မကူးဘဲ reference (object ရှိရာ memory နေရာကို ညွှန်းတဲ့ တန်ဖိုး) ကိုပဲ copy ကူးပါတယ်။

// 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!

Comment တွေက ဒီလို ပြောထားပါတယ်: ဒီနည်းက မှားပါတယ် (WRONG)၊ variable နှစ်ခုလုံးက array တစ်ခုတည်းကို ညွှန်းနေလို့ copy[0] ကို ပြင်လိုက်တာနဲ့ original[0] ကလည်း 99 ဖြစ်သွားပါတယ်။ Python list တွေကလည်း reference တွေ ဖြစ်လို့ အတူတူပါပဲ။

မှန်ကန်တဲ့ နည်းက 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

အခု copy[0] ကို ပြင်ပေမယ့် original[0] က 1 အတိုင်း ရှိနေပါတယ်။ Python မှာတော့ list အလွတ်ကနေ စပြီး append() နဲ့ element တွေကို တစ်ခုချင်း ထည့်ပါတယ်။ Python list တွေက append() လုပ်တိုင်း ကြီးလာပါတယ်။

Array variable တစ်ခုကို နောက်တစ်ခုထဲ assign လုပ်ရင် reference ကိုပဲ copy ကူးပါတယ်။ ဒီဥပမာတွေမှာ သီးခြား array တစ်ခု ရဖို့ array အသစ် တစ်ခုကို ဖန်တီးပြီး element တွေကို တစ်ခုချင်း copy ကူးပါ။

ဥပမာ 5: Array ရဲ့ အရွယ်အစားကို ပြောင်းခြင်း

Array တွေရဲ့ အရွယ်အစားက ပုံသေပါ။ Array ကို “ကြီးလာအောင်” လုပ်ချင်ရင် ပိုကြီးတဲ့ array အသစ် တစ်ခု ဖန်တီးပြီး ဒေတာတွေကို အဲဒီထဲ copy ကူးပါ:

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

Java code ထဲက comment တွေက အဆင့် သုံးဆင့်ကို ပြပါတယ်: အဆင့် 1 ပိုကြီးတဲ့ array ဖန်တီးပါ၊ အဆင့် 2 element တွေကို copy ကူးပါ၊ အဆင့် 3 reference ကို ပြန် assign လုပ်ပါ (data က array အသစ်ကို ညွှန်းသွားပါတယ်)။ Python list တွေကတော့ လိုသလို ကြီးလာလို့ ဒီလို ကိုယ်တိုင် အရွယ်အစား ပြောင်းတဲ့ ပုံစံ မလိုပါဘူး။ append() နဲ့ နေရာ နှစ်ခု ထပ်ထည့်ရင် Java ရဲ့ copy ကူးပြီး ချဲ့တဲ့ နည်းနဲ့ ရလဒ် အတူတူ ရပါတယ်။

ArrayList (ကြီးလာ၊ သေးသွားနိုင်တဲ့ list) က အတွင်းမှာ သုံးတဲ့ အယူအဆက ဒါပါပဲ: သူ့ array ပြည့်သွားရင် ပိုကြီးတဲ့ array တစ်ခု ဖန်တီးပြီး ဒေတာတွေကို copy ကူးပါတယ်။ Array အသစ်ကို အရင် array ရဲ့ တစ်ဆခွဲလောက် ကြီးအောင် လုပ်လို့ element ထည့်တိုင်း copy ကူးစရာ မလိုပါဘူး။ ဒီမှာ ကိုယ်တိုင် လုပ်ကြည့်တော့ အဲဒါအတွက် ဘယ်လောက် အလုပ် ပိုလုပ်ရလဲ ဆိုတာ မြင်ရပါတယ်။

ဥပမာ 6: ထပ်နေတဲ့ တန်ဖိုးကို ရှာခြင်း

Nested loop (loop ထဲမှာ ထပ်ပါတဲ့ loop) တွေကို သုံးပြီး တန်ဖိုး အတွဲတိုင်းကို နှိုင်းယှဉ်ပါ:

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

&& !duplicateFound condition (မှန်လား မှားလား စစ်တဲ့ အခြေအနေ) က early exit (စောစော ရပ်ခြင်း) ကို ပေးပါတယ်: တူတဲ့ အတွဲ တွေ့ပြီးရင် ဆက်ရှာစရာ အကြောင်း မရှိတော့ပါဘူး။ Python code ထဲက comment က while loop တွေက early exit စစ်တာကို loop condition ထဲမှာပဲ ထားပေးလို့ break မလိုဘူးလို့ ပြောထားပါတယ်။

Quick Check (အမြန် စစ်ဆေးမေးခွန်း)

Q1. int[] arr = new int[6] ဆိုရင် သုံးလို့ရတဲ့ နောက်ဆုံး index က ဘာလဲ။

Q2. int[] b = a; b[0] = 99; ပြီးနောက် a[0] က ဘာလဲ။

Q3. int[] arr = new int[4]; ပြီးနောက် arr[0] က ဘာလဲ။

Q4. Array arr ရဲ့ အရွယ်အစားကို ယူတဲ့ မှန်ကန်တဲ့ နည်းက ဘယ်ဟာလဲ။

Q5. ဒီ code ကို run ရင် ဘာဖြစ်မလဲ။

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

Q6. အကြီးဆုံး ရှာတဲ့ algorithm (အယ်လ်ဂိုရီသမ်၊ ပြဿနာကို အဆင့်ဆင့် ဖြေရှင်းတဲ့ နည်းလမ်း) က ဘာကြောင့် max = 0 အစား max = numbers[0] နဲ့ initialise လုပ်တာလဲ။

Trace Exercise (code ကို တစ်ဆင့်ချင်း လိုက်ကြည့်ခြင်း)

Array ထဲက အကြီးဆုံး တန်ဖိုးကို ရှာတဲ့ ဒီ code ကို trace လုပ်ပါ။ နှိုင်းယှဉ်မှု တစ်ခုစီ ပြီးတိုင်း numbers[i] နဲ့ max ရဲ့ တန်ဖိုးကို ဖြည့်ပါ။

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)

numbers[i] > max? ကော်လံမှာ yes (ဟုတ်တယ်) ဒါမှမဟုတ် no (မဟုတ်ဘူး) ကို English လို ရိုက်ထည့်ပါ။

inumbers[i]numbers[i] > max?ပြီးနောက် max
--- (စတင် တန်ဖိုး)
1
2
3
4

နောက်ဆုံး output (program က ထုတ်ပြတဲ့ ရလဒ်): Maximum:

Code Completion (code ကွက်လပ် ဖြည့်ခြင်း)

မူလ array ကို မပြောင်းဘဲ array ရဲ့ ပြောင်းပြန် copy တစ်ခုကို ဖန်တီးတဲ့ code ကို ပြီးအောင် ဖြည့်ပါ။

ဒီ algorithm က မူလ array ထဲက element တစ်ခုချင်းကို array အသစ်ထဲမှာ မှန်ထဲက ပုံလို ပြောင်းပြန်ဘက်က နေရာဆီ ပို့ပါတယ်။ ပြောင်းပြန် 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 Error (အမှား ရှာခြင်း)

ဒီ code က မူလ array မပြောင်းအောင် array ရဲ့ သီးခြား copy တစ်ခု ဖန်တီးဖို့ ကြိုးစားပါတယ်။ ဒါပေမယ့် Java ရဲ့ reference နဲ့ value ကွာခြားချက် ထောင်ချောက်ထဲ ကျသွားလို့ "copy" ကို ပြင်လိုက်ရင် မူလ array ပါ ပြောင်းသွားပါတယ်။ (Line 3 နဲ့ 4 က comment တွေက "မူလ array ကို မထိခိုက်ဘဲ စိတ်ချလက်ချ ပြင်လို့ရအောင် copy တစ်ခု ကူးမယ်" လို့ ပြောထားပြီး line 8 က 10 ကို print ထုတ်မယ်လို့ မျှော်လင့်ထားပါတယ်။) အမှားပါတဲ့ line ကို ရွေးပါ၊ ပြီးရင် ပြင်နည်းကို ရွေးပါ။

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

Line 5 အတွက် မှန်ကန်တဲ့ ပြင်နည်းကို ရွေးပါ:

ရွေးစရာ (a) က array အသစ် ဖန်တီးပေမယ့် ဒေတာကို copy လုံးဝ မကူးလို့ element တိုင်းက 0 ဖြစ်နေပါလိမ့်မယ်။ ရွေးစရာ (b) က array အသစ် ဖန်တီးပြီး ချက်ချင်း လွှင့်ပစ်လိုက်ပါတယ်: ဒုတိယ statement (code ထဲက ညွှန်ကြားချက်) က copy ကို မူလ array ဆီ ပြန်ညွှန်းစေလို့ နာမည် နှစ်ခုလုံးက array တစ်ခုတည်းကို မျှသုံးနေဆဲပါ။ ရွေးစရာ (c) က ကိုယ်တိုင် ရေးနိုင်ရမယ့် loop နဲ့ copy ကူးနည်းပါ။ (original.clone() နဲ့ Arrays.copyOf(original, original.length) တို့ကလည်း တကယ့် သီးခြား copy တစ်ခုကို ဖန်တီးပေးပါတယ်။)

Predict the Output (output ကို ကြိုခန့်မှန်းခြင်း)

ဒီ code က accumulator pattern (ရလဒ်ကို တဖြည်းဖြည်း စုပေါင်းသွားတဲ့ ပုံစံ) ကို ပြပါတယ်: array ကို traverse လုပ်ပြီး element တစ်ခုချင်းကို sum variable ထဲ ပေါင်းထည့်ရင်း running total (တဖြည်းဖြည်း ပေါင်းသွားတဲ့ စုစုပေါင်း) ကို တည်ဆောက်ပါတယ်။ 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);

အဖြေကို program ထုတ်ပေးတဲ့ အတိုင်း English လို ရိုက်ထည့်ပါ:

Practice Exercises (လေ့ကျင့်ခန်းများ)

Core (အခြေခံ အဆင့်)

  1. တန်ဖိုး ထည့်ပြီး print ထုတ်ခြင်း။ {8, 3, 15, 7, 12} တန်ဖိုးတွေ ပါတဲ့ integer 5 ခု array တစ်ခုကို ဖန်တီးတဲ့ code ကို main (program စ run တဲ့ method) ထဲမှာ ရေးပါ။ Element တစ်ခုချင်းကို သူ့ index နဲ့အတူ line တစ်ကြောင်းစီမှာ print ထုတ်ပါ (ဥပမာ [0] = 8)။

  2. အငယ်ဆုံး တန်ဖိုးကို ရှာခြင်း။ int[] temps = {22, 18, 25, 15, 20} ပေးထားပါတယ်။ အငယ်ဆုံး တန်ဖိုးနဲ့ အဲဒီ တန်ဖိုး ရှိတဲ့ index ကို ရှာပြီး print ထုတ်ပါ။

  3. သတ်မှတ် အမှတ်နဲ့ အထက် ရတာတွေကို ရေတွက်ခြင်း။ int[] scores = {72, 85, 60, 91, 45, 78} ပေးထားပါတယ်။ 70 ဒါမှမဟုတ် 70 ထက် ပိုရတဲ့ အမှတ် ဘယ်နှစ်ခု ရှိလဲ ရေတွက်ပြီး print ထုတ်ပါ။

  4. စုံကိန်း element တွေရဲ့ ပေါင်းလဒ်။ Integer array တစ်ခု ပေးထားပါတယ်။ စုံကိန်း တန်ဖိုးတွေကိုပဲ ပေါင်းပြီး ပေါင်းလဒ်ကို print ထုတ်ပါ။

Extension (တိုးချဲ့ အဆင့်)

  1. ပြောင်းပြန် copy။ မူလ array ကို မပြောင်းဘဲ {1, 2, 3, 4, 5} ရဲ့ ပြောင်းပြန် copy တစ်ခုကို ဖန်တီးပါ။ မှန်မမှန် စစ်ဖို့ array နှစ်ခုလုံးကို print ထုတ်ပါ။

  2. ထပ်နေတာတွေကို ဖယ်ခြင်း။ {3, 7, 3, 2, 7, 5, 2} ပေးထားပါတယ်။ တန်ဖိုး တစ်မျိုးကို တစ်ကြိမ်စီပဲ ပါတဲ့ array အသစ် တစ်ခုကို ဖန်တီးပါ (ပထမဆုံး ပေါ်လာတဲ့ အစဉ်အတိုင်း)။ ရလဒ်ကို print ထုတ်ပါ။

Challenge (စိန်ခေါ်မှု အဆင့်)

  1. အရွယ်အစား ချဲ့ပြီး ထည့်ခြင်း။ int[] data = {10, 20, 30, 40, 50} ပေးထားပါတယ်။ Element တစ်ခုစာ ပိုကြီးတဲ့ array အသစ် တစ်ခုကို ဖန်တီးပြီး index 2 မှာ 25 ကို ထည့်ကာ ကျန်တဲ့ element တွေကို ညာဘက်ကို တစ်နေရာစီ ရွှေ့တဲ့ code ကို ရေးပါ။ ရလဒ်က {10, 20, 25, 30, 40, 50} ဖြစ်ရပါမယ်။

GitHub Classroom (အလိုအလျောက် စစ်ဆေးတဲ့ test တွေပါတဲ့ programming assignment များ)

1D Arrays
15 exercises across 6 Java files: traversal, counting, transformation, copying, resizing, plus the GradeArray mini-project. Autograded with 58 JUnit tests.

A class assignment on GitHub Classroom: use it when your teacher has set it. It needs a free GitHub account.

Core Accept the assignment on GitHub

Working in the Codespace

  1. Accept and open. Accept the assignment above, open the link in the email from GitHub, then press Open in Codespace. In Java, change the status bar from Lightweight to Standard mode.
  2. Write and check. Open src/ArraysCore.java and complete each TODO. Open src/ArraysCore.java first, implement the TODOs, then run ./run-tests.sh in the Codespaces Terminal. Press Run and compare the output with the comments, or run bash run-tests.sh in the Terminal.
  3. Submit. In Source Control, write a message, press Commit, then Sync Changes. Your teacher’s feedback arrives as a pull request called Feedback.

The full Codespace guide, with pictures

ဆက်စပ် ခေါင်းစဉ်များ

  • အရင် လေ့လာထားရမယ့် ခေါင်းစဉ်များ: Selection (condition ပေါ်မူတည်ပြီး လမ်းကြောင်း ရွေးခြင်း) နဲ့ Iteration (ထပ်ခါထပ်ခါ လုပ်ခြင်း): traversal အတွက် loop တွေ လိုလို့ပါ
  • ဆက်စပ် ခေါင်းစဉ်: Searching Algorithms (ရှာဖွေရေး algorithm များ): linear search (တစ်ခုချင်း ဆက်တိုက် ရှာနည်း) နဲ့ binary search (တစ်ဝက်စီ ခွဲပြီး ရှာနည်း) က array တွေပေါ်မှာ အလုပ်လုပ်ပါတယ်
  • နောက်ထပ် လေ့လာမယ့် ခေါင်းစဉ်: 2D Arrays (row နဲ့ column ပါတဲ့ ဇယားကွက် array များ): array တွေနဲ့ ဖွဲ့ထားတဲ့ array
  • ဆက်ပြီး လေ့လာရန်: ArrayList၊ Sorting (အစဉ်တကျ စီခြင်း): array element တွေကို နေရာ ပြန်စီခြင်း