Øvelser med løkker

Her følger en del ekstra, frivillige, øvelser for å bli kjent med løkker. Bruk dem som mengdetrening for å bli kjent med hvordan løkker fungerer.

Mange løsningsforslag viser for sammenligningens skyld både en løsning med while-løkke og en løsning med for-løkke; men husk på at hvis det kan løses med en for-løkke, så bør det løses med en for-løkke. While-løkker skal benyttes når vi ikke vet på forhånd hvor mange iterasjoner som behøves.

Skriv ut tallene fra 1 til 10

Forventet output:

1
2
3
4
5
6
7
8
9
10


i = 1
while i <= 10:
    print(i)
    i += 1


for i in range(1, 11):
    print(i)

Skriv ut tallene fra 1 til 10 på samme linje

Forventet output:

1 2 3 4 5 6 7 8 9 10


i = 1
while i <= 10:
    print(i, end=" ")
    i += 1
print()


for i in range(1, 11):
    print(i, end=" ")
print()

Regn ut summen av tallene mellom 50 og 200

Forventet output:

18875


i = 50
total = 0
while i <= 200:
    total += i
    i += 1
print(total)


total = 0
for i in range(50, 201):
    total += i
print(total)

Skriv ut gangetabellen for 7

Forventet output:

7 14 21 28 35 42 49 56 63 70


i = 1
while i <= 10:
    print(i * 7, end=" ")
    i += 1
print()


for i in range(1, 11):
    print(i * 7, end=" ")
print()

Skriv ut alle tallene mellom 60 og 50 i synkende rekkefølge

Forventet output:

60 59 58 57 56 55 54 53 52 51 50


i = 60
while i >= 50:
    print(i, end=" ")
    i -= 1
print()


for i in range(60, 49, -1):
    print(i, end=" ")
print()

Skriv ut alle a’ene i en streng

Gitt en streng s, skriv ut alle a’er i strengen på samme linje

Forventet output hvis strengen er "abbaccdbaabccda":

aaaaa

  • Benytt en for-løkke som går igjennom alle bokstavene i strengen.

  • For hver bokstav c i strengen, sjekk om c er en a. Hvis det er det, skriv ut c.

s = "abbaccdbaabccda"
for c in s:
    if c == "a":
        print(c, end="")
print()

Tell hvor mange a’er det er i en streng

Gitt en streng s, tell hvor mange a’er det er i strengen

Forventet output hvis strengen er "abbaccdbaabccda":

5

  • Initialiser en variabel count til 0.

  • Benytt en for-løkke som går igjennom alle bokstavene i strengen.

  • For hver bokstav c i strengen, sjekk om c er en a. Hvis det er det, øk en variabel count med 1.

  • Når løkken er ferdig: skriv ut count.

s = "abbaccdbaabccda"
count = 0
for c in s:
    if c == "a":
        count += 1
print(count)

Skriv ut alle a’er og b’er i en streng

Gitt en streng s, skriv ut alle a’er og b’er i strengen på samme linje, men ignorer alle andre bokstaver

Forventet output hvis strengen er "abbaccdbaabccda":

abbabaaba

  • Benytt en for-løkke som går igjennom alle bokstavene i strengen.

  • For hver bokstav c i strengen, sjekk om c er en a eller b. Hvis det er det, skriv ut c.

s = "abbaccdbaabccda"
for c in s:
    if c == "a" or c == "b":
        print(c, end="")
print()


s = "abbaccdbaabccda"
for c in s:
    if c in "ab":
        print(c, end="")
print()


s = "abbaccdbaabccda"
result = ""
for c in s:
    if c in "ab":
        result = result + c
print(result)

Sjekk om en 0’ere og 1’ere kommer annenhver gang

Gitt en streng som består av 0’ere, 1’ere og muligens andre symboler, sjekk om 0’ere og 1’ere kommer annenhver gang, og at den første 0’eren kommer før den første 1’eren. Symboler som ikke er 0 eller 1 skal ignoreres. Skriv ut True hvis strengen er en 0-1-0-1-0-1-…-sekvens, og False ellers.

Forventet output hvis strengen er "0101901091010910101":

True

Forventet output hvis strengen er "0110901091010910101":

False

  • Opprett en variabel expected som holder styr på hvilket symbol av "0" og "1" som forventes å komme neste gang. Initialiser den til "0".

  • Opprett en variabel is_ok som holder styr på om en feil er funnet. Initialiser den til True.

  • Benytt en for-løkke som går igjennom alle bokstavene i strengen.

  • Hvis symbolet er "0" og expected er "0", sett expected til "1".

  • Hvis symbolet er "1" og expected er "1", sett expected til "0".

  • Hvis symbolet er "0" og expected er "1", sett is_ok til False.

  • Hvis symbolet er "1" og expected er "0", sett is_ok til False.

  • Når løkken er ferdig: skriv ut is_ok.

s = "0101901091010910101"
expected = "0"
is_ok = True
for c in s:
    if c == "0" and expected == "0":
        expected = "1"
    elif c == "1" and expected == "1":
        expected = "0"
    elif c == "0" and expected == "1":
        is_ok = False
    elif c == "1" and expected == "0":
        is_ok = False

print(is_ok)


s = "0101901091010910101"
previous_match = "1"
is_ok = True
for c in s:
    if c not in "01":
        continue
    if c == previous_match:
        is_ok = False
        break
    previous_match = c
print(is_ok)

Skriv ut alle tallene under 100 som er delelig med 17

Forventet output:

17 34 51 68 85


i = 17
while i < 100:
    print(i, end=" ")
    i += 17
print()


for i in range(17, 100, 17):
    print(i, end=" ")
print()

Skriv ut alle tallene under 20 som er delelig med 3 eller 5

  • Benytt en løkke som går igjennom alle mulige tall fra 1 til 20.

  • Et tall x er delelig med et annet tall y hvis restverdien etter heltallsdivisjon er null; med andre ord, hvis x % y == 0. Les mer om modulo-operatoren i kursnotater om operatorer.

Forventet output:

3 5 6 9 10 12 15 18


i = 1
while i < 20:
    if (i % 3 == 0) or (i % 5 == 0):
        print(i, end=" ")
    i += 1
print()


for i in range(1, 20):
    if (i % 3 == 0) or (i % 5 == 0):
        print(i, end=" ")
print()

Tell opp hvor mange tall under 20 som er delelig med 3 eller 5

  • Benytt en løkke som går igjennom alle mulige tall fra 1 til 19.

  • Et tall x er delelig med et annet tall y hvis restverdien etter heltallsdivisjon er null; med andre ord, hvis x % y == 0. Les mer om modulo-operatoren i kursnotater om operatorer.

Forventet output:

8


i = 1
count = 0
while i < 20:
    if (i % 3 == 0) or (i % 5 == 0):
        count += 1
    i += 1
print(count)


count = 0
for i in range(1, 20):
    if (i % 3 == 0) or (i % 5 == 0):
        count += 1
print(count)

FizzBuzz

Skriv ut tallene fra 1 til 20. For hvert tall som er delelig med 3, skriv ut «Fizz» istedenfor tallet. For hvert tall som er delelig med 5, skriv ut «Buzz» istedenfor tallet. For hvert tall som er delelig med både 3 og 5, skriv ut «FizzBuzz» istedenfor tallet.

  • Benytt en løkke som går igjennom alle mulige tall fra 1 til 20.

  • Et tall x er delelig med et annet tall y hvis restverdien etter heltallsdivisjon er null; med andre ord, hvis x % y == 0. Les mer om modulo-operatoren i kursnotater om operatorer.

Forventet output:

1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz 19 Buzz


i = 1
while i <= 20:
    if i % 3 == 0 and i % 5 == 0:
        print("FizzBuzz", end=" ")
    elif i % 3 == 0:
        print("Fizz", end=" ")
    elif i % 5 == 0:
        print("Buzz", end=" ")
    else:
        print(i, end=" ")
    i += 1
print()


for i in range(1, 21):
    if i % 3 == 0 and i % 5 == 0:
        print("FizzBuzz", end=" ")
    elif i % 3 == 0:
        print("Fizz", end=" ")
    elif i % 5 == 0:
        print("Buzz", end=" ")
    else:
        print(i, end=" ")
print()

Regn ut 100!

Faktorialen av et tall n er produktet av alle heltall fra 1 til n. Faktorialen av 5 er 1 * 2 * 3 * 4 * 5 = 120. Faktorialen av 100 er et veldig stort tall. Regn ut faktorialen av 100 ved å bruke en løkke.

  • Benytt en løkke som går igjennom alle mulige tall fra 1 til 100.

  • For hvert tall i i løkken, multipliser i med en variabel total som du initialiserer til 1.

Forventet output:

93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000


i = 1
total = 1
while i <= 100:
    total *= i
    i += 1
print(total)


total = 1
for i in range(1, 101):
    total *= i
print(total)

Finn den største faktoren

Gitt et positivt heltall n som er større enn 1, finn den største positive heltallet mindre enn n som er en faktor i n.

PS: hvis svaret blir 1, betyr det at tallet et primtall.

Forventet output hvis n er 12:

6

  • Ha en variabel max_factor som du initialiserer til 1.

  • Benytt en for-løkke som går igjennom alle mulige tall fra 1 til n - 1.

  • For hvert tall i i løkken, sjekk om i er en faktor i n (du kan benytte modulo-operatoren til dette, se kursnotater om operatorer). Hvis det er det, sett max_factor til i.

  • Når løkken er ferdig, skriv ut max_factor.

n = 12

max_factor = 1
i = 1
while i < n:
    if n % i == 0:
        max_factor = i
    i += 1
print(max_factor)


n = 12

max_factor = 1
for i in range(1, n):
    if n % i == 0:
        max_factor = i
print(max_factor)

Skriv ut en trekant

Skriv ut en trekant med 8 rader. Den første raden skal ha 1 stjerne, den andre raden skal ha 2 stjerner, den tredje raden skal ha 3 stjerner, osv.

Forventet output:

*
**
***
****
*****
******
*******
********

  • Benytt en løkke som går igjennom alle mulige tall fra 1 til 8.

  • For hvert tall i i løkken, skriv ut i stjerner.

i = 1
while i <= 8:
    print("*" * i)
    i += 1


for i in range(1, 9):
    print("*" * i)

Skriv ut en trekant opp ned

Skriv ut en trekant med 8 rader. Den første raden skal ha 8 stjerner, den andre raden skal ha 7 stjerner, den tredje raden skal ha 6 stjerner, osv.

Forventet output:

********
*******
******
*****
****
***
**
*

  • Benytt en løkke som går igjennom alle mulige tall fra 8 til 1.

  • For hvert tall i i løkken, skriv ut i stjerner.

i = 8
while i >= 1:
    print("*" * i)
    i -= 1


for i in range(8, 0, -1):
    print("*" * i)

Skriv ut en pyramide

Skriv ut en pyramide med n etasjer. Hvis n er 5, skal pyramiden se slik ut:

    *
   ***
  *****
 *******
*********

  • Benytt en løkke som går igjennom alle mulige tall fra 1 til n.

  • For hvert tall i i løkken, skriv ut n - i mellomrom, og 2 * i - 1 stjerner.

n = 5
i = 1
while i <= n:
    print(" " * (n - i), end="")
    print("*" * (2 * i - 1))
    i += 1


n = 5
for i in range(1, n + 1):
    print(" " * (n - i), end="")
    print("*" * (2 * i - 1))

Skriv ut en sidestilt pyramide

Skriv ut en pyramide med n etasjer, men rotert sidelengs. Hvis n er 4, skal pyramiden se slik ut:

*
**
***
****
***
**
*

  • Benytt en løkke som går igjennom alle mulige tall fra 1 til n.

  • For hvert tall i i løkken, skriv ut i stjerner.

  • Benytt en ny løkke som går igjennom alle mulige tall fra n - 1 til 1.

  • For hvert tall i i den nye løkken, skriv ut i stjerner.

n = 4
i = 1
while i <= n:
    print("*" * i)
    i += 1
i = n - 1
while i >= 1:
    print("*" * i)
    i -= 1


n = 4
for i in range(1, n + 1):
    print("*" * i)
for i in range(n - 1, 0, -1):
    print("*" * i)

Finn ut hvor mange ganger 1962 kan deles på 7

Benytt en løkke for å finne ut hvor mange ganger 1962 kan deles på 7 før resultatet er mindre enn 1.

Forventet output:

4

  • Ha en variabel count som du initialiserer til 0.

  • Ha en variabel x som du initialiserer til 1962.

  • Så lenge x er større enn eller lik 0, øk count med 1 og del x på 7.

  • Når løkken er ferdig, skriv ut count.

count = 0
x = 1962
while x >= 1:
    count += 1
    x /= 7
print(count)

Fordi vi ikke vet hvor mange ganger vi må dele på 7, kan vi ikke bruke en for-løkke. Vi må bruke en while-løkke.

Finn antall siffer i et tall

Skriv ut hvor mange siffer det er i et tall. For eksempel har tallet 1234 fire siffer.

Forventet output hvis n er 2**1000:

302

  • Ha en variabel count som du initialiserer til 0.

  • Ha en variabel x som du initialiserer til n.

  • Så lenge x er større enn 0, øk count med 1 og del x på 10.

  • Når løkken er ferdig, skriv ut count.

n = 2 ** 1000

count = 0
x = n
while x > 0:
    count += 1
    x //= 10
print(count)

Fordi vi ikke vet hvor mange ganger vi må dele på 10, kan vi ikke bruke en for-løkke. Vi må bruke en while-løkke.

Det finnes imidlertid en «hack» hvor vi først konverterer tallet til en streng (under panseret benyttes det nok en while-løkke under denne prosessen, men det er ikke noe vi trenger å bry oss om). Der benytter ikke vi en løkke i det hele tatt.

n = 2 ** 1000
print(len(str(abs(n))))

Tell hvor mange 1’ere det er i et tall

Gitt et tall n, skriv ut hvor mange 1’ere det er i et tall. For eksempel har tallet 11121 fire 1’ere.

Forventet output hvis n er 11121:

Det er 4 enere i 11121

  • Ha en variabel count som du initialiserer til 0.

  • Ha en variabel x som du initialiserer til abs(n).

  • Så lenge x er større enn 0:

    • Finn ut hva siste siffer er ved bruk av modulo (x % 10). Hvis dette sifferet er 1, øk count med 1.
    • Del x på 10 med heltallsdivisjon (//) for å fjerne dette siste siffer fra tallet.

  • Når løkken er ferdig, skriv ut count.

n = 11121
x = abs(n)
count = 0
while x > 0:
    if x % 10 == 1:
        count += 1
    x //= 10
print("Det er", count, "enere i", n)

Fordi vi ikke vet hvor mange ganger vi må dele på 10, kan vi ikke bruke en for-løkke. Vi må bruke en while-løkke.

Det finnes imidlertid en «hack» hvor vi først konverterer tallet til en streng (under panseret benyttes det nok en while-løkke under denne prosessen, men det er ikke noe vi trenger å bry oss om):

n = 11121
count = 0
for c in str(n):
    if c == "1":
        count += 1
print("Det er", count, "enere i", n)

Finn laveste positive heltall n slik at n**2 er større enn 1000

Forventet output:

32


n = 1
while n ** 2 <= 1000:
    n += 1
print(n)

Fordi vi ikke vet hvor mange ganger vi må øke n, kan vi ikke bruke en for-løkke. Vi må bruke en while-løkke.

Finn det største heltallet n slik at n**3 er mindre enn 10000

Foventet output:

21


n = 1
while n ** 3 < 10000:
    n += 1
print(n - 1)

Fordi vi ikke vet hvor mange ganger vi må øke n, kan vi ikke bruke en for-løkke. Vi må bruke en while-løkke.

Skriv ut de 10 første FizzOrBuzz-tallene

Et tall er et FizzOrBuzz -tall dersom det er delelig med enten 3 eller 5 (eller begge). Skriv ut de 10 første FizzOrBuzz-tallene.

Forventet output:

3 5 6 9 10 12 15 18 20 21

  • Løs FizzBuzz -oppgaven over først.

  • Definer en variabel count som holder styr på hvor mange FizzOrBuzz-tall du har funnet. Initialiser den til 0.

  • Definer en variabel i som holder styr på hvilket tall du er kommet til. Initialiser den til 1.

  • Så lenge count er mindre enn 10, sjekk om i er delelig med 3 eller 5. Hvis det er det, skriv ut i og øk count med 1.

  • Øk i med 1.

count = 0
i = 1
while count < 10:
    if i % 3 == 0 or i % 5 == 0:
        print(i, end=" ")
        count += 1
    i += 1
print()

Fordi vi ikke vet hvor mange ganger løkken skal utføres på forhånd, kan vi ikke bruke en for-løkke. Vi må bruke en while-løkke.

Skriv ut det n’te FizzOrBuzz-tallet

Et tall er et FizzOrBuzz -tall dersom det er delelig med enten 3 eller 5 (eller begge). Det første FizzOrBuzz -tallet er 3, det andre er 5, det tredje er 6, det fjerde er 9, osv. Gitt et tall n, skriv ut det n’te FizzOrBuzz -tallet.

Forventet output hvis n er 10:

21

  • Løs FizzBuzz -oppgaven over først.

  • Definer en variabel count som holder styr på hvor mange FizzOrBuzz-tall du har funnet. Initialiser den til 0.

  • Definer en variabel i som holder styr på hvilket tall du er kommet til. Initialiser den til 1.

  • Så lenge count er mindre enn n, sjekk om i er delelig med 3 eller 5. Hvis det er det, øk count med 1.

  • Når løkken er ferdig, skriv ut i.

n = 10
count = 0
i = 1
while count < n:
    if i % 3 == 0 or i % 5 == 0:
        count += 1
    i += 1
print(i - 1) # -1 fordi løkken sluttet med i += 1


n = 10
count = 0
i = 1
while True:
    if i % 3 == 0 or i % 5 == 0:
        count += 1
    if count == n:
        break
    i += 1
print(i) # -1 fordi løkken sluttet med i += 1

Fordi vi ikke vet hvor mange ganger løkken skal utføres på forhånd, kan vi ikke bruke en for-løkke. Vi må bruke en while-løkke.

Skriv ut en trekant med økende tall

Skriv ut en trekant med 8 rader. Den første raden skal ha tallet 1, den andre raden skal ha tallene 1 og 2, den tredje raden skal ha tallene 1, 2 og 3, osv.

Forventet output:

1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
1 2 3 4 5 6 7
1 2 3 4 5 6 7 8

  • Benytt en løkke som går igjennom alle mulige tall fra 1 til 8.

  • For hvert tall i i løkken, skriv ut tallene fra 1 til i i en nøstet løkke

i = 1
while i <= 8:
    j = 1
    while j <= i:
        print(j, end=" ")
        j += 1
    print()
    i += 1


for i in range(1, 9):
    for j in range(1, i + 1):
        print(j, end=" ")
    print()

Skriv ut en trekant med FizzBuzz -sekvensen

Skriv ut en trekant med 20 rader. Den første raden skal ha tallet 1, den andre raden skal ha tallene 1 og 2, den tredje raden skal ha tallene 1, 2 og 3, osv. – men dersom tallet er delelig med 3, skal det skrives ut «Fizz» istedenfor tallet, og dersom tallet er delelig med 5, skal det skrives ut «Buzz» istedenfor tallet. Dersom tallet er delelig med både 3 og 5, skal det skrives ut «FizzBuzz» istedenfor tallet.

Forventet output:

1
1 2
1 2 Fizz
1 2 Fizz 4
1 2 Fizz 4 Buzz
1 2 Fizz 4 Buzz Fizz
1 2 Fizz 4 Buzz Fizz 7
1 2 Fizz 4 Buzz Fizz 7 8
1 2 Fizz 4 Buzz Fizz 7 8 Fizz
1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz
1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11
1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz
1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13
1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14
1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz
1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16
1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17
1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz
1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz 19
1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz 19 Buzz

  • Løs FizzBuzz -oppgaven over først.

  • Benytt en løkke som går igjennom alle mulige tall fra 1 til 20.

  • Benytt en nøstet løkke som går igjennom alle mulige tall fra 1 til i (der i er tallet i den ytre løkken).

  • For hvert tall j i den indre løkken, sjekk om j er delelig med 3 eller 5. Hvis det er det, skriv ut «Fizz», «Buzz» eller «FizzBuzz» istedenfor j.

i = 1
while i <= 20:
    j = 1
    while j <= i:
        if j % 3 == 0 and j % 5 == 0:
            print("FizzBuzz", end=" ")
        elif j % 3 == 0:
            print("Fizz", end=" ")
        elif j % 5 == 0:
            print("Buzz", end=" ")
        else:
            print(j, end=" ")
        j += 1
    print()
    i += 1


for i in range(1, 21):
    for j in range(1, i + 1):
        if j % 3 == 0 and j % 5 == 0:
            print("FizzBuzz", end=" ")
        elif j % 3 == 0:
            print("Fizz", end=" ")
        elif j % 5 == 0:
            print("Buzz", end=" ")
        else:
            print(j, end=" ")
    print()

Skriv ut gangetabellen

Skriv ut en tabell med gangetabellen fra 1 til 10. Den første raden skal ha 1-gangen, den andre raden skal ha 2-gangen, den tredje raden skal ha 3-gangen, osv.

Forventet output:

1 2 3 4 5 6 7 8 9 10 
2 4 6 8 10 12 14 16 18 20 
3 6 9 12 15 18 21 24 27 30 
4 8 12 16 20 24 28 32 36 40 
5 10 15 20 25 30 35 40 45 50 
6 12 18 24 30 36 42 48 54 60 
7 14 21 28 35 42 49 56 63 70 
8 16 24 32 40 48 56 64 72 80 
9 18 27 36 45 54 63 72 81 90 
10 20 30 40 50 60 70 80 90 100 


i = 1
while i <= 10:
    j = 1
    while j <= 10:
        print(i * j, end=" ")
        j += 1
    print()
    i += 1


for i in range(1, 11):
    for j in range(1, 11):
        print(i * j, end=" ")
    print()


for i in range(1, 11):
    j = 1
    while j <= 10:
        print(i * j, end=" ")
        j += 1
    print()


i = 1
while i <= 10:
    for j in range(1, 11):
        print(i * j, end=" ")
    print()
    i += 1

Skriv ut alle primtall under 100

Et primtall er et tall som bare er delelig med 1 og seg selv (største faktor mindre enn seg selv er 1). Skriv ut alle primtall under 100. (PS: per definisjon er 1 ikke et primtall).

Forventet output:

2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 57 59 61 67 71 73 79 83 89 97

  • Løs først oppgaven i noen avsnitt tidligere om å finne den største faktoren til et tall.

  • Benytt en løkke som går igjennom alle mulige tall fra 2 til 100.

  • For hvert tall i i løkken, sjekk om i er et primtall, ved å sjekke om den største faktoren i i er 1. Hvis den er det, skriv ut i.

i = 2
while i < 100:
    max_factor = 1
    j = 1
    while j < i:
        if i % j == 0:
            max_factor = j
        j += 1
    if max_factor == 1:
        print(i, end=" ")
    i += 1
print()

PS: det finnes mer langt mer effektive løsninger enn de vi har gitt her. I første omgang er det om å gjøre å forstå hvordan selve løkken fungerer, så vi har gått for en enklere algoritme enn den mest effektive.

for i in range(2, 100):
    max_factor = 1
    for j in range(1, i):
        if i % j == 0:
            max_factor = j
    if max_factor == 1:
        print(i, end=" ")
print()

PS: det finnes mer langt mer effektive løsninger enn de vi har gitt her. I første omgang er det om å gjøre å forstå hvordan selve løkken fungerer, så vi har gått for en enklere algoritme enn den mest effektive.

Skriv ut de 10 første primtallene over 100

Et primtall er et tall som bare er delelig med 1 og seg selv (største faktor mindre enn seg selv er 1). Skriv ut de 10 laveste primtallene over 100. (PS: per definisjon er 1 ikke et primtall).

Forventet output:

101 103 107 109 113 127 131 137 139 149

  • Løs først oppgaven i noen avsnitt tidligere om å finne den største faktoren til et tall.

  • Benytt en løkke som går igjennom alle mulige tall fra 101 og oppover.

  • For hvert tall i i løkken, sjekk om i er et primtall, ved å sjekke om den største faktoren i i er 1. Hvis den er det, skriv ut i.

  • Ha en variabel count som holder styr på hvor mange primtall du har funnet. Initialiser den til 0 før løkken starter.

  • Når du har funnet et primtall, øk count med 1.

  • Så lenge count er mindre enn 10, fortsett løkken.

count = 0
i = 101
while count < 10:
    max_factor = 1
    j = 1
    while j < i:
        if i % j == 0:
            max_factor = j
        j += 1
    if max_factor == 1:
        print(i, end=" ")
        count += 1
    i += 1
print()

PS: det finnes mer langt mer effektive løsninger enn de vi har gitt her. I første omgang er det om å gjøre å forstå hvordan selve løkken fungerer, så vi har gått for en enklere algoritme enn den mest effektive.

I forhold til WHILE-WHILE -løsningen er denne å foretrekke, siden vi vet på forhånd hvor mange ganger den innerste løkken (maksimalt) skal kjøres.

count = 0
i = 101
while count < 10:
    max_factor = 1
    for j in range(2, i):
        if i % j == 0:
            max_factor = j
    if max_factor == 1:
        print(i, end=" ")
        count += 1
    i += 1
print()

PS: det finnes mer langt mer effektive løsninger enn de vi har gitt her. I første omgang er det om å gjøre å forstå hvordan selve løkken fungerer, så vi har gått for en enklere algoritme enn den mest effektive.

Det finnes ingen løsning som kun benytter for-løkker, fordi vi ikke vet hvor mange tall vi trenger å sjekke før vi har funnet 10 primtall. Ett eller annet sted må det nesten være en while-løkke.

Fordi vi ikke vet hvor mange ganger løkken skal utføres på forhånd, kan vi ikke bruke en for-løkke. Vi må bruke en while-løkke.

  • Q: Men er det ikke mulig å ha en løkke som går 10 ganger, og hver gang finner den et nytt primtall større enn det forrige?
  • A: Joda. Det er mulig; men da må man eventuelt ha en while-løkke som leter etter neste primtall som er nøstet inni en for-løkke som går 10 ganger. Da blir det tre nivåer med nøsting, og koden blir mer komplisert enn while-løsningen. Men det er mulig å gjøre det på den måten også:
threshold = 100
for i in range(10):
    prime_found = False
    while not prime_found:
        threshold += 1
        max_factor = 1
        for factor in range(2, threshold):
            if threshold % factor == 0:
                max_factor = factor
        if max_factor == 1:
            print(threshold, end=" ")
            prime_found = True
print()

PS: det finnes mer langt mer effektive løsninger enn de vi har gitt her. I første omgang er det om å gjøre å forstå hvordan selve løkken fungerer, så vi har gått for en enklere algoritme enn den mest effektive.

Finn det n’te primtallet

Et primtall er et tall som bare er delelig med 1 og seg selv (største faktor mindre enn seg selv er 1). Det første primtallet er 2, det andre er 3, det tredje er 5, det fjerde er 7, osv. Gitt et tall n, skriv ut det n’te primtallet.

Forventet output hvis n er 10:

29

  • Løs først oppgaven over om å finne de 10 første primtallene over 100.

  • I stedet for å begynne søket på 100, begynn på 1.

  • Ha en variabel count som holder styr på hvor mange primtall du har funnet. Initialiser den til 0 før løkken starter.

  • Når du har funnet et primtall, øk count med 1.

  • Så lenge count er mindre enn n, fortsett løkken.

  • Når løkken er ferdig, skriv ut i.

n = 10
count = 0 # Number of primes found so far
candidate = 1 # Number to test (check if it is a prime)

while count < n:
    candidate += 1
    max_factor = 1
    for factor in range(2, candidate):
        if candidate % factor == 0:
            max_factor = factor
    if max_factor == 1:
        count += 1

print(candidate)

PS: Variabelen candidate initialiseres til 1 mindre enn den første kandidaten vi ønsker å teste (nemlig 2). Dette er fordi det første som skjer i løkken er at nummeret økes med 1.