Dzielne liczb naturalnych

Mam prośbę o pomoc w rozwiązaniu następującego problemu - zadania:
Napisz program, który wypisze 10 najmniejszych liczb, które są podzielne przez liczby 1...9 (wszystkie liczby naturalne jednocześnie).
Czy dałoby się to rozwiązać z użyciem jedynie pętli for (bez while)?

Dało by się, pokaż co Masz, gdzie szukałeś rozwiązania.

take 10 [num | num <- [1..],
                       all (\k -> num `mod` k == 0) [1..9]]

:)

Pokaz co tam juz napisales

Dałoby się, wystarczy że znajdziesz najmniejszą wspólną wielokrotność (NWW) dla liczb 1...9 i będziesz mieć pierwszą z nich, dalej powinno już być z górki - kolejne liczby powinny być kolejnymi wielokrotnościami NWW.

Dla przykładu - biorąc tylko 1...4 mamy NWW(1,2,3,4) = 12 (możesz sprawdzić), kolejną taką liczbą będzie 24, 36, 48... itd

@lion137: Wykombinowałem coś na podstawie NWW (od 1 do 9), ale to raczej słabe rozwiązanie.

``` def wiel(a, b):
   ``` nww = a * b
   ``` while a != b:
     ```  if a > b:
  ```          a = a - b
```        else:
```            b = b - a
```    nww = nww // a
```    return nww
```def najw():
```    a = 1
```    pom = 0
```    for i in range (2,10):
```        b = i
  ```      a = wiel (a, b)
```    return a

```liczba = najw()
```for i in range (1,11):
```    liczba = liczba * i
```    print(liczba, end =" ")''

@stivens:

def wiel(a, b):
    nww = a * b
    while a != b:
        if a > b:
            a = a - b
        else:
            b = b - a
    nww = nww // a
    return nww
def najw():
    a = 1
    pom = 0
    for i in range (2,10):
        b = i
        a = wiel (a, b)
    return a

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

I jak ten kod, daje radę? Testowałeś?

@superdurszlak: Dzięki za sugestie - udało się, program przeszedł wszystkie testy:

def wiel(a, b):
    nww = a * b
    while a != b:
        if a > b:
            a = a - b
        else:
            b = b - a
    nww = nww // a
    return nww
def najw():
    a = 1
    pom = 0
    for i in range (2,10):
        b = i
        a = wiel (a, b)
    return a

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

@lion137: Program przeszedł wszystkie testy poprawności w takiej formie:

def wiel(a, b):
    nww = a * b
    while a != b:
        if a > b:
            a = a - b
        else:
            b = b - a
    nww = nww // a
    return nww
def najw():
    a = 1
    pom = 0
    for i in range (2,10):
        b = i
        a = wiel (a, b)
    return a

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

Wiem, że nie jest to szczyt perfekcji, ale zadziałało - teraz można zastanowić się nad jego optymalizacją :-)

Masz krócej:

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

@Spine: jak już się zna NWW 1...9 :-), ale tutaj chodziło o dojście do tego bez jego znajomości

Toporny jak i zadanie

def NWW():
    tab = [x for x in range(2, 10)]
    maks = 1
    for liczba in tab:
        maks *= liczba
    maks += 1
    for liczba in range(1, maks):
        czujka = True
        for dzielnik in tab:
            if liczba % dzielnik != 0:
                czujka = False
                break
        if czujka is True:
            return liczba
print(NWW())

edit: trochę szybszy

import sys

def NWW():
   tab = [x for x in range(2, 9)]
   for liczba in range(9,sys.maxsize,9):
       czujka = True
       for dzielnik in tab:
           if liczba % dzielnik != 0:
               czujka = False
               break
       if czujka is True:
           return liczba
print(NWW())

>>> from itertools import accumulate
>>> from functools import reduce
>>> from math import lcm
>>> 
>>> reduce(lcm, range(1, 10))
2520
>>> list(accumulate([_] * 10))
[2520, 5040, 7560, 10080, 12600, 15120, 17640, 20160, 22680, 25200]