АСП2/К3 2020 - Историја измена

KockaBot: Замена начина истицања милокода.

2024-09-13T00:09:18Z

Замена начина истицања милокода.

← Старија измена		Верзија на датум 13. септембар 2024. у 02:09
Ред 8:		Ред 8:
	=== Rešenje ===		=== Rešenje ===
	Prvo tražimo lokaciju ključa za uklanjanje a zatim, ako je ključ pronađen, prevezujemo prethodnu posećenu zauzetu lokaciju, brišemo ključ iz tabele i ažuriramo pokazivač ''free''.		Prvo tražimo lokaciju ključa za uklanjanje a zatim, ako je ključ pronađen, prevezujemo prethodnu posećenu zauzetu lokaciju, brišemo ključ iz tabele i ažuriramo pokazivač ''free''.
	<~~syntaxhighlight lang="milo"~~>		{{Милокод\|<nowiki>
	DELETE ENTRY(table, n, key, free)		DELETE ENTRY(table, n, key, free)
	prev_adr = -1		prev_adr = -1
Ред 26:		Ред 26:
	end_if		end_if
	end_if		end_if
	</~~syntaxhighlight~~>		</nowiki>}}
	Po novijoj verziji knjige profesora Mila V. Tomaševića pri objedinjenom ulančavanju bi trebalo da se na oslobođeno mesto prebacuje ključ sa kraja liste u kojoj se nalazio, i takav pristup se nalazi ispod:		Po novijoj verziji knjige profesora Mila V. Tomaševića pri objedinjenom ulančavanju bi trebalo da se na oslobođeno mesto prebacuje ključ sa kraja liste u kojoj se nalazio, i takav pristup se nalazi ispod:
	<~~syntaxhighlight lang="milo"~~>		{{Милокод\|<nowiki>
	DELETE ENTRY(table, n, key, free)		DELETE ENTRY(table, n, key, free)
	prev_adr = -1		prev_adr = -1
Ред 61:		Ред 61:
	end_if		end_if
	end_if		end_if
	</~~syntaxhighlight~~>		</nowiki>}}

	== 2. zadatak ==		== 2. zadatak ==
Ред 101:		Ред 101:
	=== Rešenje ===		=== Rešenje ===
	Algoritam prvo pronalazi ključ u hipu iterativnim obilaskom niza (ne postoji efikasnija tehnika od te jer hip ne daje nikakve garancije da će se dati element naći u levom ili desnom podstablu).		Algoritam prvo pronalazi ključ u hipu iterativnim obilaskom niza (ne postoji efikasnija tehnika od te jer hip ne daje nikakve garancije da će se dati element naći u levom ili desnom podstablu).
	<~~syntaxhighlight lang="milo"~~>		{{Милокод\|<nowiki>
	HEAP CHANGE(heap, n, key, new_key)		HEAP CHANGE(heap, n, key, new_key)
	pos = -1		pos = -1
Ред 139:		Ред 139:
	end_while		end_while
	end_if		end_if
	</~~syntaxhighlight~~>		</nowiki>}}

	== 4. zadatak ==		== 4. zadatak ==
Ред 306:		Ред 306:
	* Pošto nam je dato da se polazni niz može modifikovati, može se koristiti ''heapsort'' kako bi se u vremenskoj složenosti <math>\mathcal{O}(n \log n)</math> i prostornoj složenosti <math>\mathcal{O}(1)</math> pronašla tražena vrednost		* Pošto nam je dato da se polazni niz može modifikovati, može se koristiti ''heapsort'' kako bi se u vremenskoj složenosti <math>\mathcal{O}(n \log n)</math> i prostornoj složenosti <math>\mathcal{O}(1)</math> pronašla tražena vrednost
	Ispod je dato rešenje pomoću ''counting sort''.		Ispod je dato rešenje pomoću ''counting sort''.
	<~~syntaxhighlight lang="milo"~~>		{{Милокод\|<nowiki>
	FIND MAX REP(arr, n, k)		FIND MAX REP(arr, n, k)
	rep_max = 0		rep_max = 0
Ред 321:		Ред 321:
	end_for		end_for
	return rep_elem		return rep_elem
	</~~syntaxhighlight~~>		</nowiki>}}

	[[Категорија:АСП2]]		[[Категорија:АСП2]]
	[[Категорија:Рокови]]		[[Категорија:Рокови]]

KockaAdmiralac: PNG u SVG

2022-02-13T21:24:45Z

PNG u SVG

← Старија измена		Верзија на датум 13. фебруар 2022. у 23:24
Ред 217:		Ред 217:
	Ispod je dato konačno rešenje zadatka, a koraci se mogu simulirati u [https://www.cs.usfca.edu/~galles/visualization/BinomialQueue.html simulatoru binomnih hipova,] redom umetanjem ključeva 19, 41, 15, 29, 17, 25, 3, 10 i 14, pa zatim izvršavati zadate operacije.		Ispod je dato konačno rešenje zadatka, a koraci se mogu simulirati u [https://www.cs.usfca.edu/~galles/visualization/BinomialQueue.html simulatoru binomnih hipova,] redom umetanjem ključeva 19, 41, 15, 29, 17, 25, 3, 10 i 14, pa zatim izvršavati zadate operacije.

	<gallery>		<gallery class="transparent-svg">
	ASP2 K3 2020 zadatak 5 hip postavka.~~png~~ \| Ispravljena postavka zadatka		ASP2 K3 2020 zadatak 5 hip postavka.svg \| Ispravljena postavka zadatka
	ASP2 K3 2020 zadatak 5 hip rešenje.~~png~~ \| Konačni izgleda hipa		ASP2 K3 2020 zadatak 5 hip rešenje.svg \| Konačni izgleda hipa
	</gallery>		</gallery>

Etfsibg: /* Rešenje */

2022-01-20T12:50:23Z

Rešenje

← Старија измена		Верзија на датум 20. јануар 2022. у 14:50
Ред 56:		Ред 56:
	key(table[adr]) = key(table[last_adr])		key(table[adr]) = key(table[last_adr])
	key(table[last_adr]) = empty		key(table[last_adr]) = empty
	~~next(table[last_adr]) = -1~~
	if last_adr > free then		if last_adr > free then
	free = last_adr		free = last_adr

KockaAdmiralac: Dodata provera koje je dete veće pre zamene sa detetom

2021-02-17T23:10:05Z

Dodata provera koje je dete veće pre zamene sa detetom

← Старија измена		Верзија на датум 18. фебруар 2021. у 01:10
Ред 127:		Ред 127:
	else if ((child_pos_1 ≤ n) and (heap[child_pos_1] < heap[pos])) or ((child_pos_2 ≤ n) and (heap[child_pos_2] < heap[pos])) then		else if ((child_pos_1 ≤ n) and (heap[child_pos_1] < heap[pos])) or ((child_pos_2 ≤ n) and (heap[child_pos_2] < heap[pos])) then
	while ((child_pos_1 ≤ n) and (heap[child_pos_1] < heap[pos])) or ((child_pos_2 ≤ n) and (heap[child_pos_2] < heap[pos])) do		while ((child_pos_1 ≤ n) and (heap[child_pos_1] < heap[pos])) or ((child_pos_2 ≤ n) and (heap[child_pos_2] < heap[pos])) do
	if (child_pos_1 ≤ n) and (heap[child_pos_1] < heap[pos]) then		if (child_pos_1 ≤ n) and (heap[child_pos_2] < heap[child_pos_1] < heap[pos]) then
	heap[pos] = heap[child_pos_1]		heap[pos] = heap[child_pos_1]
	heap[child_pos_1] = new_key		heap[child_pos_1] = new_key

KockaAdmiralac: Dodato alternativno rešenje od `<@142395301863358466>` na osnovu novog izdanja knjige

2021-02-10T22:42:56Z

Dodato alternativno rešenje od `<@142395301863358466>` na osnovu novog izdanja knjige

@@ Ред 24: / Ред 24: @@
      if adr > free then
          free = adr
      end_if
 end_if

KockaAdmiralac: Ispravka HEAP CHANGE algoritma (više se ne pretpostavlja sortiranost dece i rukovodi se slučajem kada je novi ključ veći od dece) i shellsort rezultata (korak 3 se ponavlja dvaput jer nakon prvog nije dobijen sortiran niz)

2021-01-18T22:46:24Z

Ispravka HEAP CHANGE algoritma (više se ne pretpostavlja sortiranost dece i rukovodi se slučajem kada je novi ključ veći od dece) i shellsort rezultata (korak 3 se ponavlja dvaput jer nakon prvog nije dobijen sortiran niz)

← Старија измена		Верзија на датум 19. јануар 2021. у 00:46
Ред 72:		Ред 72:
	if heap[i] = key then		if heap[i] = key then
	pos = i		pos = i
	~~break~~
	~~else if heap[i] > key then~~
	break		break
	end_if		end_if
Ред 82:		Ред 80:
	heap[pos] = new_key		heap[pos] = new_key
	parent_pos = pos / 2		parent_pos = pos / 2
	while (parent_pos > 0) and (heap[parent_pos] > heap[pos]) do		child_pos_1 = pos * 2
	heap[pos] = heap[parent_pos]		child_pos_2 = pos * 2 + 1
	heap[parent_pos] = new_key		if (parent_pos > 0) and (heap[parent_pos] > heap[pos]) then
	pos = parent_pos		while (parent_pos > 0) and (heap[parent_pos] > heap[pos]) do
	parent_pos = pos / 2		heap[pos] = heap[parent_pos]
	end_while		heap[parent_pos] = new_key
			pos = parent_pos
			parent_pos = pos / 2
			end_while
			else if ((child_pos_1 ≤ n) and (heap[child_pos_1] < heap[pos])) or ((child_pos_2 ≤ n) and (heap[child_pos_2] < heap[pos])) then
			while ((child_pos_1 ≤ n) and (heap[child_pos_1] < heap[pos])) or ((child_pos_2 ≤ n) and (heap[child_pos_2] < heap[pos])) do
			if (child_pos_1 ≤ n) and (heap[child_pos_1] < heap[pos]) then
			heap[pos] = heap[child_pos_1]
			heap[child_pos_1] = new_key
			pos = child_pos_1
			else
			heap[pos] = heap[child_pos_2]
			heap[child_pos_2] = new_key
			pos = child_pos_2
			end_if
			child_pos_1 = pos * 2
			child_pos_2 = pos * 2 + 1
			end_while
			end_if
	</syntaxhighlight>		</syntaxhighlight>

Ред 192:		Ред 208:
	! 3		! 3
	\| 7 \|\| 8 \|\| 45 \|\| 57 \|\| 42 \|\| 101 \|\| 95 \|\| 159 \|\| 74 \|\| 103 \|\| 303 \|\| 179 \|\| 219		\| 7 \|\| 8 \|\| 45 \|\| 57 \|\| 42 \|\| 101 \|\| 95 \|\| 159 \|\| 74 \|\| 103 \|\| 303 \|\| 179 \|\| 219
			\|-
			! 3
			\| 7 \|\| 8 \|\| 45 \|\| 57 \|\| 42 \|\| 74 \|\| 95 \|\| 159 \|\| 101 \|\| 103 \|\| 303 \|\| 179 \|\| 219
	\|-		\|-
	! 2		! 2
	\| 7 \|\| 8 \|\| 42 \|\| 57 \|\| 45 \|\| ~~101~~ \|\| 74 \|\| 103 \|\| 95 \|\| 159 \|\| 219 \|\| 179 ~~\|\| 303~~		\| 7 \|\| 8 \|\| 42 \|\| 57 \|\| 45 \|\| 74 \|\| 95 \|\| 103 \|\| 101 \|\| 159 \|\| 219 \|\| 179 \|\| 303
	\|-
	~~! 1~~
	~~\| 7 \|\| 8 \|\| 42 \|\| 45 \|\| 57 \|\| 74 \|\| 101 \|\| 95 \|\| 103 \|\| 159 \|\| 179 \|\| 219~~ \|\| 303
	\|-		\|-
	! 1		! 1

KockaAdmiralac: ...eto

2020-12-28T22:28:55Z

...eto

Нова страница

{{tocright}}
[https://rti.etf.bg.ac.rs/rti/ri3sp/rokovi/13S112ASP2_K3_1920.pdf Postavka na stranici predmeta.]

== 1. zadatak ==
=== Postavka ===
Upotrebom tehnike objedinjenog ulančavanja implementirati funkciju DELETE_ENTRY koja treba da iz heš tabele (''table'') fizički ukloni prosledjeni<sup>[sic]</sup> ključ (''key'') ukoliko on postoji. Tabela ima ''n'' ulaza, a funkcija treba da ažurira i index ''free'' tako da ne postoji slobodna lokacija sa većim indeksom.

=== Rešenje ===
Prvo tražimo lokaciju ključa za uklanjanje a zatim, ako je ključ pronađen, prevezujemo prethodnu posećenu zauzetu lokaciju, brišemo ključ iz tabele i ažuriramo pokazivač ''free''.
<syntaxhighlight lang="milo">
DELETE ENTRY(table, n, key, free)
prev_adr = -1
adr = h(key)
while (adr ≠ -1) and (key(table[adr]) ≠ key) do
prev_adr = adr
adr = next(table[adr])
end_while
if adr ≠ -1 then
if prev_adr ≠ -1 then
next(table[prev_adr]) = next(table[adr])
end_if
key(table[adr]) = empty
next(table[adr]) = -1
if adr > free then
free = adr
end_if
end_if
</syntaxhighlight>

== 2. zadatak ==
=== Postavka ===
Radix exchange algoritam.
<div class="abc-list">
# Prikazati prve tri iteracije algoritma radix exchange nad sledećom sekvencom 5-bitnih neoznačenih celobrojnih ključeva:
# Da li je algoritam stabilan? Obrazložiti ukratko.
</div>

=== Rešenje ===
Prvo odvajamo ključeve na bitove:
* 4 — 00100
* 7 — 00111
* 9 — 01001
* 10 — 01010
* 15 — 01111
* 16 — 10000
* 18 — 10010
* 23 — 10111
{| class="wikitable"
|+ Prve tri iteracije ''radix exchange'' algoritma nad sekvencom
! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7
|-
| 7 || 18 || 23 || 4 || 10 || 16 || 9 || 15
|-
| 7 || 15 || 9 || 4 || 10 || 16 || 23 || 18
|-
| 7 || 4 || 9 || 15 || 10 || 16 || 23 || 18
|-
| 7 || 4 || 9 || 10 || 15 || 16 || 18 || 23
|}
Ovaj algoritam nije stabilan jer funkcioniše po sličnom principu kao ''quicksort'' zamena. Stabilnost algoritma podrazumeva da se jednaki elementi sortiraju po indeksu u originalnom poretku, a ovde se može desiti da se prilikom zamene element koji je bio prvi među jednakima prebaci na kraj.

== 3. zadatak ==
=== Postavka ===
Posmatra se rastuće uređeni '''binarni hip''', koji je dat u vidu niza ključeva ''heap''. Napisati u pseudokodu efikasnu iterativnu funkciju koja menja vrednost zadatog ključa ''key'', na zadatu vrednost ''new_key''. Poznato je da hip ima ''n'' elemenata.

=== Rešenje ===
Algoritam prvo pronalazi ključ u hipu iterativnim obilaskom niza (ne postoji efikasnija tehnika od te jer hip ne daje nikakve garancije da će se dati element naći u levom ili desnom podstablu).
<syntaxhighlight lang="milo">
HEAP CHANGE(heap, n, key, new_key)
pos = -1
for i = 1 to n do
if heap[i] = key then
pos = i
break
else if heap[i] > key then
break
end_if
end_for
if pos = -1 then
ERROR(Ključ nije u hipu)
end_if
heap[pos] = new_key
parent_pos = pos / 2
while (parent_pos > 0) and (heap[parent_pos] > heap[pos]) do
heap[pos] = heap[parent_pos]
heap[parent_pos] = new_key
pos = parent_pos
parent_pos = pos / 2
end_while
</syntaxhighlight>

== 4. zadatak ==
=== Postavka ===
Podaci se smeštaju u heš tabelu sa 7 ulaza primenom heš funkcije h<sub>p</sub>(K) = K mod 7. Za razrešavanje kolizija se koristi tehnika kvadratnog pretraživanja. U tabelu se umeću redom ključevi 38, 31, 10, 56, 21. Odrediti prosečan broj pristupa prilikom uspešnog i neuspešnog traženja i verovatnoću popunjavanja praznih ulaza, pod pretpostavkom da su svi ključevi jednako verovatni.

=== Rešenje ===
Ovaj zadatak je rešen na [https://rti.etf.bg.ac.rs/rti/ri3sp/materijali/si2asp2/09_Hesiranje.ppt prezentaciji iz heširanja] na stranici predmeta.
{| class="wikitable"
|+ Popunjena heš tabela
| 0 || 10
|-
| 1 || 56
|-
| 2 || 21
|-
| 3 || 38
|-
| 4 || 31
|-
| 5 ||
|-
| 6 ||
|}
{| class="wikitable"
|+ Ispitni nizovi za kvadratno pretraživanje
! i / K % 7 !! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6
|-
! 0
| 0 || 1 || 2 || 3 || 4 || 5 || 6
|-
! 1
| 1 || 2 || 3 || 4 || 5 || 6 || 0
|-
! 2
| 4 || 5 || 6 || 0 || 1 || 2 || 3
|-
! 3
| 2 || 3 || 4 || 5 || 6 || 0 || 1
|-
! 4
| 2 || 3 || 4 || 5 || 6 || 0 || 1
|-
! 5
| 4 || 5 || 6 || 0 || 1 || 2 || 3
|-
! 6
| 1 || 2 || 3 || 4 || 5 || 6 || 0
|}
* Umetanje:
** 38 % 7 = 3 (1 pristup)
** 31 % 7 = 3 (2 pristupa)
*** (3 + 1*1) % 7 = 4
** 10 % 7 = 3 (3 pristupa)
*** (3 + 1*1) % 7 = 4
*** (3 + 2*2) % 7 = 0
** 56 % 7 = 0 (2 pristupa)
*** (0 + 1*1) % 7 = 1
** 21 % 7 = 0 (4 pristupa)
*** (0 + 1*1) % 7 = 1
*** (0 + 2*2) % 7 = 4
*** (0 + 3*3) % 7 = 2
* Prosečan broj uspešnih pristupa: <math>P_u = \frac{1 + 2 + 3 + 2 + 4}{5} = \frac{12}{5} = 2.4</math>
* Prosečan broj neuspešnih pristupa: <math>P_nu = 1 + \frac{5}{7} + \frac{5 \cdot 4}{7 \cdot 6} + \frac{5 \cdot 4 \cdot 3}{7 \cdot 6 \cdot 5} + \frac{5 \cdot 4 \cdot 3 \cdot 2}{7 \cdot 6 \cdot 5 \cdot 4} + \frac{5 \cdot 4 \cdot 3 \cdot 2 \cdot 1}{7 \cdot 6 \cdot 5 \cdot 4 \cdot 3} =</math>
*: <math>= 1 + \frac{5}{7} + \frac{10}{21} + \frac{2}{7} + \frac{1}{7} + \frac{1}{21} = \frac{8}{3} \approx 2.67</math>
* Verovatnoća popunjavanja:
** 5: <math>\frac{0 + 1 + 0 + 1 + 1 + 1 + 0}{7} = \frac{4}{7}</math>
** 6: <math>\frac{0 + 0 + 1 + 0 + 0 + 0 + 1}{7} = \frac{2}{7}</math>

== 5. zadatak ==
=== Postavka ===
Prikazati izgled '''binomnog hipa''' nakon svake izmene, ukoliko se prvo obriše minimum, pa se nakon toga dodaju ključevi 2, 32, 4 i nakon toga ponovo obriše minimum.

=== Rešenje ===
U originalnoj postavci je umesto broja 19 stajao broj 9. Hip tada ne bi bio validan, tako da se u rešenju smatra da je tu broj 19.

Ispod je dato konačno rešenje zadatka, a koraci se mogu simulirati u [https://www.cs.usfca.edu/~galles/visualization/BinomialQueue.html simulatoru binomnih hipova,] redom umetanjem ključeva 19, 41, 15, 29, 17, 25, 3, 10 i 14, pa zatim izvršavati zadate operacije.

<gallery>
ASP2 K3 2020 zadatak 5 hip postavka.png | Ispravljena postavka zadatka
ASP2 K3 2020 zadatak 5 hip rešenje.png | Konačni izgleda hipa
</gallery>

== 6. zadatak ==
=== Postavka ===
Data je sekvenca ključeva: 159, 57, 103, 7, 74, 95, 8, 101, 179, 45, 303, 42, 219. Prikazati rad ''shell sort'' algoritma po koracima. Navesti korišćenu sekvencu inkremenata i obrazložiti izbor.

=== Rešenje ===
Data sekvenca ima 13 ključeva, i ono što inkrementi u ''shell sort'' algoritmu treba idealno da postignu jeste mešanje ključeva između "grupa", te se zato biraju uzajamno prosti inkrementi 7, 5, 3, 2 i 1.
{| class="wikitable"
|+ Koraci ''shell sort'' algoritma
! Inkrement !! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8 !! 9 !! 10 !! 11 !! 12
|-
! Početak
| 159 || 57 || 103 || 7 || 74 || 95 || 8 || 101 || 179 || 45 || 303 || 42 || 219
|-
! 7
| 101 || 57 || 45 || 7 || 42 || 95 || 8 || 159 || 179 || 103 || 303 || 74 || 219
|-
! 5
| 95 || 8 || 45 || 7 || 42 || 101 || 57 || 159 || 179 || 103 || 303 || 74 || 219
|-
! 3
| 7 || 8 || 45 || 57 || 42 || 101 || 95 || 159 || 74 || 103 || 303 || 179 || 219
|-
! 2
| 7 || 8 || 42 || 57 || 45 || 101 || 74 || 103 || 95 || 159 || 219 || 179 || 303
|-
! 1
| 7 || 8 || 42 || 45 || 57 || 74 || 101 || 95 || 103 || 159 || 179 || 219 || 303
|-
! 1
| 7 || 8 || 42 || 45 || 57 || 74 || 95 || 101 || 103 || 159 || 179 || 219 || 303
|}

== 7. zadatak ==
=== Postavka ===
Neka se kod spoljašnjeg heširanja koristi tehnika dinamičkog heširanja. Heš tabela se sastoji od 4 baketa kapaciteta b = 2. Za heš funkciju se koriste viši bitovi heš funkcije K ''mod'' 8. Neka se u tabelu umeću redom ključevi 37, 33, 15, 24, 37, 46, 41 i 54. Ilustrovati stanje tabele nakon svakog razrešenja kolizije pri umetanju i u završnom stanju.

=== Rešenje ===
[ 00 | 01 | 10 | 11 ]
|
[37 ]

[ 00 | 01 | 10 | 11 ]
| |
[33 ] [37 ]

[ 00 | 01 | 10 | 11 ]
| | |
[33 ] [37 ][15 ]

[ 00 | 01 | 10 | 11 ]
| | |
[33 24] [37 ][15 ]

[ 00 | 01 | 10 | 11 ]
| | |
[33 24] [37 37][15 ]

[ 00 | 01 | 10 | 11 ]
| | |
[33 24] [37 37][15 46]

[ 00 | 01 | 10 | 11 ]
| | |
/ \ | |
| | | |
[24 ][33 41] [37 37][15 46]
000... 001...

[ 00 | 01 | 10 | 11 ]
| | |
/ \ / / \
| | | | |
[24 ][33 41][37 37][46 54][15 ]
000... 001... 110... 111...

== 8. zadatak ==
=== Postavka ===
Neka je dat niz celih brojeva ''arr'' dužine ''n'' čiji se elementi nalaze u opsegu od 0 do ''k''-1. Napisati u pseudokodu iterativnu funkciju koja pronalazi element koji se najčešće pojavljuje u nizu. Ukoliko ima više takvih elemenata dovoljno je pronaći jedan. Funkcija treba da ima što je moguće bolju vremensku i prostornu složenost. Dozvoljeno je modifikovati polazni niz.

=== Rešenje ===
Ovde su dva rešenja pogodna:
* Pošto nam je dat opseg vrednosti u nizu, može se koristiti ''counting sort'' kako bi se u vremenskoj složenosti <math>\mathcal{O}(n)</math> i prostornoj složenosti <math>\mathcal{O}(k)</math> pronašla vrednost koja se najviše ponavlja
* Pošto nam je dato da se polazni niz može modifikovati, može se koristiti ''heapsort'' kako bi se u vremenskoj složenosti <math>\mathcal{O}(n \log n)</math> i prostornoj složenosti <math>\mathcal{O}(1)</math> pronašla tražena vrednost
Ispod je dato rešenje pomoću ''counting sort''.
<syntaxhighlight lang="milo">
FIND MAX REP(arr, n, k)
rep_max = 0
rep_elem = 0
for i = 0 to k-1 do
c[i] = 0
end_for
for i = 1 to n do
c[arr[i]] = c[arr[i]] + 1
if c[arr[i]] > rep_max then
rep_max = c[arr[i]]
rep_elem = arr[i]
end_if
end_for
return rep_elem
</syntaxhighlight>

[[Категорија:АСП2]]
[[Категорија:Рокови]]