Top 50 vragen en antwoorden over array-interviews (2026)
Redactie
Bereid je je voor op een sollicitatiegesprek bij Array? Het is tijd om te focussen op de vragen die je kunt krijgen. Inzicht in {{keyword}} helpt kandidaten om analytisch denkvermogen, logica en probleemoplossend vermogen effectief te ontwikkelen.
Arrays vormen de basis van de technische en professionele ervaring van programmeurs. Van beginners tot ervaren professionals: het beheersen ervan toont sterke technische expertise en diepgaande kennis van datamanipulatie. Werkgevers waarderen dergelijke vaardigheden tijdens vraag- en antwoordsessies, enz.ping Kandidaten doorstaan de reguliere, gevorderde of mondelinge examenrondes met een zelfverzekerde analyse en praktische vaardigheden.
Deze verzameling is gebaseerd op inzichten van meer dan 85 technische leiders, managers en professionals en belicht diverse perspectieven uit verschillende sectoren. Zo weet u zeker dat elk onderwerp in de reeks de authentieke verwachtingen bij het aannemen van personeel en de echte normen voor codeerevaluatie weerspiegelt.
Top Array-interviewvragen en -antwoorden
1) Leg uit wat een array is en hoe deze verschilt van andere datastructuren.
Een array is een aaneengesloten geheugenblok dat meerdere elementen van hetzelfde gegevenstype opslaat. Het biedt constante toegang tot elk element met behulp van de index, waardoor het een van de meest efficiënte structuren voor willekeurige toegang is. In tegenstelling tot gekoppelde lijsten hebben arrays een vaste grootte en geen overhead voor het opslaan van pointers. Arrays hebben de voorkeur wanneer het aantal elementen vooraf bekend is, terwijl dynamische structuren zoals lijsten of vectoren worden gebruikt wanneer frequente formaatwijzigingen worden verwacht.
| Kenmerk | reeks | Gelinkte lijst |
|---|---|---|
| Geheugentoewijzing | Aaneengesloten | Niet aaneengesloten |
| Toegangstijd | O (1) | O (n) |
| Invoegen/verwijderen | Duur | Doeltreffend |
| Geheugenoverhead | Laag | Hoog (wijzers) |
👉 Gratis PDF-download: Array-interviewvragen en -antwoorden
2) Wat zijn de verschillende typen arrays? Geef voorbeelden.
Arrays worden gecategoriseerd op basis van hun afmetingen en gebruik. De belangrijkste typen zijn:
- Eendimensionale array: Slaat elementen lineair op, bijvoorbeeld:
int arr[5] = {1,2,3,4,5}. - Tweedimensionale matrix: Geeft tabelgegevens weer, bijvoorbeeld matrices.
- Multidimensionale array: Hogere dimensies, vaak gebruikt in simulaties of beeldverwerking.
- Dynamische arrays: Automatisch de grootte aanpassen wanneer elementen worden toegevoegd, bijvoorbeeld:
ArrayListin Java,vectorin C++.
| Type | Structuur | Voorbeeld |
|---|---|---|
| 1D | Lineair | [1, 2, 3] |
| 2D | Matrix | [[1, 2], [3, 4]] |
| Dynamisch | resizable | std::vector<int> |
3) Hoe vind je de grootste en kleinste elementen in een array?
Dit probleem wordt vaak opgelost met een lineaire traversal. Je onderhoudt dan twee variabelen – één voor het minimum en één voor het maximum – en werkt deze bij tijdens de iteratie.
Algoritme:
- initialiseren
minenmaxmet het eerste element. - Doorloop de matrix en vergelijk elk element.
- bijwerken
minormaxovereenkomstig.
Voorbeeld (C++):
int arr[] = {5, 2, 9, 1, 7};
int min = arr[0], max = arr[0];
for (int i : arr) {
if (i < min) min = i;
if (i > max) max = i;
}
Tijdscomplexiteit: Op).
4) Wat zijn de voor- en nadelen van arrays?
Arrays bieden hoge prestaties voor willekeurige toegang, maar hebben een vaste grootte en kosten om de grootte aan te passen.
| Aspect | Voordelen | Nadelen |
|---|---|---|
| Prestaties | Snelle indexering (O(1)) | Langzaam invoegen/verwijderen (O(n)) |
| Geheugen | Compacte opslag | Statische groottetoewijzing |
| Implementatie | Eenvoudige syntaxis | Geen grenscontrole in sommige talen |
| Use Case | Geschikt voor vaste datasets | Inefficiënt voor frequente wijzigingen |
5) Beschrijf het verschil tussen statische en dynamische arrays.
A statische array heeft een vaste grootte die tijdens het compileren wordt bepaald, terwijl een dynamische array kunnen tijdens runtime groeien of krimpen. Statische arrays zijn efficiënt in geheugen maar rigide, terwijl dynamische arrays flexibiliteit bieden met een kleine overhead tijdens het wijzigen van de grootte.
| Kenmerk | Statische array | Dynamische array |
|---|---|---|
| Grootte | vast | Veranderlijk |
| Geheugen | Opstapelen | Hoop |
| Voorbeeld | int arr[5]; |
std::vector<int> |
| Resizing | Niet ondersteund | ondersteunde |
Voorbeeldgebruikscasus:
Gebruik statische arrays in embedded systemen en dynamische arrays voor verzamelingen met een onvoorspelbare grootte.
6) Hoe kun je een array ter plekke omkeren?
RevHet in-place wissen van een array houdt een swap in.ping Elementen van beide uiteinden bewegen zich naar het midden.
Algoritme:
- Initialiseer twee pointers:
start = 0enend = n - 1. - Elementen verwisselen
arr[start]enarr[end]. - aanwas
starten afnemenendtot ze elkaar ontmoeten.
Voorbeeld (Python):
arr = [1, 2, 3, 4, 5] arr.reverse() # Built-in method # or manually arr = arr[::-1]
Tijdscomplexiteit: Op), Ruimtecomplexiteit: O(1).
7) Wat is het verschil tussen een jagged array en een multidimensionale array?
A gekartelde reeks is een reeks reeksen waarin de binnenste reeksen verschillende lengtes kunnen hebben, terwijl een multidimensionale array heeft uniforme rij- en kolomgrootten.
| Kenmerk | Gekartelde array | Multidimensionale array |
|---|---|---|
| Structuur | Onregelmatig (geneste arrays) | Rechthoekig (matrix) |
| Geheugen | Niet aaneengesloten | Aaneengesloten |
| Toegang | arr[i][j] |
arr[i][j] |
| Voorbeeld | int[][] jagged = {{1,2}, {3,4,5}}; |
int[,] matrix = {{1,2}, {3,4}}; |
Jagged arrays zijn geheugenefficiënter wanneer de gegevens ongelijkmatig zijn.
8) Hoe vind je het ontbrekende getal in een matrix van 1 tot n?
Dit probleem maakt gebruik van wiskundige eigenschappen van natuurlijke getallen.
Benadering 1 (Somformule):
Som van de eerste n natuurlijke getallen = n*(n+1)/2.
Subtract is de som van de array-elementen van dit totaal.
Benadering 2 (XOR):
XOR alle elementen met getallen van 1 tot n. De resterende waarde is het ontbrekende getal.
Voorbeeld:
Bij [1,2,4,5,6] (n=6):
Verwachte som = 21, Werkelijke som = 18 → Ontbrekend = 3.
Tijdscomplexiteit: Op), Ruimtecomplexiteit: O(1).
9) Wat zijn de verschillende manieren om duplicaten uit een array te verwijderen?
Er zijn verschillende benaderingen, afhankelijk van de taal en de beperkingen:
- HashSet gebruiken: Sla alleen unieke elementen op.
- Sorteren gebruiken: Sorteer de matrix en verwijder aangrenzende duplicaten.
- Frequentiekaart gebruiken: Track tellingen van elk element.
Voorbeeld (Java):
Set<Integer> unique = new HashSet<>(Arrays.asList(arr));
| Aanpak | Tijd | Tussenruimte |
|---|---|---|
| HashSet | O (n) | O (n) |
| Sorteren | O (n log n) | O (1) |
| Frequentie | O (n) | O (n) |
10) Hoe vind je het op één na grootste element in een array?
Met één doorkruising kunt u het op één na grootste element vinden, waarbij u twee variabelen behoudt.
Algoritme:
- initialiseren
firstensecondasINT_MIN. - Doorloop de array.
- Werk beide bij als er een grotere waarde wordt gevonden.
Voorbeeld (C++):
int first = INT_MIN, second = INT_MIN;
for (int x : arr) {
if (x > first) {
second = first;
first = x;
} else if (x > second && x < first) {
second = x;
}
}
Tijdscomplexiteit: Op), Ruimtecomplexiteit: O(1).
11) Hoe kun je een array 'k' posities roteren? Leg verschillende benaderingen uit.
Arrayrotatie verschuift elementen cyclisch. Er zijn drie hoofdmethoden om het te bereiken:
- Een tijdelijke array gebruiken: Kopieer de eerste k elementen en voeg ze aan het einde toe nadat je de andere elementen hebt verschoven.
- gebruik Reversal Algoritme: Reverse De array bestaat uit drie delen: het eerste deel, het tweede deel en vervolgens de hele array.
- Gebruik van het jongleeralgoritme: Gebaseerd op GCD van n en k (efficiënt in O(n)).
Voorbeeld (rechtsom draaien met 2):
Input: [1,2,3,4,5] Output: [4,5,1,2,3]
| Methode | Tijd | Tussenruimte | Beschrijving |
|---|---|---|---|
| Tijdelijke array | O (n) | OK) | Eenvoudig en intuïtief |
| Reveral | O (n) | O (1) | Ter plaatse en efficiënt |
| Jongleren | O (n) | O (1) | Gebaseerd op GCD-cycli |
12) Wat is een subarray en hoe verschilt het van een subreeks?
A subarray is een aaneengesloten gedeelte van een array, terwijl een subreeks handhaaft de orde, maar kan elementen overslaan.
| Eigendom | subarray | Subsequentie |
|---|---|---|
| Aaneengesloten | Ja | Nee |
| Bestelling bewaard | Ja | Ja |
| Voorbeeld (uit [1,2,3]) | [1,2] | [1,3] |
Voorbeeld:
Gegeven array [1,2,3], totale subarrays = n*(n+1)/2 = 6.
Subreeksen zijn daarentegen 2ⁿ - 1 = 7 niet-lege combinaties.
13) Hoe vind je de maximale som van de subarray?
De Kadane's algoritme is de meest efficiënte manier om de aaneengesloten subarray met de maximale som te vinden.
Stappen:
- initialiseren
max_current = max_global = arr[0]. - Herhaal elementen.
- bijwerken
max_current = max(arr[i], arr[i] + max_current). - Track het wereldwijde maximum.
Voorbeeld:
Input: [-2,1,-3,4,-1,2,1,-5,4] → Uitvoer: 6 (subreeks [4,-1,2,1]).
complexiteit:
O(n) tijd, O(1) ruimte.
14) Hoe kun je twee gesorteerde arrays samenvoegen zonder extra ruimte te gebruiken?
Twee gesorteerde arrays samenvoegen in situHet idee is om vanaf het einde van beide arrays te vergelijken.
Nadering:
- Begin met het laatste geldige element van beide arrays.
- Vergelijk en verplaats de grootste naar het einde van de gecombineerde ruimte.
- Herhaal dit totdat alle elementen zijn samengevoegd.
Voorbeeld (C++):
int i = m-1, j = n-1, k = m+n-1;
while (i >= 0 && j >= 0) {
if (A[i] > B[j]) A[k--] = A[i--];
else A[k--] = B[j--];
}
Tijdscomplexiteit: O(m+n).
15) Op welke verschillende manieren kun je naar een element in een array zoeken?
| Methode | Type | Tijdcomplexiteit | Voorbeeld gebruik |
|---|---|---|---|
| Lineair zoeken | unsorted | O (n) | Algemeen zoeken |
| Binaire zoekopdracht | gesorteerd | O (log n) | Efficiënt opzoeken |
| Hashing | Ongeordend | O(1) gemiddelde | Grote datasets |
Voorbeeld (Binair zoeken – Python):
def binary_search(arr, x):
l, r = 0, len(arr)-1
while l <= r:
mid = (l+r)//2
if arr[mid] == x: return mid
elif arr[mid] < x: l = mid+1
else: r = mid-1
return -1
16) Leg het verschil uit tussen ‘shallow copy’ en ‘deep copy’ in arrays.
A Oppervlakkige kopie kopieën van verwijzingen naar de originele elementen, terwijl een diepe kopie dupliceert alle gegevens naar nieuwe geheugenlocaties.
| Kopieer Type | Onafhankelijkheid van gegevens | Voorbeeld |
|---|---|---|
| Ondiep | Nee | arr_copy = arr |
| Diep | Ja | arr_copy = arr[:] (Python) |
Voorbeeld:
Het wijzigen van een ondiepe kopie wordt doorgevoerd in de originele array. Een diepe kopie niet.
17) Hoe vind je duplicaten in een array zonder extra ruimte te gebruiken?
Benadering 1 (sorteren): Sorteer en controleer aangrenzende elementen.
Benadering 2 (negatiemethode voor 1-n waarden): Mark bezocht indices door het element op die index te ontkennen.
Benadering 3 (detectie van de Floyd-cyclus): Behandel de array als een gekoppelde lijst en vind de cyclus (voor herhaalde elementen in het bereik [1..n]).
Voorbeeld:
reeks [3,1,3,4,2] → Duplicaat = 3.
Tijd: Op), Ruimte: O(1).
18) Wat zijn sparse arrays en wat zijn hun voordelen?
A spaarzame array Bevat voornamelijk nulwaarden of standaardwaarden. In plaats van alle elementen op te slaan, slaan we alleen niet-nulwaarden op met hun indices.
Voordelen:
- Bespaart geheugen.
- Efficiënt voor grote datasets zoals matrices of documenttermfrequenties.
| Type | Voorbeeld | Use Case |
|---|---|---|
| Dichte matrix | [0,1,0,2,3] |
Kleine gegevens |
| Sparse Array | {1:1, 3:2, 4:3} |
Grote, schaarse gegevens |
Voorbeeld: Wordt gebruikt in machine learning-modellen (TF-IDF-matrices).
19) Hoe kun je de doorsnede van twee arrays efficiënt bepalen?
Kruispunten kunnen worden gevonden met behulp van hashing- of sorteertechnieken.
- HashSet gebruiken: Voeg elementen van de eerste array toe en controleer vervolgens het lidmaatschap van de tweede array.
- Twee aanwijzers gebruiken: Werkt voor gesorteerde arrays.
Voorbeeld (Python):
intersection = list(set(arr1) & set(arr2))
complexiteit:
- HashSet: O(n)
- Twee aanwijzers: O(n log n) vanwege sortering.
20) Leg het verschil uit tussen de rij- en kolomvolgorde in arrays.
Dit zijn geheugenopslagvolgordes die worden gebruikt voor multidimensionale arrays.
| Concept | Rij-Majoor (C/C++) | Kolom-Majoor (Fortra(n, MATLAB) |
|---|---|---|
| Opslagorder | Rij voor rij | Kolom voor kolom |
| Adresformule | Base + ((i * cols) + j) * size |
Base + ((j * rows) + i) * size |
| Voordeel | Sneller voor rij-overgang | Sneller voor kolomdoorkruising |
Voorbeeld:
Voor een 2D-array A[2][3], rij-grote winkels [A[0][0], A[0][1], A[0][2], A[1][0], ...].
21) Wat is de prefix sum-techniek en hoe wordt deze in arrays gebruikt?
De voorvoegsel som De techniek omvat het vooraf berekenen van cumulatieve sommen van een array om bereikquery's efficiënt te kunnen beantwoorden.
Concept:
prefix[i] = prefix[i-1] + arr[i]
Om vervolgens de som van de elementen van l tot r te verkrijgen, gebruikt u:
sum(l, r) = prefix[r] - prefix[l-1]
Voorbeeld:
Array = [2, 3, 5, 7, 1]
Voorvoegsel = [2, 5, 10, 17, 18]
Som(2,4) = prefix[4] - prefix[1] = 15
toepassingen:
Wordt gebruikt in subarray-somquery's, cumulatieve frequentietabellen en competitieve programmering.
complexiteit:
Voorbewerking: O(n), Query: O(1)
22) Hoe verbetert de schuifvenstertechniek de arrayprestaties?
De schuifraam Deze techniek wordt gebruikt om problemen met aaneengesloten segmenten (subarrays) efficiënt op te lossen.
Idee: In plaats van de som of voorwaarde voor elk venster opnieuw te berekenen, werkt u het resultaat bij door het volgende element toe te voegen en het eerste te verwijderen.
Voorbeeld probleem:
Vind de maximale somsubarray van grootte k.
Algoritme:
- Bereken de som van de eerste
kelementen. - Verschuif het venster één element tegelijk.
- Voeg het nieuwe element toe, verwijder het eerste en track het maximum.
Tijdscomplexiteit: O(n) — veel sneller dan de naïeve O(n×k)-benadering.
toepassingen:
Wordt gebruikt bij problemen zoals het maximale gemiddelde van de subarray, de langste substring of het eerste negatieve getal in elk venster.
23) Wat is het verschil tussen een array en een pointer in C?
| Kenmerk | reeks | Wijzer |
|---|---|---|
| Definitie | Verzameling van vergelijkbare data-elementen | Variabel geheugenadres opslaan |
| Geheugentoewijzing | Aaneengesloten | Dynamisch of willekeurig |
| Grootte | vast | Kan worden aangepast |
| Voorbeeld | int a[5]; |
int *p; |
Belangrijkste verschil:
De naam van een array fungeert als een constante aanwijzer, maar een aanwijzer kan dynamisch overal naartoe wijzen.
Voorbeeld:
int arr[3] = {1,2,3};
int *ptr = arr; // ptr points to first element
24) Hoe kun je de evenwichtsindex in een array vinden?
An evenwichtsindex is een positie waarbij de som van de elementen aan de linkerkant gelijk is aan de som aan de rechterkant.
Algoritme:
- Bereken de totale som van de matrix.
- Doorkruis en behoud de linkersom.
- If
(total_sum - left_sum - arr[i]) == left_sum, retourindex.
Voorbeeld:
Array: [1, 3, 5, 2, 2] → Index = 2 (omdat de linkersom = de rechtersom = 4)
complexiteit: Op), Ruimte: O (1)
25) Wat zijn sparse matrices en hoe worden ze efficiënt opgeslagen?
A schaarse matrix Bevat voornamelijk nullen. Om geheugen te besparen, worden alleen elementen die niet nul zijn en hun indices opgeslagen.
Opslagmethoden:
- Coördinatenlijst (COO): Opslaan (rij, kolom, waarde).
- Gecomprimeerde Sparse Row (CSR): Drie arrays:
values,col_index,row_pointer. - Sleutelwoordenboek (DOK): Hashmap van (rij, kolom) → waarde.
| Methode | Geheugenefficiëntie | Voorbeeld gebruik |
|---|---|---|
| COO | Gemiddeld | Algemene opslag |
| CSR | Hoge | Numerieke berekeningen |
| DOC | Flexibel | Dynamische invoeging |
Veelgebruikt in machine learning (TF-IDF, grafiek-adjacency matrices).
26) Hoe kun je een matrix zo rangschikken dat even en oneven getallen elkaar afwisselen?
Het doel is om even en oneven getallen door elkaar te schuiven, terwijl de relatieve volgorde behouden blijft.
Algoritme:
- Scheid even en oneven arrays.
- Voeg afwisselend samen, beginnend met even of oneven.
- Als een type op is, voeg je het resterende type toe.
Voorbeeld:
Input: [3, 6, 12, 1, 5, 8] Output: [6, 3, 12, 1, 8, 5]
complexiteit: O (n)
27) Leg het verschil uit tussen arrayrotatie en arrayverschuiving.
| Werking | Rotatie | ShiftING |
|---|---|---|
| Definitie | Elementen bewegen cirkelvormig | Elementen verplaatsen, vrijgekomen plaatsen worden opgevuld (bijv. 0-en) |
| Voorbeeld | [1,2,3,4] → [3,4,1,2] |
[1,2,3,4] → [0,1,2,3] |
| Gegevens verloren | Nee | Ja |
| Gebruik | Cyclische herschikkingen | Wachtrij-implementaties |
In het kort:
Rotatie is omkeerbaar, verschuiving doorgaans niet.
28) Hoe kun je de maximale product-subarray vinden?
Vergelijkbaar met het algoritme van Kadane, maar jij track geeft zowel het maximale als het minimale product weer vanwege negatieve waarden.
Algoritme:
- initialiseren
max_ending_here = min_ending_here = arr[0]. - Herhaal en update beide op basis van het huidige element.
- Circuit
max_so_far.
Voorbeeld:
Input: [2,3,-2,4] → Uitvoer: 6 (subreeks [2,3])
complexiteit: Op), Ruimte: O (1)
29) Hoe kun je efficiënt het aantal subarrays tellen met een gegeven som?
Benadering (Prefix Som + Hash Map):
- De lopende som behouden tijdens het itereren.
- Controleer voor elke prefixsom of
(current_sum - target)bestaat in de hashmap. - Verhoog het aantal dienovereenkomstig.
Voorbeeld:
arr = [10,2,-2,-20,10], target = -10 Output = 3 subarrays
Tijdscomplexiteit: O (n)
Ruimtecomplexiteit: O (n)
30) Wat is bitmanipulatie bij arrayproblemen en waar wordt het toegepast?
Bitmanipulatie omvat het uitvoeren van bewerkingen zoals AND, OR, XOR en shifts om problemen efficiënt op te lossen.
Gemeenschappelijke toepassingen:
- Een enkelvoudig, niet-herhalend element vinden met behulp van XOR.
- Controleren of een subset bestaat met behulp van bitmaskering.
- Sets weergeven als bitvectoren.
Voorbeeld:
Zoek het element dat één keer voorkomt, terwijl andere elementen twee keer voorkomen:
int res = 0; for (int num : arr) res ^= num;
Voordelen:
- Constante ruimte
- Snelle logische berekening
31) Hoe doorloop je een matrix in spiraalvorm?
A spiraalvormige doorgang bezoekt alle matrixelementen laag voor laag met de klok mee.
Algoritme:
- Definieer vier grenzen:
top,bottom,leftenright. - Beweeg van links → rechts, boven → onder, rechts → links en onder → boven.
- Verklein de grenzen na elke doorgang totdat alle elementen bedekt zijn.
Voorbeeld:
Input: 1 2 3 4 5 6 7 8 9 Output: [1,2,3,6,9,8,7,4,5]
complexiteit:
Tijd: O(n×m) | Ruimte: O(1)
32) Wat zijn de verschillende manieren om een array te sorteren? Leg uit met voorbeelden.
Sorteren herschikt elementen in een specifieke volgorde. De keuze van het algoritme hangt af van gegevensgrootte, distributie en geheugenbeperkingen.
| Algoritme | Beste geval | Gemiddeld geval | Stal | Tussenruimte |
|---|---|---|---|---|
| Bubble Sorteren | O (n) | O(n²) | Ja | O (1) |
| Sorteren samenvoegen | O (n log n) | O (n log n) | Ja | O (n) |
| Snel sorteren | O (n log n) | O(n²) | Nee | O (log n) |
| Heap Sorteren | O (n log n) | O (n log n) | Nee | O (1) |
Voorbeeld (Python Snel sorteren):
def quicksort(arr):
if len(arr) <= 1:
return arr
pivot = arr[len(arr)//2]
return quicksort([x for x in arr if x < pivot]) + [x for x in arr if x == pivot] + quicksort([x for x in arr if x > pivot])
33) Leg de tweepuntstechniek in arrays uit.
De tweepuntstechniek maakt gebruik van twee indices om een datastructuur vanaf verschillende uiteinden of snelheden te doorzoeken, waardoor tijd en ruimte worden geoptimaliseerd.
Algemeen gebruik:
- Paren met een bepaalde som detecteren in gesorteerde arrays.
- Duplicaten ter plekke verwijderen.
- Revarrays ersen.
- Intervallen samenvoegen.
Voorbeeld (paar met Target Som):
arr = [1,2,3,4,6], target = 6
left, right = 0, len(arr)-1
while left < right:
s = arr[left] + arr[right]
if s == target: print(arr[left], arr[right])
elif s < target: left += 1
else: right -= 1
complexiteit: O (n)
34) Hoe kun je het meerderheidselement in een array vinden?
A meerderheidselement komt meer dan ⌊n/2⌋ keer voor.
Boyer-Moore-stemalgoritme lost dit op in lineaire tijd en constante ruimte.
Algoritmestappen:
- initialiseren
candidateencount = 0. - Voor elk element:
- Als aantal = 0, instellen
candidate = element. - Toename/afname van het aantal op basis van gelijkheid.
- Als aantal = 0, instellen
- Verifieer de kandidaat.
Voorbeeld: [3,2,3] → Uitvoer: 3
complexiteit: O (n)
35) Wat is het verschil tussen binair zoeken en exponentieel zoeken?
| Kenmerk | Binaire zoekopdracht | Exponentiële zoekopdracht |
|---|---|---|
| eis | Gesorteerde array | Gesorteerde array |
| Kernidee | Verdeel de matrix in tweeën | Bereik exponentieel vinden vóór binair zoeken |
| Ingewikkeldheid | O (log n) | O (log n) |
| Use Case | Bekende grootte | Onbekende of oneindige arrays |
Voorbeeld:
Voor grote datasets of onbeperkte arrays (zoals pagina-API's) vindt exponentieel zoeken het bereik efficiënt.
36) Hoe kun je het k-de kleinste of grootste element in een array vinden?
benaderingen:
- Sorteren: Sorteren en toegang
k-1de index (O(n log n)). - Minimale/maximale heap: Efficiënt voor frequente zoekopdrachten (O(n log k)).
- QuickSelect (algoritme van Hoare): Gemiddelde O(n).
Voorbeeld (Python met behulp van heapq):
import heapq arr = [3,2,1,5,6,4] k = 2 print(heapq.nlargest(k, arr)[-1]) # 5
Use case: Ranglijsten, best presterende statistieken, percentielanalyse.
37) Hoe vind je het ontbrekende en herhalende getal in een matrix van 1 tot n?
Gegeven een matrix met de getallen 1 tot en met n, waarvan er één ontbreekt en één wordt herhaald:
Benadering 1 (wiskundig):
Gebruik het verschil tussen de werkelijke en verwachte som en de som van de kwadraten.
Benadering 2 (XOR-methode):
- XOR alle array-elementen en 1…n.
- Het resultaat is de XOR van ontbrekende en herhalende getallen.
- Verdeel met behulp van het meest rechtse bitje.
complexiteit: Op), Ruimte: O (1)
Voorbeeld:
Input: [4,3,6,2,1,1] Output: Missing = 5, Repeating = 1
38) Wat zijn inversietellingen in een array en hoe bereken je ze?
An inversie is een paar (i, j) zodanig dat i < j en arr[i] > arr[j].
Nadering:
- Naïef: Controleer alle paren → O(n²).
- Geoptimaliseerd (samenvoegen/sorteren): Tel inversies tijdens samenvoeging → O(n log n).
Voorbeeld:
Input: [8, 4, 2, 1] Inversions = 6 → (8,4), (8,2), (8,1), (4,2), (4,1), (2,1)
Gebruikt in meetarray-wanorde en ranking systemen.
39) Hoe kun je de mediaan van twee gesorteerde arrays vinden?
Optimale aanpak (binair zoeken):
Verdeel beide arrays zodanig dat de linkerhelften evenveel elementen bevatten als de rechterhelften.
Algoritme:
- Gebruik binair zoeken op een kleinere array.
- Vergelijk scheidingswanden.
- Retourneer de mediaan op basis van partitiewaarden.
complexiteit: O(log(min(n, m)))
Voorbeeld:
A = [1,3], B = [2] Median = 2.0
40) Wat zijn de voordelen van het gebruik van arrays ten opzichte van gekoppelde lijsten?
| Factor | reeks | Gelinkte lijst |
|---|---|---|
| Geheugen | Aaneengesloten | Niet aaneengesloten |
| Toegangstijd | O (1) | O (n) |
| Invoegen/verwijderen | Duur | Doeltreffend |
| Cache-locatie | Uitstekend | arm |
| Boven het hoofd | Geen | Extra pointeropslag |
Conclusie:
Arrays zijn optimaal voor datasets met een vaste grootte die willekeurige toegang vereisen, terwijl gekoppelde lijsten beter zijn voor dynamische invoeging en verwijdering.
41) Hoe vind je de maximale som van een cirkelvormige subarray?
In een cirkelvormige matrix, elementen wikkelen zich aan het eind om.
Nadering:
- Vind de normale maximale subarraysom met behulp van Kadane's algoritme.
- Vind de minimale subarraysom.
- Het resultaat =
max(normal_max, total_sum - min_subarray).
Randgeval: Als alle elementen negatief zijn, retourneer dan het maximumelement.
Voorbeeld:
Input: [5, -2, 3, 4] Normal Max = 10, Circular Max = 12 → Output = 12
complexiteit: O (n)
42) Hoe zoek je naar een element in een geroteerde gesorteerde array?
Gebruik een gewijzigde binaire zoekopdracht om het draaipunt te vinden en vergelijkingen aan te passen.
Algoritme:
- Bereken het midden = (laag + hoog) / 2.
- Controleer of
arr[mid] == target. - Als de linkerhelft is gesorteerd → zoeken naar links; anders naar rechts.
Voorbeeld:
Input: [4,5,6,7,0,1,2], target = 0 Output: Index = 4
Tijdscomplexiteit: O (log n)
43) Leg de dynamische programmeringsaanpak voor de “Maximum Sum Increasing Subsequence” uit.
Het doel is om de maximale som van een stijgende deelreeks te vinden.
Algoritme:
- initialiseren
dp[i] = arr[i]. - Voor elk
i, controleer vorige elementenj < i:- If
arr[j] < arr[i]dandp[i] = max(dp[i], arr[i] + dp[j]).
- If
- Retourneer de maximale waarde in
dp.
Voorbeeld:
Input: [1, 101, 2, 3, 100, 4, 5] Output: 106 (1 + 2 + 3 + 100)
Tijd: O(n²) | Ruimte: O (n)
44) Wat is de “valstrik”?ping Het probleem van "regenwater" en hoe kan het worden opgelost?
Bij dit klassieke arrayprobleem wordt de vraag gesteld hoeveel water er na regenval tussen de staven kan worden vastgehouden.
Benadering (twee aanwijzingen):
- initialiseren
left,right,left_max,right_max. - Verplaats de wijzers naar binnen, het opgeslagen water wordt bijgewerkt =
min(left_max, right_max) - height[i].
Voorbeeld:
Input: [0,1,0,2,1,0,1,3,2,1,2,1] Output: 6
| Aanpak | Tijd | Tussenruimte |
|---|---|---|
| Brute Force | O(n²) | O (1) |
| Dynamisch programmeren | O (n) | O (n) |
| Twee aanwijzers | O (n) | O (1) |
45) Hoe kun je de langste subarray vinden met een som gelijk aan nul?
Algoritme (Hash Map):
- Initialiseer een hashmap om prefixsommen op te slaan.
- Als dezelfde prefixsom nogmaals voorkomt, heeft de subarray tussen de indices een nulsom.
Voorbeeld:
Input: [15, -2, 2, -8, 1, 7, 10, 23] Output: Length = 5 (Subarray [-2, 2, -8, 1, 7])
complexiteit: O (n)
46) Wat is het verschil tussen ondiepe en diepe afvlakking van multidimensionale arrays?
| Type | Definitie | Voorbeeld |
|---|---|---|
| Ondiepe afvlakking | Maakt slechts één niveau plat | [[1,2],[3,[4]]] → [1,2,3,[4]] |
| Diepe afvlakking | Maakt alle geneste arrays volledig plat | [[1,2],[3,[4]]] → [1,2,3,4] |
Voorbeeld (Python):
import itertools shallow = list(itertools.chain.from_iterable(arr))
Use case: Handig bij het opschonen van gegevens en het normaliseren van hiërarchische gegevens.
47) Hoe vind je het evenwichtselement in een matrix (2D-array)?
An evenwichtselement in een matrix is een element waarvan rij- en kolomsommen zijn gebalanceerd.
Algoritme:
- Bereken vooraf de sommen van rijen en kolommen.
- Controleer voor elk element of
row_sum[i] - arr[i][j] == col_sum[j] - arr[i][j].
Voorbeeld:
Matrix:
Matrix: 2 7 5 3 1 1 4 6 8 Output: Element 1 at (1,1)
complexiteit: O(n²)
48) Hoe kun je een array partitioneren in twee subsets met gelijke som?
Dit is een deelverzamelingsomprobleem, opgelost met behulp van Dynamisch programmeren.
Nadering:
- Bereken het totaal.
- Indien oneven → retourneer False.
- Maak een DP-tabel om te controleren of er een subset is met
sum/2bestaat.
Voorbeeld:
Input: [1,5,11,5] Output: True (Subsets: [1,5,5] and [11])
Tijd: O(n × som/2) | Ruimte: O(som/2)
49) Hoe draai je een matrix 90 graden met de klok mee?
Algoritme:
- Transponeer de matrix.
- Reverse elke rij.
Voorbeeld:
Input: 1 2 3 4 5 6 7 8 9 Output: 7 4 1 8 5 2 9 6 3
complexiteit: O(n²), Op zijn plaats.
Gebruikt in afbeelding verwerken en transformaties voor datavisualisatie.
50) Wat zijn de meest voorkomende toepassingen van arrays in de praktijk?
Arrays vormen de basis voor talloze reken- en praktijksystemen.
toepassingen:
- Database-indexering: Opslaan en sorteren van gegevens.
- Machine Learning: Kenmerkvectoren, matrices en tensoren.
- Afbeelding verwerken: 2D- en 3D-pixelgegevens.
- Operasystemen: Geheugen- en procesplanning.
- Netwerken: Pakketbuffering en -routering.
- Games: Spelerstatus trackoning en roosters.
| Domein | Array-rol |
|---|---|
| AI / ML | Tensor- en matrixrepresentatie |
| dbms | Indexering en zoekmachineoptimalisatie |
| Embedded Systems | Realtime sensorgegevens |
| Cloud Computing | Load distributie arrays |
Arrays bieden de ruggengraat voor efficiënte gegevensorganisatie, berekening en schaalbaarheid.
🔍 Top Array Interviewvragen met realistische scenario's en strategische antwoorden
1) Wat is een array en hoe verschilt het van andere datastructuren?
Verwacht van kandidaat: De interviewer wil graag uw fundamentele kennis van arrays beoordelen, waaronder hun doel, structuur en hoe ze verschillen van andere gegevenstypen, zoals gekoppelde lijsten of hashmaps.
Voorbeeld antwoord:
Een array is een verzameling elementen die zijn opgeslagen in aaneengesloten geheugenlocaties, waarbij elk element toegankelijk is via een index. In tegenstelling tot gekoppelde lijsten bieden arrays constante toegang (O(1)) tot elementen, maar vereisen ze een vaste grootte die is gedefinieerd op het moment van aanmaken. Dit maakt ze efficiënt voor leesbewerkingen, maar minder flexibel voor invoegingen en verwijderingen.
2) Hoe vind je op efficiënte wijze de grootste en kleinste elementen in een array?
Verwacht van kandidaat: De interviewer wil uw algoritmische denkvermogen en uw vermogen om prestaties te optimaliseren, testen.
Voorbeeld antwoord:
“Om efficiënt zowel het grootste als het kleinste element in een array te vinden, zou ik één keer door de array itereren,ping track van het huidige maximum en minimum. Deze aanpak heeft een tijdscomplexiteit van O(n) en een ruimtecomplexiteit van O(1), wat optimaal is voor dit probleem.”
3) Beschrijf hoe u duplicaten uit een ongesorteerde array verwijdert.
Verwacht van kandidaat: De interviewer wil graag uw kennis van arraymanipulatie en datastructuren in kaart brengen, zodat u deze taak kunt uitvoeren.
Voorbeeld antwoord:
Ik zou een hashset gebruiken om unieke elementen op te slaan tijdens het itereren door de array. Als een element al in de set staat, zou ik het overslaan; anders zou ik het toevoegen. Deze methode zorgt ervoor dat duplicaten efficiënt worden verwijderd met een tijdscomplexiteit van O(n) en een ruimtecomplexiteit van O(n)."
4) Kunt u uitleggen hoe array sorting werkt en een paar veelgebruikte algoritmen noemen?
Verwacht van kandidaat: De interviewer verwacht dat u bekend bent met verschillende sorteeralgoritmen en hun toepassingsmogelijkheden.
Voorbeeld antwoord:
“Arraysortering kan worden bereikt met behulp van verschillende algoritmen zoals Quick Sort, Merge Sort en Bubble Sorteren. Snel sorteren is efficiënt voor gemiddelde gevallen met een complexiteit van O(n log n), terwijl Samenvoegen sorteren de voorkeur heeft voor grote datasets vanwege de stabiele aard ervan. Bubble Sort wordt, hoewel eenvoudig, zelden gebruikt vanwege de O(n²)-prestaties.”
5) Vertel eens over een situatie waarin je een programma hebt geoptimaliseerd dat veel gebruikmaakte van arrays.
Verwacht van kandidaat: De interviewer wil graag inzicht krijgen in uw probleemoplossende aanpak en uw vermogen om uw prestaties te verbeteren.
Voorbeeld antwoord:
In mijn vorige functie optimaliseerde ik een dataverwerkingsscript dat afhankelijk was van meerdere geneste lussen over arrays. Door array slicing te implementeren en ingebouwde vectorbewerkingen te gebruiken, heb ik de uitvoeringstijd met bijna 60 procent verkort, wat de systeemresponsiviteit aanzienlijk heeft verbeterd.
6) Hoe ga je om met een out-of-bound array index-fout?
Verwacht van kandidaat: De interviewer toetst uw begrip van foutbehandeling en veilige coderingspraktijken.
Voorbeeld antwoord:
Ik zou ervoor zorgen dat alle indextoegangen gevalideerd worden voordat ze worden gebruikt door te controleren of ze binnen het bereik van de arraylengte vallen. Daarnaast zou ik try-catch-mechanismen of gelijkwaardige foutverwerkingsmethoden implementeren om onverwachte out-of-bound-fouten op een elegante manier te beheren.
7) Hoe keer je een array om zonder extra geheugen te gebruiken?
Verwacht van kandidaat: De interviewer wil uw algoritmische efficiëntie en begrip van de werkzaamheden ter plaatse beoordelen.
Voorbeeld antwoord:
“Ik zou twee pointers gebruiken: één aan het begin van de array en de andere aan het einde. Door ze te verwisselenping Door de elementen op deze posities te verplaatsen en beide pointers naar het midden te bewegen, kan de array ter plekke worden omgekeerd met een tijdscomplexiteit van O(n) en een ruimtecomplexiteit van O(1).
8) Beschrijf een situatie waarin je een grote dataset met arrays moest beheren. Hoe heb je de prestaties en nauwkeurigheid gewaarborgd?
Verwacht van kandidaat: De interviewer wil een beeld krijgen van uw vermogen om met databeheer en prestatieoptimalisatie in de praktijk om te gaan.
Voorbeeld antwoord:
“Bij mijn vorige baan werkte ik met grote numerieke arrays voor financiële data-analyse. Om de prestaties te behouden, gebruikte ik efficiënte geheugenbeheertechnieken en batchverwerking. Ik maakte ook gebruik van NumPy-arrays om vectorbewerkingen uit te voeren, wat zowel de nauwkeurigheid als de uitvoeringssnelheid verbeterde.”
9) Welke stappen zou u nemen om naar een specifieke waarde in een gesorteerde array te zoeken?
Verwacht van kandidaat: De interviewer verwacht dat u kennis heeft van zoekalgoritmen.
Voorbeeld antwoord:
Voor een gesorteerde array zou ik het binaire zoekalgoritme gebruiken, dat het zoekinterval herhaaldelijk doormidden deelt. Deze aanpak reduceert de tijdscomplexiteit tot O(log n), waardoor het veel efficiënter is dan een lineaire zoekactie naar grote datasets.
10) Welke rol spelen arrays bij het oplossen van echte problemen in softwareontwikkeling?
Verwacht van kandidaat: De interviewer wil graag weten hoe u technische kennis koppelt aan praktische toepassingen.
Voorbeeld antwoord:
Arrays zijn essentieel in softwareontwikkeling omdat ze efficiënte dataopslag en -opvraging ondersteunen. In mijn vorige functie gebruikte ik bijvoorbeeld arrays om cachingmechanismen en datasortering voor analysedashboards te implementeren. Dit verbeterde de toegankelijkheid van data en verkortte de responstijden van query's.
