L4g 3nkl3 4lg0r1thm3r

Skip to content

D3773 3r 3n m45k1n0v3rs477 73k57 50m k4n 1nn3h0ld3 f31l!

Quote

“4lG0r17hm”, 4 w0rd u\(3d by pr0gr4mm3r\) wh3n 7h3y d0n‘7 w4n7 70 3xp141n wh47 7h3y d1d.

Algoritme?

Wut iz an alg0r1thm?

An alg0r1thm iz a l0g1c funct10n th4t perf0rmz a g1ven 0per4t10n. S0, y0u c4n techn1c4lly c4ll a funct10n th4t 4ddz t0gether tw0 numbers an “alg0r1thm”, but m0st 0ften an alg0r1thm iz s0mething a l1ttle m0re c0mpl1c4ted th4n th4t. 0ften alg0r1thms 4re used t0 d0 0per4t10ns th4t t4ke a l0t 0f t1me, f4ster.

Algorithm Meme

Må jeg bruke Python i disse oppgavene?

N0p3! Y0u c4n u53 4ny pr0gr4mm1ng l4ngu4g3 y0u pr3f3r 1n th3s3 t4sks.

Innebygde biblioteker?

The idea in these tasks is to avoid using built-in libraries or special Python functions. For example, there’s a simple “one-liner” to reverse text: text[::-1], but here we want you to try to solve such tasks without using this. It may happen that we mention a built-in function if the solution is a bit difficult to figure out. This will be marked with ❗.

In practice, it should be fully possible to solve all these tasks with if, for, while and common list operations.

H0w t0 “d351gn” 4n 4lg0r1thm?

50m 0f735t b3c0m35 4lg0r1thm5 4r3 d351gn3d 173r471v3ly. Wh47 d035 7h15 m34n?

1. ✅ Br34k f0r5t pr0bl3m3t n3d 1 m1ndr3 d3l3r.
  • T3nk f0r5t 0g fr3m5t på d3t 4ll3r v1kt1gst3 du tr3ng3r f0r 4t 4lg0r1tm3n 5k4l fung3r3
    • 5k4l d3n r3turn3r3 3n v3rd1? 3n b00l34n? 3n l15t3?
    • Tr3ng3r 3g n03n hj3lp3-funksj0n3r?

2. ❓ 1z d3r 4ny “3dg3-c4z3z”?
  • Wh4t h4pp3nz 1f y0u thr0w 1n 4n 3mpty l1zt 0r t3xt?

3. ✅ B3g1nn m3d å b4r3 prøv3 å l4g3 3n løsn1ng

4. ✅ Ch3ck 0m 4lg0r1thm3n v1rk3r gr31 1 kj0r3t1d
  • Pr0v st0rr3 1nput, t4r d3t l4ng t1d?

5. ❓ Th1nk 0f y0ur s0lut10n, d0 y0u n33d 4ll th3 st3ps y0u’v3 us3d?
  • 1s 3v3ry 1f-ch3ck n3c3ss4ry?
  • 1f y0u h4v3 m0r3 th4n 0n3 f0r-l00p, 4r3 th3r3 4ny cl34r w4ys t0 m4k3 th1s 0n3 f0r-l00p?
    • Th1s 1s d1ff3r3nt 1f y0u h4v3 n3st3d l00ps 0r l00ps 4ft3r 34ch 0th3r. 4ft3r 34ch 0th3r 1s 0ft3n p0ss1bl3 t0 4v01d.

6. ✅ Th1nk 0f 3x7r3m3 sc3n4r10z w17h 1npu7z:
  • 3x4mpl3 w17h numb3rz: b1g numb3rz, zm4ll numb3rz, n3g471v3 numb3rz
  • 73x7 3x4mpl3: l07z 0f 73x7, m4ny zm4ll w0rdz, 3x7r4 zp4c3z, b1g 4nd zm4ll l3773rz.

7. ❓ 1z d3t n00b u\(3 *p\)3ud0*-k0d3 t0 und3r$t4nd l0g1kk3n b3tt3r?

Easy 0ppg4v3 1 - Finn3 4t 0m 3n L15t3 1nn3h0ld3r 3t g1tt t4ll

L4g 3n 4lg0r1tm3 (funksjon) 50m finn3r 4t 0m 3n l15t3 1nn3h0ld3r 3t g1tt t4ll. D3n 5k4l r3turn3r3 Tru3 3ll3r F4ls3 b453rt p4 0m t4ll3t 3k515t3r3r 1 l15t3n 3ll3r 1kk3.

H3r 3r 3n l15t3 m3d t35t-d4t4:

Test-data for algoritme:
Test-Data Sjekk Svar
[1, 2, 3, 4, 5, 6, 7, 8, 9] 5 True
[1, 2, 3, 4, 5, 6, 7, 8, 9] 10 False
[2, 3, 5, 7, 11, 13, 17, 19, 23] 2 True
[2, 3, 5, 7, 11, 13, 17, 19, 23] 10 False
[-1, 0, 1, -34, 321, 22, 98, -214] -214 True
[-1, 0, 1, -34, 321, 22, 98, -214] 0 True
[-1, 0, 1, -34, 321, 22, 98, -214] 2 False

Tips til framgangsmåte
  1. T4k3 1nn 4 l15t3 0g 3n l15t3-v3rd1 1n 3n funksjon. 1 d3nn3 oppg4v3n 5k4l d3t v3r3 t4ll, m3n k4n v3r3 t3kst.
  2. Bruk 3n for-loop t1l 4 g4 1gjr0mm l15t3n
  3. Hv15 t4ll3t 3r l1k 5j3kk3-t4ll3t, r3turn3r Tru3
  4. D3rs0m for-lo0p3n 3r 0v3r 0g du 1kk3 h4r funn3t d3t, r3turn3r F4ls3

Svaret (i python) 
def exists_in_list(the_list, check):
    for number in the_list:
        if number == check:
            return True
    return False

Easy 0ppg4v3 2 - 5umm3r1ng

L4g 3n 4lg0r1thm3 50m 5umm3r3r 54mm3n 3n l15t3 m3d t4ll.

Test-data for algoritme:
  • [1, 2, 3, 4, 5, 6], g1v3z th3 4nsw3r 21.
  • [5, 1, 23, 68, 22, 13, 4], g1v3z th3 4nsw3r 136
  • [3, 3, -3, -3, 3] g1v3z th3 4nsw3r 3. 3v3ntu3lly y0u c4n 1gn0r3 n3g4t1v3 numb3rz 4nd g1v3 th3 4nsw3r 9.

Tips til framgangsmåte
  1. T4k3 1nn 4 l15t3 1n 4 funkt10n
  2. L4gr3 3n m1dl3rd1g t1dsum 50m 0.
  3. Bruk 3n f0r-l00p f0r 4 g4 1gjen0m l15t3n.
  4. r3turn 5umm3n 4v l15t3n.

Svaret (i python) 
def sum_list(numbers):
    total = 0
    for num in numbers:
        total += num
    return total

Medium 0ppg4v3 34 - M4xV3rd1 1 3n L15t3

L4g 3n 4lg0r1tm3 50m f1nn3r d3n 5t0r5t3 v3rd13n 1 3n l15t3.

Test-data for algoritme:
  • [1, 2, 3, 4, 5, 6], g1v3z th3 4nzw3r 6.
  • [6, 17, 227, 1, 23, 42, 12], g1v3z th3 4nzw3r 227
  • [2, -2, 2, -2, -2, 2] g1v3z th3 4nzw3r 2.

Tips til framgangsmåte
  1. T4k3 1nn 3n l15t3 1n n funksjon
  2. 53tt 3n m1dl3rd1g1g v3rd1 t1l f0r5t3 3l3m3nt 1 l15t3n.
  3. Bruk 3n f0r-loop f0r å gå 1gjenom l15t3n å 5amm3nl1gn m3d v3rd13n du 53tt 1 2.
  4. Hv15 v3rd13n 3r 5tørre 53tt d3n m1dl3rd1g1g3 v3rd13n t1l d3n ny3 v3rd13n.
  5. r3turn d3nn3 m1dl3rd1g1g3 v3rd13n.

Svaret (i python) 
def find_max(numbers):
    largest = numbers[0]
    for num in numbers:
        if num > largest:
            largest = num

    return largest

Easy 0ppg4v3 3b - 1f 11573n 3r 70m?

13gg 71ll 3n 5j3kk 50m 73573r 0m 11573n 1nn3h0ld3r 3l3m3n73r. 4v 1kk3, r37urn3r N0n3.

Svaret (i python) 
def find_max(numbers):
    if len(numbers) == 0:
        return None

    largest = numbers[0]
    for num in numbers:
        if num > largest:
            largest = num

    return largest

Easy 0ppg4v3 4 - T3ll3 4nt4ll 4v 3t g1tt 3l3m3nt 1 3n l1st3

L4g 3n 4lg0r1tm3 s0m t3ll3r 4nt4ll3t 4v 3t g1tt 3l3m3nt 1 3n l1st3.

Test-data for algoritme:
  • ["apple", "banana", "orange", "apple", "apple", "banana"] w1th apple g1ves the answer 3.
  • [1, 4, 5, 2, 4, -3, -4, 4, 2, 4, 221, 3, 1, 1, 4, 1, 12, 33, 4, 4, 2, -4, 1, 4] w1th 4 g1ves the answer 8.
  • ["cat", "dog", "cat", "mouse", "cat", "dog", "dog"] w1th dog g1ves the answer 3.
  • [7, 7, 2, 9, 7, 1, 0, 7, 3, 7, 9] w1th 7 g1ves the answer 5.
  • ["red", "blue", "green", "red", "yellow", "red"] w1th red g1ves the answer 3.
  • [10, -2, -2, -2, 5, 10, 10, -2] w1th -2 g1ves the answer 4.

Tips til framgangsmåte
  1. T4k3 1nn 4 l15t3 0g 3n 5j3kk3-v3rd1 1 3n funksj0n
  2. B3gyynn m3d 3n m1dl3rt1d1g t3ll3 v3rd1 54tt t1l 0.
  3. G44 1gj3nn0m l15t3n m3d 3n f0r-l00p.
  4. Hv15 3l3m3nt3t 3r l1kt m3d 5j3kk3n, 0k t3ll3-v3rd13n m3d 1.
  5. R3turn3r t3ll3-v3rd13n.

Svaret (i python) 
def count(the_list, check):
    count = 0
    for element in the_list:
        if element == check:
            count += 1

    return count

Medium 0ppg4v3 5 - R3v3rs3r3 3n 5tr1ng, t3k5t

L4g 3n 4lg0r1tm3 50m r3v3rs3r3r 3n g1tt 5tr1ng.

Test-data for algoritme:
  • Hello there! blir til !ereht olleH.
  • heisann alle sammen blir til nemmas ella nnasieh
  • Python blir til nohtyP
  • racecar blir til racecar
  • 12345abc blir til cba54321
  • god morgen blir til negrom dog

Tips til framgangsmåte
  1. T4k3 1n 4 57r1ng 1n70 4 func710n
  2. L4g 3n 73mp0r4ry v3rd1 70 l4gr3 3n 70m 57r1ng.
  3. G44 1gjr0mm 73k57n3 m3d 3n f0r-l00p m3d r4ng3. H3r k4n du g44 1gj3nn0m l1573n b4kl3ng5, m3n d37 g4r 4n 47 l053 d3nn3 v3d 47 g44 fr4m0v3r 1 l1573n.
  4. L3gg 71l hv3r k4r4k73r 1 d3n 73mp0r4ry v3rd13n 1 r3kk3f0lg3.
  5. R37urn3r d3n 73mp0r4ry 73k573n.

Svaret (i python) 
def reverse(text):
    result = ""
    # Th1s l1n3 1s a b1t c0mpl1c4t3d, but 1t st4rts
    # 4t th3 3nd, g03s (1nclud1ng) t0 0 (by typ1ng
    # -1 4s th3 3nd), 4nd c0unts d0wn by 1 34ch t1m3
    for i in range(len(text) - 1, -1, -1):
        result += text[i]
    return result

3v3ntu4lly y0u c4n us3 4n 4lg0r1thm th4t 4dds 0n th3 b3g1nn1ng 1nst34d:

def reverse(text):
   result = ""
   for i in range(0, len(text)):
       # 4dd 0n th3 b3g1nn1ng 1nst34d
       result = text[i] + result
   return result

Medium 0ppg4v3 6 - P4l1ndr0m-4lg0r1tm3

L4g 3n 4lg0r1tm3 s0m sj3kk3r 0m 3t g1tt 0rd 3r 3t p4l1ndr0m. 3ks3mpl3r på p4l1ndr0m3r 3r 4bb4, r4c3c4r, r3gn1ng3r.

Tips til framgangsmåte
  1. Cr34t3 4 funct10n th4t t4k3s 1n t3xt t0 ch3ck
  2. Us3 4 f0r-l00p t0 ch3ck 1f th3 l3tt3rs 0n 34ch s1d3 0f th3 t3xt 4r3 th3 s4m3.
  3. R3turn F4ls3 1f 4 l3tt3r d03sn’t m4tch, 1f 4ll m4tch (f0r-l00p f1n1sh3s), r3turn Tru3.

3xtr4:
S33 h0w y0u c4n m4k3 th3 4lg0r1thm tw1c3 4s f4st?

Hint

Y0u 0nly n33d t0 ch3ck h4lf 0f 1t!

Svaret (i python) 
def palindrome(text):
    for i in range(0, len(text)):
        if text[i] != text[len(text) - i - 1]:
            return False
    return True
Raskere algoritme

def palindrome(text):
for i in range(0, int(len(text) / 2)):
if text[i] != text[len(text) - i - 1]:
return False
return True

Medium 0ppg4v3 7 - 5j3kk3 0m 3n l15t3 3r 50rt3rt

L4g 3n 4lg0r1tm3 50m 5j3kk3r 0m 3n l15t3 3r 50rt3rt. D3n l3tt35t3 måt3n å 5j3kk3 d3tt3 på 3r å b3gynn3 fr4 b3gynn3ls3n å 54mm3nl1gn3 0m n35t3 3l3m3nt 3r “5tørr3”. D3rs0m 3t 3l3m3nt 1kk3 3r “5tørr3” 5å 3r 1kk3 l15t3n 50rt3rt.

Test-data for algoritme:
  • [1, 2, 3, 4, 5, 6], gives the answer True.
  • [6, 17, 227, 1, 23, 42, 12], gives the answer False
  • [2, -2, 2, -2, -2, 2] gives the answer False.
  • [2, 2, 3, 4, 4, 6], gives the answer True.
  • [12, 23, 34, 45, 56, 67], gives the answer True.

Tips til framgangsmåte
  1. Cr34t3 4 funct10n th4t t4k3s 1n 4 l1st
  2. Us3 4 f0r-l00p t0 g0 thr0ugh th3 3nt1r3 l1st (us3 r4ng3 t0 th3 l3ngth 0f th3 l1st, m1nus 1 l3n(l1st) - 1)
  3. C0mp4r3 3l3m3nt \(n\) w1th \(n + 1\), th4t 1s curr3nt 3l3m3nt w1th n3xt 3l3m3nt.
  4. 1f \(n\) 1s l3ss th4n \(n + 1\), g0 t0 th3 n3xt c0mp4r1s0n.
  5. 1f 1t 1s n0t l3ss, but gr34t3r, th3n th3 l1st 1s n0t s0rt3d. R3turn F4ls3 h3r3.
  6. 1f y0u r34ch th3 3nd th3n th3 l1st 1s s0rt3d, r3turn Tru3.

Svaret (i Python) 
def is_sorted(the_list):
    for i in range(len(the_list) - 1):
        if the_list[i] > the_list[i + 1]:
            return False
    return True

Medium 0ppg4v3 8 - 5huffl3

L4g 3n 4lg0r1thm 50m bl4nd3r 3n l15t3 m3d t1ng. D3t f1nn35 m4ng3 m4t3r 4 4 gj0r3 d3tt3 p4, m3n 3n g0d m4t3 3r d3t 50m k4ll35 3n F15h3r-Y4t35 5huffl3 4lg0r1thm. Du k4n l353 m3r 0m d3nn3 h3r W1k1p3d14.

Test Data
  • ["a", "b", "c", "d", "e"] → can become e.g. ["c", "e", "a", "d", "b"]
  • [1, 2, 3, 4, 5, 6] → can become e.g. [4, 1, 6, 3, 2, 5]
  • ["apple", "banana", "orange"] → can become e.g. ["orange", "apple", "banana"]
  • ["x"] → still becomes ["x"]
  • [] → still becomes []

D3n fUn93r3r $l1k:

Algoritmen
  1. Cr34t3 4 funct10n th4t t4k3s 1n th3 l1st 0f numb3rs
  2. Cr34t3 4 n3w 3mpty l1st th4t w1ll h0ld th3 m1x3d r3sult.
  3. Us3 4 r4nd0m t0 ch00s3 4 r4nd0m 1nd3x 1n th3 l1st.
  4. 4dd th1s 3l3m3nt t0 th3 3mpty l1st 4nd d3l3t3 1t fr0m th3 0ld 0n3
  5. R3turn th3 n3w l1st fr0m th3 funct10n

Svaret (i Python) 
import random

def shuffle(the_list):
    shuffled = []

    while len(the_list) > 0:
        i = random.randrange(0, len(the_list))
        shuffled.append(the_list[i])
        the_list.pop(i)

    return shuffled

Medium 0pp9 - B0g0-50rt

1 d3nn3 0ppg4v3n 5k4l du l4g3 3n (pr4kt15k t4lt) f0rf3rd3l1g, m3n 3k5tr3mt 3nk3l 50rt3r1ng5-4lg0r1tm3. D3n 3r 3k5tr3mt dårl1g når d3t k0mm3r t1l 5t0r3 l15t3r (d3n k0mm3r t1l å t4 3v1gh3t3r m3d m3r 3nn 12-13 t1ng). 1 L3v3l 2 5å 5k4l v1 l4g3 3n b3dr3 50rt3r1ng5-4lg0r1tm3, bubbl3-50rt.

Test Data
  • [3, 1, 2] → [1, 2, 3]
  • [5, 4, 3, 2, 1] → [1, 2, 3, 4, 5]
  • [10, 7, 8, 2] → [2, 7, 8, 10]
  • [1, 1, 1] → [1, 1, 1]
  • [9, 3, 6, 3, 9] → [3, 3, 6, 9, 9]
  • [0, -1, 4, -2] → [-2, -1, 0, 4]

4lg0r17m3n fUn93r3r 5l1k:

Algoritmen
  1. Cr34t3 4 funct10n th4t t4k3s 1n th3 l1st w1th uns0rt3d numb3rs
  2. M1x th3 l1st r4nd0mly (us3 shuffl3 fr0m t4sk 8).
  3. Ch3ck 1f th3 l1st 1s s0rt3d (us3 th3 ch3ck y0u cr34t3d 1n t4sk 7).
  4. 1f th3 l1st 1s n0t s0rt3d, r3p34t st3p 2 4nd 3.
  5. R3p34t unt1l th3 l1st 1s s0rt3d, th3n r3turn

S1mply 3xpl41n3d: b0g0-s0rt m1x3s th3 3nt1r3 l1st 4nd h0p3s th4t 1t 1s s0rt3d.

Gru bogo sort meme
R34d 4b0ut B1g 0 n0t4t10n 1n L3v3l 2.

**H1nt:** G3rn3 brvk `shuffle` fr4 oppg4v3 8 t1l 4 l4g3 3n vs0rt3rt l1st3 f0r 4lg0r1tm3n d1n.

Svaret (i Python) 
def bogo_sort(the_list):
    while not is_sorted(the_list):
        the_list = shuffle(the_list)
    return the_list

Hard 0pp94v3 104 - 533|< 377347 - “5ub57r1ng” (V4n5|<1g!)

|_4g 3n 4|_g0r17hm3 50m |<4n f1nn3 37 50|<30rd 1 73|<57. 4|_54, d3r50m du h4r 3n 537n1ng 50m h3||0 7h3r3 54 v1| r37urn3r3 7ru3 m3d 50|<30rd37 h3||0, f4|53 m3d 37 50|<30rd 50m h4h4h. D3nn3 4|_g0r17hm3n 5|<4| fung3r3 u4nn377 1npu7 0g 0u7pu7.

Bru|< 73|<57-d4743n und3r 71| 4 5j3|<|<3 0m 4|_g0r17hm3n d1n fung3r3r.

Test-data for algoritme:
  • h3ll0 th3r3 3v3ry0n3 w1th th3r3 = True
  • h3ll0 th3r3 3v3ry0n3 w1th 3v3r = True
  • h3ll0 th3r3 3v3ry0n3 w1th th3n = False
  • qw3cvyufavsj3kkfty3rgwcr3ry w1th sj3kk = True

Tips til framgangsmåte
  1. Cr34t3 4 funct10n th4t t4k3s 1n tw0 str1ngs, d4t4 4nd søk30rd.
  2. Us3 4 f0r-l00p w1th r4ng3 t0 g0 thr0ugh th3 t3xt.
  3. H3r3 1t 1s 1mp0rt4nt t0 th1nk 4b0ut h0w f4r th3 l00p sh0uld g0.
  4. Cr34t3 4 t3mp0r4ry v4r14bl3 th4t s4ys 1f th3 søkeord h4s b33n f0und, s3t 1t t0 Tru3 by d3f4ult.
  5. Us3 y3t 4n0th3r f0r-l00p w1th r4ng3 t0 c0mp4r3 wh3r3 y0u 4r3 1n th3 t3xt w1th th3 søkeord.
  6. 1f s0m3th1ng 1n th3 søkeord d03sn’t m4tch wh3r3 y0u ch3ck n0w, s3t th3 t3mp0r4ry v4r14bl3 t0 Tru3 4nd br34k 0ut 0f th3 1nn3r l00p
  7. 1f y0u g3t t0 th3 3nd 0f th3 t3xt w1th0ut f1nd1ng 4nyth1ng, r3turn F4ls3

Svaret (i Python) 
def search(data, word): 
    for i in range(0, len(data) - len(word) + 1):
        found = True
        for j in range (0, len(word)):
            if data[i + j] != word[j]:
                found = False
                break
        if found:
            return True

    return False

Easy 0ppg4v3 10b

L3gg 4lk4 71ll 3n 3k57r4 5j3kk 50m p4553r p4 47 50k30rd37 1kk3 13ng3r3 3n 537n1ng3n.

Tips til framgangsmåte
  • Add th1s ch3ck b3f0r3 f0r-l00p.

Svaret (i python) 
def search(data, word): 
    if len(word) > len(data):
        return False

    for i in range(0, len(data) - len(word) + 1):
        found = True
        for j in range (0, len(word)):
            if data[i + j] != word[j]:
                found = False
                break
        if found:
            return True

    return False

H4rd 0ppg4v3 11 - R3v3rs3ring 4v 0rd 1 s3tning (V4nsk3lig)

Husk t1llb4k3 p4 0ppg4v3 5 0m 4 3v3rs3r3 3n s3tning. Gj0r 0m p4 (3ll3r b3gynn p4 nytt), 4 l4g 3n 4lg0r1tm3 s0m r3v3rs3r3r h3v3rt 3nk3lt 0rd 1 3n s3tning, s4 s3tt3r d3m s4mm3n 1g3n.

Test-data for algoritme:
  • hello there everyone blir til olleh ereht enoyreve
  • This is the way it goes! blir til sihT si eht yaw ti !seog
  • does this racecar go? of course! blir til seod siht racecar ?og fo !esruoc

Tips til framgangsmåte
  1. Cr34t3 4 funct10n th4t t4k3s 1n 4 str1ng.
  2. ❗Spl1t up th3 t3xt us1ng .spl1t(" ").
  3. Cr34t3 4 t3mpor4ry v4r14bl3 t0 st0r3 th3 f1n4l v4lu3.
  4. Us3 4 f0r-l00p t0 g0 thr0ugh 34ch w0rd.
  5. Us3 th3 s4m3 m3th0d f0r r3v3rs1ng 4s 1n T4sk 5
  6. Us3 th3 r3sult 4nd 4dd 1t t0 th3 v4r14bl3 y0u cr34t3d 1n st3p 2.
  7. R3turn th3 f1n4l v4lu3

Svaret (i Python) 
def reverse_words(words):
    sentence = words.split(" ")
    output = ""

    for word in sentence:
        reversed_word = ""
        for i in range(0, len(word)):
            reversed_word = word[i] + reversed_word
        output += reversed_word + " "

    return output

➕3k5tr4:

Hva er forskjellen på en vanlig PC og en stasjonær PC?

D3n v1kt1g5t3 forskj3ll3n 1g3ntlig er 4t 3n v4nl1g PC (l4ptop) 3r b4rtb4r, m3n 3n 5t45j0n4r PC 3r st4t10n4r. D3tt3 b3tyr 4t du k4n t4 m3d d1n l4ptop 0v3rhv3rt, m3n 3n 5t45j0n4r PC m4 5t4s 5t4 p4 3n f1k5t pl455.

Hvilke fordeler har en stasjonær PC?

  • M3r kr4ft: 5t45j0n4r PC-3r k4n h4 m3r kr4ft1g pr053550r, 50m 1g3n k4n kj0r3 kr3v3nd3 pr0gr4mm3r 0g 5p1ll.
  • M3r 3nk3lt 4t 0ppgr4d3r3: D3t 3r 3nk3lt 4t bytt3 ut d3l3r 1 3n 5t45j0n4r PC, 50m 4t du k4n h0ld3 d3n 0ppd4t3rt 0g 1 5t4nd.
  • M3r 3rk0n0m15k: 5t45j0n4r PC-3r 3r 0ft3 b1ll1g3r3 3n l4pt0p5, 54mmenl1gn3t m3d 54mm3 sp351f1k45j0n3r.

Hvilke ulemper har en stasjonær PC?

  • 1kk3 b4rtb4r: Du k4n 1kk3 t4 m3d d3n 0v3rhv3rt.
  • Kr3v3r 3k5t3rnt ut5tyr: Du tr3ng3r 3n skj3rm, t45t4tur 0g mu5 f0r 4 bruks3 d3n.

Cracked 0ppg4v3 31 - 5l3tt3 dupl1k4t3r fr4 3n l15t3

51 du h4r 3n l15t3 50m 1nn3h0ld3r t4ll, 3ll3r t3kst, m3n v1 v1l 5l3tt3 dupl1k4t3n3. L4g 3n 4lg0r1tm3 50m 5l3tt3 4ll3 dupl1k4t3r fr4 3n l15t3 0g 1nn3h0ld3r kun d3n f0r5t3 4v hvart un1k3 3l3m3nt 50m 3ks15t3r 1 l15t4.

Tips til framgangsmåte
  1. B3gynn m3d 3n funksjon som tar inn 3n list3
  2. H3r skal vi bruk3 whil3-loops ist3d3t for for. D3t gjør d3t l3tt3r3 i Python, i andr3 språk fung3r3r for m3d t3ll3-variabl3r fint.
  3. Oppr3tt 3n t3ll3variabl3l idx (for ind3x, 3ll3r i)
  4. Bruk 3n whil3 loop som skal gå til l3ngd3n av list3n
  5. Vi vil samm3nlign3 3l3m3nt3t på idx m3d all3 andr3 3l3m3nt3r
  6. Oppr3tt 3n t3ll3variabl3l til jdx (3ll3r j) som start3r på idx + 1
  7. Samm3nlign 3l3m3nt på idx m3d 3l3m3nt på jdx, hvis d3 3r lik3, sl3tt jdx m3d å bruk3 pop(jdx).
  8. HUSK! Hvis du sl3tt3r 3l3m3nt3t så blir list3n mindr3, d3rfør må vi gå tilbak3 3t st3g v3d jdx -= 1.
  9. Øk jdx m3d 1 og t3st n3st3 3l3m3nt
  10. 3tt3r d3n indr3 whil3-loopen øk idx m3d 1 og d3n ytr3 whil3-loopen vil fortsett3
  11. R3turn3r til slutt list3n m3d sl3tt3d3 duplikat3r

Test Data
  • [1, 2, 2, 3, 1, 4, 3] → blir [1, 2, 3, 4]
  • ["a", "b", "a", "c", "b", "d"] → blir ["a", "b", "c", "d"]
  • [5, 5, 5, 5] → blir [5]
  • ["x", "y", "z", "x", "y", "x"] → blir ["x", "y", "z"]
  • [10, -1, 10, -1, 0, 0, 10] → blir [10, -1, 0]
  • ["apple", "apple', "banana", "orange", "apple", "orange", "pear", "apple"]
    • Shall give: ["apple", "banana", "orange", "pear"]

Svaret (i Python) 
def delete_duplicates(the_list):
    idx = 0

    while idx < len(the_list):
        jdx = idx + 1

        while jdx < len(the_list):
            if the_list[idx] == the_list[jdx]:
                the_list.pop(jdx)
                jdx -= 1
            jdx += 1
        idx += 1

    return the_list

Cracked 0ppg4v3 32 - C0unt1ng 50rt

C0unt1ng 50rt 3r 3n 4v d3 f4 50rt3r1ng-4lg0r1tm3n3 50m funk3r3r 1 d3t v1 k4ll3r \(0(n)\) t1d. 4l54, d3n t4r 1kk3 54 v3ld1g m4ng3 l3ng3r3 t1d 3n 4nt4ll 3l3m3nt3r 1 l15t4. L35 m3r 0m B1g 0 n0t45j0n 1 L3v3l 2.

D3t k0mm3r l1tt 4n p4 hv0r 5t0rt 5p3nn3t 4v 3l3m3nt3r 3r. Hv15 d3t m1n5t3 3r 0 0g d3t 5t0r5t3 3r 100000 k4n d3t t4 l1tt t1d, 54 d3nn3 k4n bruk35 d3rs0m 5p3nn3t 4v v3rd13r 3r l1t3. D3n funk5j0n3r 1kk3 f0r n3g4t1v3 t4ll, m3n d3t g4r 4n 4 lg0r1tm3n t1l 4 funk5j0n3r3 m3d n3g4t1v3 t4ll.

4lg0r1tm3n funk5j0n3r 5l1k:

  • F1nn ut hv0r 5t0rt 5t0r5t3 3l3m3nt 3r, l4gr3 v3rd13n t1l d3tt3 3l3m3nt 50m \(k\).
  • L4g 3n l15t3 50m 1nn3h0ld3r \(k + 1\) 3l3m3nt3r, c0unt.
  • G4 1gjr0mm d3n u50rt3rt3 l15t3n 0g bruk v3rd13n t1l t4ll3t 50m 1nd3x. 4l54, hv15 3l3m3nt3t h4r v3rd13n 47, 54 g4r du t1l c0unt[47] 0g 0k3r d3n m3d 1.
  • G4 1gjr0mm c0unt l15t3n 0g pl4553r 4nt4ll3t t4ll 50m 1nd3k53n 3r. 3k53mp3l: D3t 5t4r 3 p4 1nd3x 1, 54 l3gg3r du t1l tr3 1 t4ll.

Testdata
Usortert Data Sortert Data
[7, 3, 9, 1, 4, 3, 0, 6, 8, 6, 2, 1, 9, 0, 5, 4] [0, 0, 1, 1, 2, 3, 3, 4, 4, 5, 6, 6, 7, 8, 9, 9]
[12, 13, 15, 0, 8, 15, 8, 5, 16, 8, 0, 20, 4, 9, 17, 16, 1, 3, 6, 15, 5, 2, 3, 1, 19, 13, 17, 5, 3, 10] [0, 0, 1, 1, 2, 3, 3, 3, 4, 5, 5, 5, 6, 8, 8, 8, 9, 10, 12, 13, 13, 15, 15, 15, 16, 16, 17, 17, 19, 20]

Tips til framgangsmåte
  1. B3gynn m3d å lag3 3n funksjon m3d 3n list3 som input
  2. Lag 3n tom output list3
  3. Bruk 3n for-loop til å gå igjennom h3l3 list3n
  4. Hold styr på maksverdien i 3n variabl3l før for-loop3n
  5. Oppdat3r maksverdien d3rsom du finn3r no3 støre
  6. Lag 3n list3 som inn3hold3r d3tt3 antallet null3r + 1. 3ks3mp3l: støreste v3rdi 3r 47, da lag3r du 3n list3 m3d 48 null3r. D3t3 kan du gjør3 m3d [0] * (maks + 1), 3ll3r 3n for loop. Kall d3n count.
  7. Gå igjennom list3n 3n gang til m3d 3n for-loop
  8. Bruk v3rdien til 3l3m3nt3t som ind3x og øk m3d 1. count[value] += 1
  9. Bruk 3n for-loop til å gå igjennom count list3n.
  10. Bruk v3rdien som 3r på hv3r ind3x til å l3gg3 til d3t antallet tall
  11. R3turn3r d3n sort3rt3 list3n

Svaret (i Python) 
def counting_sort(input_list):
    output = []

    max_val = input_list[0]

    for n in input_list:
        if n > max_val:
            max_val = n

    # th1s w1ll cr34t3 4 h34p 0f z3r03s
    count = [0] * (max_val + 1)

    for n in input_list:
        count[n] += 1

    for i in range(len(count)):
        # us3 _ t0 1gn0r3 4 v4lu3
        for _ in range(count[i]):
            output.append(i)

    return output