Aşağıdaki kod parçasının çıktısı hangi şıkta doğru verilmiştir?

int[] sayilar = {12, 20, 16};
for (int i = 1; i < sayilar.length; i++) {
    System.out.print(sayilar[i] + " ");
}

D: Döngü i = 1'den başladığı için sayilar[0] = 12 atlanır; i = 1 → 20, i = 2 → 16, i = 3 < 3 yanlış → biter.

Aşağıdaki kod parçasının çıktısı hangi şıkta doğru verilmiştir?

int dizi[] = {1, 2, 3, 4, 5};
for (int i = 0; i <= dizi.length; ++i)
    System.out.print(dizi[i] + " ");

D: Koşul <= olduğu için son turda i = 5 olur; dizi[5] yoktur → ArrayIndexOutOfBoundsException. Hata oluşmadan önce 1 2 3 4 5 yazılmıştır, ama program hatayla biter. Doğrusu i < dizi.length.

Aşağıdaki kodun çıktısı nedir?

int[] p = {1, 2, 3};
int[] q = Arrays.copyOf(p, 5);
int[] r = Arrays.copyOfRange(q, 1, 4);
System.out.println(Arrays.toString(r));
System.out.println(p == q);

A: copyOf(p, 5) uzunluk büyük olduğu için sıfırla doldurur: [1, 2, 3, 0, 0]. copyOfRange(q, 1, 4) 1, 2, 3 indekslerini alır (4 hariç): [2, 3, 0]. q yeni bir dizi olduğundan p == q false'tur.

Aşağıdaki kodun çıktısı nedir?

int[] a = {3, 5, 7};
for (int x : a) {
    x = x * 2;
}
System.out.println(Arrays.toString(a));

B: Gelişmiş for'da x, hücrenin kopyasıdır; x'e atama diziyi değiştirmez. Diziyi değiştirmek için indeksli for gerekir: a[i] = a[i] * 2;

Koşul sayilar[i] > 10 && sayilar[i] % 3 == 0 olursa çıktı ne olur?

int[] sayilar = {12, 7, 3, 21, 1, 5, 8, 9, 20, 13, 12, 14, 16};
for (int i = 0; i < sayilar.length; i++) {
    if (sayilar[i] > 10 && sayilar[i] % 3 == 0) {
        System.out.print(sayilar[i] + " ");
    }
}

C: 10'dan büyük olanlar: 12, 21, 20, 13, 12, 14, 16. Bunlardan 3'e tam bölünenler 12, 21, 12. 3 ve 9 da 3'e bölünür ama 10'dan büyük değildir.

Koşul sayilar[i] < 10 && sayilar[i] % 2 == 0 olursa çıktı ne olur?

int[] sayilar = {12, 7, 3, 21, 1, 5, 8, 9, 20, 13, 12, 14, 16};
for (int i = 0; i < sayilar.length; i++) {
    if (sayilar[i] < 10 && sayilar[i] % 2 == 0) {
        System.out.print(sayilar[i] + " ");
    }
}

A: 10'dan küçük olanlar 7, 3, 1, 5, 8, 9; bunların içinde tek çift sayı 8'dir. B şıkkı || (veya) kullanılmış gibi düşünmektir.

Sınavdaki enBuyukEleman metodunda başlangıç değeri dizi[0] yerine 0 yazılırsa enBuyukEleman(new int[]{-8, -3, -5}) ne döndürür?

static int enBuyukEleman(int[] dizi) {
    int enBuyuk = 0;   // dizi[0] yerine
    for (int i = 0; i < dizi.length; i++)
        if (dizi[i] > enBuyuk)
            enBuyuk = dizi[i];
    return enBuyuk;
}

D: Hiçbir eleman 0'dan büyük olmadığı için koşul hiç sağlanmaz ve dizide olmayan 0 döner. Aday her zaman dizinin bir elemanı (dizi[0]) olmalıdır; o zaman sonuç −3 olurdu.

Sınavdaki ortalamaHesapla metodunda (double) dönüşümü unutulursa ortalamaHesapla(new int[]{4, 7, 2, 6}) ne döndürür?

static double ortalamaHesapla(int[] dizi) {
    int toplam = 0;
    for (int i = 0; i < dizi.length; i++)
        toplam += dizi[i];
    double ortalama = toplam / dizi.length;
    return ortalama;
}

B: toplam = 19; 19 / 4 iki int'in bölmesidir → 4 (kesir atılır). Sonra double'a atanınca 4.0 olur. Doğrusu (double) toplam / dizi.length → 4.75.

10'dan büyük ve 20'den küçük elemanları yazdıran metotta boşluğa hangisi yazılmalıdır?

static void yazdir(int[] dizi) {
    for (int i = 0; i < dizi.length; i++) {
        if ( ______ ) {
            System.out.println(dizi[i]);
        }
    }
}

D: İki koşul birlikte sağlanmalı: &&. A her sayı için true olur (her sayı ya 10'dan büyük ya 20'den küçüktür). B derlenmez: 10 < dizi[i] boolean üretir, boolean 20 ile karşılaştırılamaz. C 10 ve 20'yi de yazar.

Önceki sorudaki ortancaElemanBul metoduyla aşağıdaki kodun çıktısı nedir?

int[] a = {9, 2, 7, 4};
double m = ortancaElemanBul(a);
System.out.println(Arrays.toString(a) + " " + m);

C: Metoda dizinin başvurusu gider; Arrays.sort(dizi) main'deki a dizisini de sıralar. Özgün sıra korunmak isteniyorsa metot içinde dizi.clone() sıralanmalıdır.

Sınavdaki metot int[] d = diziOlusturVeDoldur(5); ile çağrılıyor. Hangisi her çalıştırmada kesinlikle doğrudur?

static int[] diziOlusturVeDoldur(int elemanSayisi) {
    int[] dizi = new int[elemanSayisi];
    Random rastgele = new Random();
    for (int i = 0; i < dizi.length; i++) {
        dizi[i] = rastgele.nextInt(100);
    }
    return dizi;
}

B: nextInt(100) 0 dahil, 100 hariç bir tam sayı üretir (0–99). Aynı sayı tekrar gelebilir, sıra rastgeledir. Metot yeni dizinin başvurusunu döndürür. java.util.Random için import gerekir.

Diziyi ters çevirmek isteyen bu kodun çıktısı nedir?

int[] a = {1, 2, 3, 4};
for (int i = 0; i < a.length; i++) {
    int t = a[i];
    a[i] = a[a.length - 1 - i];
    a[a.length - 1 - i] = t;
}
System.out.println(Arrays.toString(a));

A: Döngü tüm diziyi gezdiği için her çift iki kez takas edilir: i = 0, 1 diziyi ters çevirir, i = 2, 3 geri çevirir. Döngü yalnızca ortaya kadar (i < a.length / 2) dönmelidir.

Dersteki ara metodu için ara(d, 5) ne döndürür ve dizi[i] == hedef karşılaştırması kaç kez yapılır?

static int ara(int[] dizi, int hedef) {
    for (int i = 0; i < dizi.length; i++)
        if (dizi[i] == hedef) return i;
    return -1;
}
// main içinde:
int[] d = {8, 3, 6, 2};
System.out.println(ara(d, 5));

C: 5 dizide yoktur; dört elemanın hepsine bakılır (n karşılaştırma), döngü bitince return -1 çalışır. En kötü durum O(n).

Kabarcık sıralamanın yalnızca ilk geçişi yapılıyor. Çıktı nedir?

int[] a = {5, 1, 4, 2, 3};
for (int j = 0; j < a.length - 1; j++) {
    if (a[j] > a[j + 1]) {
        int t = a[j]; a[j] = a[j + 1]; a[j + 1] = t;
    }
}
System.out.println(Arrays.toString(a));

D: 5 her karşılaştırmada sağdaki küçük elemanla yer değiştirir ve en sona “kabarır”: [1,5,4,2,3] → [1,4,5,2,3] → [1,4,2,5,3] → [1,4,2,3,5]. Tam sıralama için n − 1 geçiş gerekir.

Aşağıdaki kod çalıştırıldığında ne olur?

int[][] m = new int[3][];
m[0] = new int[2];
m[2] = new int[4];
System.out.println(m[0].length + m[2].length);
System.out.println(m[1].length);

B: new int[3][] yalnızca dış diziyi oluşturur; m[1] hiç atanmadığı için null kalır. 2 + 4 = 6 yazıldıktan sonra m[1].length null üzerinden alan okumaya çalışır → NullPointerException.