Nangungunang 50 Array na Mga Tanong at Sagot sa Panayam (2025)

Narito ang mga tanong at sagot sa panayam ng Array para sa mga fresher pati na rin sa mga may karanasang kandidato upang makuha ang kanilang pangarap na trabaho. Ang mga array ay isang mahalagang bahagi ng programming, at iba't ibang mga coding na wika tulad ng C, C++, Python, Java, at Perl ay gumagamit ng mga array.

1) Ano ang ibig mong sabihin sa isang Array?

• Ang array ay isang set ng magkatulad na uri ng data.
• Ang mga arrays object ay nag-iimbak ng maraming variable na may parehong uri.
• Maaari itong magkaroon ng mga primitive na uri at object reference.
• Ang mga array ay palaging naayos

Libreng PDF Download: Array Interview Questions & Answers

---

2) Paano lumikha ng isang Array?

Ang isang Array ay idineklara na katulad ng kung paano idineklara ang isang variable, ngunit kailangan mong magdagdag ng [] pagkatapos ng uri. Halimbawa: int [] intArray; Maaari naming ideklara ang Java array bilang isang field, static na field, isang lokal na variable, o parameter, tulad ng anumang iba pang variable. Ang array ay isang koleksyon ng mga variable ng ganoong uri. Narito ang ilan pang halimbawa ng deklarasyon ng array ng Java:

String [] stringArray;

MyClass [] myClassArray;

Pareho ang kaso para sa iba pang mga programming language.

---

3) Mga kalamangan at kawalan ng Array?

Bentahe:

• Maaari naming ilagay sa lugar ang iba pang mga istruktura ng data tulad ng mga stack, queues, mga naka-link na listahan, mga puno, mga graph, atbp. sa Array.
• Maaaring pag-uri-uriin ng mga array ang maraming elemento nang sabay-sabay.
• Maa-access natin ang isang elemento ng Array sa pamamagitan ng paggamit ng index.

Disadvantages:

• Kailangan nating ideklara ang Sukat ng isang array nang maaga. Gayunpaman, maaaring hindi namin alam kung anong laki ang kailangan namin sa oras ng deklarasyon ng array.
• Ang array ay static na istraktura. Nangangahulugan ito na ang laki ng array ay palaging naayos, kaya hindi namin maaaring taasan o bawasan ang paglalaan ng memorya.

---

4) Maaari ba nating baguhin ang laki ng isang array sa oras ng pagtakbo?

Hindi, hindi namin mababago ang laki ng array. Bagama't mayroong mga katulad na uri ng data na magagamit na nagpapahintulot sa pagbabago sa laki.

---

5) Maaari ka bang magdeklara ng isang array nang hindi nagtatalaga ng laki ng isang array?

Hindi, hindi kami makakapagdeklara ng array nang hindi nagtatalaga ng laki. Kung idedeklara namin ang isang array na walang sukat, ito ay magtapon ng compile time error Halimbawa: mga marka = bagong int []; //COMPILER ERROR

---

6) Ano ang default na halaga ng Array?

Ang anumang bagong Array ay palaging sinisimulan na may default na halaga tulad ng sumusunod

• Para sa byte, maikli, int, mahaba - ang default na halaga ay zero (0).
• Para sa float, double - default na halaga ay 0.0.
• Para sa Boolean – ang default na halaga ay mali.
• Para sa object - ang default na halaga ay null.

---

7) Paano mag-print ng elemento ng Array?

Narito ang code upang i-print ang elemento ng array.

int schoolmarks [] = {25, 30, 50, 10, 5 };

System.out.println (Arrays.toString (schoolmarks));

Ang output ay: [25, 30, 50, 10, 5]

---

8) Paano ihambing ang Dalawang Array?

Kung ang 2 array ay may parehong laki at uri ng data, maaaring gawin ang paghahambing gamit ang "Arrays.equal ()"

int [] num1 = { 1, 2, 3 };

int[] num2 = { 4, 5, 6 };

System.out.println (Arrays. Equals (num1, num2)); //false

Int [] num3 = {1, 2, 3};

System.out.println (Arrays.equals (num1, num3)); //true

---

9) Paano mag-uri-uriin ang isang Array?

Posible gamit ang built static na paraan na Arrays. uri ().

Int Marks [] = {12, 5, 7, 9};

Arrays.sort(Marks);

System.out.println(Arrays.toString(Marks));//[5, 7, 9, 12]

---

10) Maaari ba nating ideklara ang laki ng array bilang negatibong numero?

Hindi. Hindi namin maipahayag ang negatibong integer bilang laki ng array. Kung idineklara namin, walang magiging error sa compile-time. Gayunpaman, makakakuha tayo ng NegativeArraySizeException sa oras ng pagtakbo.

---

11) Kailan tayo makakakuha ng ArrayStoreException?

Ito ay isang runtime exception. Halimbawa, maaari lamang kaming mag-imbak ng mga elemento ng string sa isang String Array. Kung sinuman ang sumusubok na magpasok ng elemento ng integer sa String Array na ito, makakakuha tayo ng ArrayStoreException sa oras ng pagtakbo.

---

12) Maaari ba tayong magdagdag o magtanggal ng elemento pagkatapos magtalaga ng array?

Hindi hindi pwede.

---

13) Ano ang kahulugan ng anonymous array? Ipaliwanag gamit ang isang halimbawa?

Ang ibig sabihin ng anonymous na array ay array na walang anumang reference. Halimbawa:-

//Creating anonymous arrays

System.out.println(new int[]{11, 12, 13, 14, 15}.length); //Output : 5

System.out.println(new int[]{31, 94, 75, 64, 41}[1]); //Output : 94 }}

---

14) Mayroon bang pagkakaiba sa pagitan ng int[] a at int a[]?

Walang pinagkaiba pareho ang legal pahayag.

---

15) Mayroong 2 int type array data type. Ang isa ay naglalaman ng 50 elemento, at isa pa ay naglalaman ng 30 elemento. Maaari ba nating italaga ang hanay ng 50 elemento sa hanay ng 30 elemento?

Oo maaari kaming magtalaga kung dapat silang pareho ang uri. Susuriin ng compiler ang tanging uri ng array, hindi ang laki.

int[] ab = new int[30];

int[] cd = new int[50];

a = b; //Compiler checks only type, not the size

---

16) int a[] = new int[3]{1, 2, 3} – ito ba ay isang tamang paraan upang magdeklara ng mga arrays sa java?

Hindi. Hindi namin dapat banggitin ang laki ng array kapag nagbibigay kami ng mga elemento ng array.

---

17) Paano kopyahin ang isang array sa isa pang array?

Sa ibaba ng apat na trick ay magagamit sa java upang kopyahin ang isang array.

1. Gamit ang "Para sa loop"
2. Gamit ang pamamaraang "Arrays.copyOf()".
3. Gamit ang pamamaraang "System.arraycopy()".
4. Gamit ang pamamaraang "clone()".

---

18) Ano ang mga "jagged" arrays sa java?

Ang Jagged Arrays ay Arrays ay naglalaman ng mga array na may iba't ibang haba. Ang mga jagged array ay kilala rin bilang multidimensional array.

---

19) Kapag nangyari ang ArrayIndexOutOfBoundsException?

Isa itong eksepsiyon sa run time. Mangyayari ito kapag sinubukan ng program na i-access ang di-wastong index ng isang array. Mas mataas ang index kaysa sa laki ng array o negatibong index.

---

20) Maaari mo bang ipaliwanag ang iba't ibang mga hakbang ng pagdedeklara ng mga multidimensional array sa Java?

//2D Arrays

int[][] twoArray1;

int twoArray2[][];

int[] twoArray3[];

//3D Arrays

int[][][] threeArray1;

int threeArray2[][][];

int[] threeArray3[][];

int[][] threeArray4[];

//4D Arrays

int[][][][] fourArray1;

int fourArray2[][][][];

int[] fourArray3[][][];

int[][] fourArray4[][];

int[][][] fourArray5[];

---

21) Paano tayo maghahanap ng isang partikular na elemento sa isang array?

Maaari naming gamitin ang Arrays.binarySearch() na paraan. Ang pamamaraang ito ay gumagamit ng binary search algorithm.

---

22) Kung hindi ka magsisimula ng array ano ang mangyayari?

Ang array ay magkakaroon ng default na halaga.

---

23) Paano natin mahahanap ang mga dobleng elemento sa isang array?

Paggamit ng Brute Force Method: Sa pamamaraang ito, inihahambing namin ang bawat elemento ng isang array sa iba pang mga elemento. Kung may dalawang elementong nakitang magkapareho o magkapareho, idedeklara namin ang mga ito bilang mga duplicate. Mangyaring hanapin sa ibaba ang code para sa pareho

public class DuplicatesInArray {

public static void main(String[] args) {

String[] strArray1 = {"abc1", "def1", "mno1", "xyz1", "pqr1", "xyz1", "def1"};

for (int i = 0; i < strArray1.length-1; i++) {

for (int j = i+1; j < strArray1.length; j++) {

if( (strArray1[i].equals(strArray1[j])) && (i != j) ) {

System.out.println("Duplicates : "+strArray1[j]);

}}}} }

Output: Ang Duplicate na Element ay : def1 Ang Duplicate na Element ay: xyz1

---

24) Maaari ba nating gamitin ang Generics kasama ang array?

Hindi, hindi namin magagamit ang Generic na may array.

---

25) Paano umulit ng isang array sa java?

1) Paggamit ng normal para sa loop

public class MainClass1

{

public static void main(String[] args)

{

int[] a1 = new int[]{45, 12, 78, 34, 89, 21};

//Iterating over an array using normal for loop

for (int i = 0; i < a1.length; i++)

{

System.out.println(a1[i]);

}}}

2) Paggamit ng pinalawig na bago para sa loop

public class MainClass1

{

public static void main(String[] args)
{
int[] a2 = new int[]{45, 12, 78, 34, 89, 21};

//Iterating over an array using extended for loop

for (int i: a2){

System.out.println(i);

}}}

---

26) Saan nakalaan ang memorya para sa mga arrays sa Java?

Sa Java, ang memorya para sa mga array ay palaging inilalaan sa heap dahil ang mga array sa Java ay mga bagay.

---

27) Maaari mo bang sabihin sa akin ang pangalan ng klase ng isang array sa Java?

Ang array ay isang bagay. Upang mabawi ang pangalan ng klase maaari naming gamitin ang getClass().getName() method sa object.

---

28) “int a[] = new int[3]{1, 2, 3}” – Ito ay isang legal na paraan ng pagtukoy sa mga array?

Hindi. Hindi namin dapat ideklara ang laki ng array kapag nagbibigay kami ng mga elemento ng array.

---

29) Ano ang two-dimensional array?

Isang array ng isang array sa Java. Maaari naming ipahayag ang mga ito tulad ng

int[][] p = new int[3][3]

na isang matrix ng 3x3.

---

30) Mayroon ba tayong 3-dimensional na mga array sa Java?

Oo, sinusuportahan ng Java ang N-dimensional array. Ang multi-dimensional array sa Java ay walang iba kundi isang array ng array, Halimbawa: 2-dimensional array ay isang array ng 1-dimensional array.

---

31) Maaari ba tayong gumawa ng array na pabagu-bago ng isip sa Java?

Oo, maaari tayong gumawa ng array na pabagu-bago ng isip sa Java, ngunit ginagawa lang natin ang variable na tumuturo sa array na pabagu-bago.

---

32) Ano ang magiging output ng code sa ibaba?

int myArr[] = new int [7];

System.out.print(myArr);

Sagot: Ang output ay magiging halaga ng Basura. myArr ay isang array variable, myArr ay tumuturo sa isang array kung ito ay integers. Ang pag-print ng myArr ay magpi-print ng halaga ng basura. Ito ay hindi katulad ng pag-print ng myArr[0].

---

33) Ano ang hakbang upang ma-access ang mga elemento ng isang array sa Java?

Maaari naming i-access gamit ang "index". Ang index ay nagsisimula sa Zero(0), kaya ang unang elemento ay nakaimbak sa lokasyong zero at ang huling elemento ay Array.length – 1. Halimbawa:- String strArr[] = bagong String []{“A”, “B”, “C”, “D”, “E”}; Ang strArr[0] ay nangangahulugang “A” at ang strArr[2] ay nangangahulugang “C”.

---

34) Maaari mo bang sabihin sa akin ang mga pagkakaiba sa pagitan ng Array at ArrayList?

Ayos	Listahan ng Array
Ang array ay static na may nakapirming laki na hindi na mababago kapag na-delared.	Ang ArrayList ay hindi static ngunit dynamic sa laki. Habang idinagdag ang mga elemento sa isang ArrayList, awtomatikong lumalaki ang kapasidad o laki nito.
Naglalaman ito ng parehong mga primitive na uri ng data at mga bagay ng isang klase.	Ang ArrayList ay hindi naglalaman ng mga primitive na uri ng data ngunit naglalaman ng mga entry ng object.
Ang Array ay walang tampok na Generics.	Ang ArrayList ay may tampok na Generics.

---

35) Alam namin na ang mga Array ay mga bagay kaya bakit hindi namin maisulat ang strArray.length()?

Ang mga array ay mga object reference tulad ng mga klase sa Java. Maaari naming gamitin ang mga pamamaraan ng Object tulad ng toString () at isa pang hashCode () laban sa Array. Ang haba ay isang data item ng isang array at kaya hindi ito isang paraan. Iyon ang dahilan kung bakit ginagamit namin ang strArray.length.

---

36) Paano mahahanap ang nawawalang elemento sa integer array ng 1 hanggang 7?

Ang mga solusyon upang malutas ang problemang ito ay upang kalkulahin ang kabuuan ng lahat ng mga numero sa array at ihambing sa isang inaasahang kabuuan, ang pagkakaiba ay ang nawawalang numero.

int ar [] = new int[]{1,2,3,5,6,7};

• Kunin ang kabuuan ng mga numero
• kabuuan = n*(n+1)/2
• Ibawas ang lahat ng mga numero mula sa kabuuan at
• makukuha mo ang nawawalang numero.
• Ayon sa logic sa ibaba sumOfNnumberss ay 7*(7+1)/2=28

sumOfElements = 1+2+3+5+6+7=24 nawawalang elemento ay = 28-24=4

int n = ar.length+1;

int total = n*(n+1)/2;

for(int i =0;i<ar.length;i++){

total -=ar[i];}

System.out.println(total);

---

37) Paano mahahanap ang duplicate sa isang array?

String str = "HI RAHUL I AM FINE RAHUL"; // String with a duplicate word.

String[] words = str.split(" "); // Splitting and converting to Array .

for(int i = 0; i < words.length; i++){ //iterating array inside for loop

for(int j = i+1; j < words.length; j++){ //iterating same array inside another for loop

if (words[i].equals(words[j])){ // Using equal method i am verifying which word is repeating . System.out.println( words[i]); // here it will print duplicate .

}}}

---

38) Paano suriin ang array ay naglalaman ng halaga o hindi?

Narito ang isang String[] na may mga halaga

public static final String[] myNames = new String[] {"B","A","K","C"};

Kung ang myNames ay naglalaman ng halagang iyon, magbabalik ito ng true kung hindi man false. Narito ang dalawang pamamaraan na isExists() at contains() ang parehong mga pamamaraan ay nagbabalik ng true kung ang halaga ay magagamit kung hindi man false. Unang Pamamaraan Ito ay nagko-convert ng array sa ArrayList. Pagkatapos nito ay susubukan kung ang isang array ay naglalaman ng anumang halaga pagkatapos ito ay magbabalik ng true kung hindi man false.

public static <T> boolean isExists(final T[] array, final T object) {

return Arrays.asList(array).contains(object); }

Ikalawang Paraan Ang pamamaraang ito ay umiikot sa isang array at gumamit ng equal() na paraan upang maghanap ng elemento. Ito ay aktwal na nagsasagawa ng isang linear na paghahanap sa isang array sa Java. Magbabalik ito ng true kung ang isang array ay nagbigay ng halaga.

public static <T> boolean contains(final T[] array, final T v) {

for (final T e : array) { if (e == v || v != null && v.equals(e)) {

return true;

} }

return false;

} }

---

39) Paano makakuha ng pinakamalaki at pinakamaliit na numero sa isang array?

Sagot: Lohika ng problemang ito:

• Gumagamit kami ng dalawang variable upang mag-imbak ng pinakamalaki at pinakamaliit na numero.
• Una, sinisimulan namin ang pinakamalaki sa Integer.MIN_VALUE at
• Susunod, sinisimulan namin ang pinakamaliit gamit ang Integer.MAX_VALUE.
• Sa bawat pag-ulit ng for loop, ihahambing namin ang kasalukuyang numero sa pinakamalaki at pinakamaliit na numero, at mag-a-update kami
• Kung ang isang numero ay mas malaki kaysa sa pinakamalaki, hindi ito maaaring mas maliit kaysa sa pinakamaliit. Nangangahulugan iyon na hindi na kailangang suriin kung totoo ang unang kundisyon,
• Gagamitin namin ang if-else code block, kung saan ang ibang bahagi ay isasagawa lamang kung ang unang kundisyon ay hindi nangangahulugang hindi totoo.

import java.util.Arrays;

public class MaximumMinimumArrayExample{

public static void largestAndSmallest(int[] numbers) {

int largest = Integer.MIN_VALUE;

int smallest = Integer.MAX_VALUE;

for (int number : numbers) {

if (number > largest) {

largest = number;

}

else if (number < smallest) {

smallest = number;

} }
System.out.println("Largest is : " + largest);

System.out.println("Smallest is : " + smallest); } }

---

40) Paano gawin ang intersection ng dalawang pinagsunod-sunod na array?

Sagot: Lohika: i-print ang elemento kung ang elemento ay naroroon o magagamit sa parehong mga array.

• Gumamit ng dalawang index na variable na i at j, pagkatapos nito ay ang mga halaga ng i = 0, j = 0
• Kung ang arr01 [i] ay mas maliit kaysa sa arr02 [j] pagkatapos ay dagdagan ang i.
• Kung ang arr01 [i] ay mas malaki kaysa sa arr02 [j] pagkatapos ay dagdagan ang j.
• Kung pareho ang pareho, i-print ang alinman sa mga ito at dagdagan ang parehong i at j.

public static void getIntersection(int arr01[], int arr02[], int m, int n){

int i = 0, j = 0;

while (i < m && j < n){

if (arr01[i] < arr02[j])

i++;

else if (arr02[j] < arr01[i])

j++;

else{

System.out.print(arr02[j++]+" ");

i++;

}

}

}

public static void main(String args[]){

int arr01[] = {1, 2, 4, 5, 6};

int arr02[] = {2, 3, 5, 7};

int m = arr01.length;

int n = arr02.length;

getIntersection(arr01, arr02, m, n);

}

---

41) Paano makakuha ng nangungunang dalawang numero mula sa isang array?

Sagot: Ang lohika ay:

• Magtatalaga kami ng unang variable na max01 na may Integer.MIN_VALUE

Bukod dito, ang pangalawang variable na max02 na may parehong max01 na Integer.MIN_VALUE.

• Uulitin namin ang array na ito at ihahambing ang bawat numero sa max01 at max02,
• Kung ang kasalukuyang numero ay mas malaki kaysa sa max1 pagkatapos ay italaga ang max01 = numero at max02 = max1.
• Kung hindi, kung ito ay mas malaki lamang sa max02 pagkatapos ay i-update lamang namin ang max02 gamit ang kasalukuyang numero.
• Sa pagtatapos ng isang pag-ulit, ang max01 at max02 ay tumuturo sa nangungunang dalawang numero mula sa ibinigay na array.

import java.util.Arrays;

public class TopTwoMaximumNumbers{

public static void main(String args[]) {

topTwoNumbers(new int[]{20, 34, 21, 87, 92, Integer.MAX_VALUE});

topTwoNumbers(new int[]{0, Integer.MIN_VALUE, -2});

topTwoNumbers(new int[]{Integer.MAX_VALUE, 0, Integer.MAX_VALUE});

topTwoNumbers(new int[]{1, 1, 0}); }

public static void topTwoNumbers(int[] numbers) {

int max01 = Integer.MIN_VALUE;

int max02 = Integer.MIN_VALUE; for (int number : numbers) {

if (number > max01) { max02 = max01; max01 = number; }

else if (number > max02) { max02 = number; } }

System.out.println("First largest number is : " + max01);

System.out.println("Second largest number is : " + max02); } }

---

42) Paano i-cut o alisin ang isang elemento mula sa array?

Sagot: Ang lohika ay: Maaari naming alisin o gupitin ang isang elemento gamit ang Apache Commons ArrayUtils batay sa isang index. Ang ArrayUtils ay may ilang overloaded na remove() na paraan.

import java.util.Arrays;

import org.apache.commons.lang.ArrayUtils;

public class RemoveFromArray{

public static void main(String args[]) {

//let's create an array for demonstration purpose

int[] testArr = new int[] { 10, 102, 13, 14, 105};

System.out.println("Array size : " + testArr.length );

System.out.println("Find Contents : " + Arrays.toString(testArr));

//let's remove or delete an element from Array using Apache Commons ArrayUtils

testArr = ArrayUtils.remove(testArr, 2); //removing element at index 2

//Size of array must be 1 less than original array after deleting an element

System.out.println("Size of array after removing : " + testArr.length);

System.out.println("Content of Array : "+ Arrays.toString(testArr));

} }

---

43) Ano ang lohika upang baligtarin ang array?

Sagot: Lohika: i-print ang elemento sa reverse order.

• Ipahayag ang a

String Array String[] s = new String[]{"My","Leg","is","cut"};

• Ulitin ito gamit ang para sa loop makuha ang lahat ng mga elemento sa reverse order ay nangangahulugan ng pagtatapos ng punto sa simula.

public static void main(String[] args)

{String[] s = new String[]{"My","Leg","is","cut"};

for(int i=s.length-1; i>=0; i--){

System.out.println("reverse "+s[i]);}}

---

44) Paano mo mahahanap ang pangalawang pinakamalaking elemento sa isang hanay ng mga integer?

Sagot: Ang lohika ay:

• Ulitin ang ibinigay na array gamit ang for loop.
• (una kung ang kundisyon arr[i] > pinakamalaki):
• Kung ang kasalukuyang halaga ng array ay mas malaki kaysa sa pinakamalaking halaga kung gayon
• Ilipat ang pinakamalaking halaga sa pangalawang Pinakamalaking at gawing pinakamalaki ang kasalukuyang halaga
• (pangalawa kung kondisyon arr[i] > pangalawaLarge )
• Kung ang kasalukuyang halaga ay mas maliit kaysa sa pinakamalaking at

mas malaki kaysa sa pangalawang Pinakamalaking pagkatapos ay ang kasalukuyang halaga ay nagiging

public static void main(String[] args) {

int myArr[] = { 14, 46, 47, 86, 92, 52, 48, 36, 66, 85 };

int largest = myArr[0];

int secondLargest = myArr[0];

System.out.println("The given array is:" );

for (int i = 0; i < myArr.length; i++) {

System.out.print(myArr[i]+"\t");

}

for (int i = 0; i < myArr.length; i++) {

if (myArr[i] > largest) {

secondLargest = largest;

largest = myArr[i];

} else if (myArr[i] > secondLargest) {secondLargest = myArr[i];

}}

System.out.println("\nSecond largest number is:" + secondLargest);

}

---

45) Sumulat ng isang programa upang sumama ang mga halaga ng ibinigay na array.

Sagot: Ang lohika ay:

• Ideklara at italaga ang int variable na sum =0.
• Ulitin ang ibinigay na array gamit ang for loop.
• Idagdag ang lahat ng elemento ng array at panatilihin sa variable na ito na ang kabuuan.

Public static void main(String[] args) {

int my_array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

int sum = 0;

for (int i: my_array)

sum += i;

System.out.println("The sum is " + sum);

}

---

46) Paano mo ihihiwalay ang mga zero mula sa mga di-zero sa isang array?

Sagot: Ang lohika ay:

• Sinisimulan ang counter sa 0
• Binabaybay ang inputArray mula kaliwa hanggang kanan
• Kung ang inputArray[i] ay hindi zero
• Pagtatalaga ng inputArray[i] sa inputArray[counter]
• Pagdaragdag ng counter ng 1
• Pagtatalaga ng zero sa natitirang mga elemento

Public class SeparateZerosFromNonZeros

{ static void moveZerosToEnd(int inputArray[]) { int counter = 0;

for (int i = 0; i < inputArray.length; i++)

{

if(inputArray[i] != 0) {

inputArray[counter] = inputArray[i];

counter++;

} }

while (counter < inputArray.length) {

inputArray[counter] = 0;

counter++; }

System.out.println(Arrays.toString(inputArray));

}

public static void main(String[] args) {

moveZerosToEnd(new int[] {12, 0, 7, 0, 8, 0, 3});

moveZerosToEnd(new int[] {1, -5, 0, 0, 8, 0, 1});

moveZerosToEnd(new int[] {0, 1, 0, 1, -5, 0, 4});

moveZerosToEnd(new int[] {-4, 1, 0, 0, 2, 21, 4});

} }

---

47) Sumulat ng isang programa upang magpasok ng isang elemento at sa tiyak na posisyon sa array?

Sagot: Ang lohika ay:

• Magpasok ng elemento sa ika-3 posisyon ng array (index->2, value->5)
• Ulitin ang ibinigay na array sa reverse order gamit ang for loop.
• Ngayon ipasok ang ibinigay na posisyon at halaga pagkatapos ng para sa loop.

Public static void main(String[] args) {

int[] my_array = {25, 14, 56, 15, 36, 56, 77, 18, 29, 49};

int Index_position = 2;

int newValue = 5;

System.out.println("Original Array : "+Arrays.toString(my_array));

for(int i=my_array.length-1; i > Index_position; i--){

my_array[i] = my_array[i-1];
}my_array[Index_position] = newValue;

System.out.println("New Array: "+Arrays.toString(my_array));

}

---

48) Paano makukuha ang index ng isang elemento ng array?

Sagot: Ang lohika ay:

• Sa bawat hakbang, sinusuri nito ang halaga ng input key na may halaga ng gitnang elemento ng isang array.
• Kung tumugma ang mga susi, ibabalik nito ang posisyon. Sa ibang kaso, kung ang susi ay mas mababa sa susi ng gitnang elemento,
• Pagkatapos ay uulitin nito ang while loop. Kung ang natitirang array ay hinanap at ito ay nabawasan sa zero, ito ay babalik -1 ay nangangahulugan na hindi natagpuan

public static int findIndex (int[] my_array, int t) {

int startPoint = 0;

int endPoint = my_array.length - 1;

while (startPoint <= endPoint) {

int mid = (startPoint + end) / 2;

if (key == my_array[mid]) {

return mid;

}

if (key < my_array[mid]) {

endPoint = mid - 1;
} else {

startPoint = mid + 1;

}

}

return -1;

}

Public static void main(String[] args) {

int[] arr = {2, 4, 6, 8, 10, 12, 14, 16};

System.out.println("Key 14's position: "findIndex(arr, 14));

int[] arr1 = {6,34,78,123,432,900};

System.out.println("Key 432's position: "+findIndex(arr1, 432));

}

---

49) Maaari ba nating pahabain ang isang array pagkatapos ng pagsisimula?

Sagot: Ang lohika ay: Maaari naming i-extend ang isang array pagkatapos ng pagsisimula sa pamamagitan ng pagdaragdag ng bagong array. Mangyaring hanapin ang halimbawa sa ibaba.

Public static void main(String[] args) {

String [] names = new String[] { "A", "B", "C" };

String [] extended = new String[5];

extended [3] = "D";

extended [4] = "E";

System.arraycopy(names, 0, extended, 0, names.length);

//here we are extending with new array extended[3] and extended[4].

for (String str: extended){

System.out.println(str);

}

}

ang output ay A, B, C, D, E.

---

50) Paano punan ang elemento (magpasimula nang sabay-sabay) sa isang array?

Sagot: Ang halimbawang ito ay punan(simulan ang lahat ng elemento ng array sa isang maikling) isang array sa pamamagitan ng paggamit ng Array.fill(array name,value) na paraan at Array.fill(array name, starting index, ending index, value) ang paraan ng Java Util class.

import java.util.*;

public class FillTest {

public static void main(String args[]) {

int array[] = new int[6];

Arrays.fill(array, 100);

for (int i = 0, n = array.length; i < n; i++) {

System.out.println(array[i]);

}

System.out.println();

Arrays.fill(array, 3, 6, 50);

for (int i = 0, n = array.length; i< n; i++) {

System.out.println(array[i]);}}}

ang output ay

100,100,100,100,100,100

100,100,100,50,50,50