вопрос по циклам в python

Question

Я хочу вычислить пифагорейские триплеты (код ниже), и я хочу вычислять бесконечно, как мне это сделать, не используя три цикла for? Могу ли я использовать цикл for каким-либо образом? спасибо.

import math

def main():
    for x in range (10000, 1000):
        for y in range (10000, 1000):
            for z in range(10000, 1000):
                if x*x == y*y + z*z:
                    print y, z, x
                    print '-'*50

if __name__ == '__main__':
    main()  

Answer 1

Как правило, вы не можете. Три переменные, три цикла.

Но это особый случай, так как никто не указал. Вы можете решить эту проблему с помощью двух циклов.

Также нет смысла проверять y, z и z, y.

Ох и range(10000, 1000) = [].

import math

for x in range(1, 1000):
  for y in range(x, 1000):
      z = math.sqrt(x**2 + y**2)
      if int(z) == z:
        print x, y, int(z)
        print '-'*50

Answer 2

Вы можете расположить свой код в одном главном цикле следующим образом:

MIN = 10000
MAX = 10010
a = [MIN, MIN, MIN]
while True:
    print a
    for i in range(len(a)):
        a[i] = a[i] + 1
        if a[i] < MAX:
            break
        a[i] = MIN
        i += 1
    else:
        break

Вместо print a вы можете провести там трифлетный тест Пифагора. Это будет работать для произвольного числа измерений.

Если вы действительно хотите делать это бесконечно, вам придется использовать другую технику итерации, такую ​​как диагонализация .

Answer 3

Вам понадобятся только два цикла - просто проверьте, является ли math.sqrt(x*x+y*y) целым числом. Если это так, вы обнаружили пифагорейскую тройку.

Я новичок в Python, поэтому я не знаю, что делает range(10000, 1000) - где он начинается и заканчивается? Я спрашиваю, потому что вы можете вдвое сократить время выполнения, установив диапазон для y, начинающийся с x, а не исправляя его, поскольку добавление является коммутативным.

edit: Этот ответ - это то, что я получил, и то, что я написал бы, если бы знал больше Python.

Answer 4

Вот эффективная версия с использованием итераторов, которая генерирует все такие тройки, с целью. Хитрость заключается в том, чтобы перебирать наборы пар (x, y) эта сумма в N, для всех N.

import math
import itertools

def all_int_pairs():
    "generate all pairs of positive integers"
    for n in itertools.count(1):
        for x in xrange(1,n/2+1):
            yield x,n-x

for x,y in all_int_pairs():
    z = math.sqrt(x**2 + y**2)
    if int(z) == z:
        print x, y, int(z)
        print '-'*50

Answer 5

Использование xrange вместо range должно использовать меньше памяти, особенно если вы хотите попробовать большие диапазоны.

Answer 6

Используя тот же алгоритм (см. Другие ответы для лучших подходов), вы можете использовать itertools.count, чтобы получить цикл, который выполняется вечно.

import itertools

for x in itertools.count(1):
    for y in xrange(1, x):
         for z in xrange(1, y):
              if x*x == y*y + z*z:
                  print x, y, z

Answer 7

Это то же самое, что и ответ Can Berk Guder, но сделано в качестве генератора, просто для удовольствия. Это не очень полезно с вложенными циклами здесь, но часто может быть более чистым решением. Ваша функция дает результаты; позже вы беспокоитесь о том, сколько нужно извлечь.

import math

def triplets(limit):
    for x in range(1, limit):
        for y in range(x, limit):
            z = math.sqrt(x**2 + y**2)
            if int(z) == z:
                yield x, y, int(z)

for x, y, z in triplets(10):
    print x, y, z
    print "-" * 50

Answer 8

Не самый эффективный (Python создаст массив с миллиардом кортежей), но это один цикл:

for x, y, z in [(x, y, z) for x in range(10000, 11000) for y in range(10000, 11000) for z in range(10000, 11000)]:
    if x*x == y*y + z*z:
        print y, z, x
        print '-'*50

Или, как предлагает Кристиан Виттс ,

for x, y, z in ((x, y, z) for x in xrange(10000, 11000) for y in xrange(10000, 11000) for z in xrange(10000, 11000)):
    if x*x == y*y + z*z:
        print y, z, x
        print '-'*50

(при условии, что Python> = 2.4) использует генераторы вместо построения массива с миллиардами кортежей.

В любом случае, вы не должны так кодировать ... Ваш исходный код с вложенными циклами более понятен.

Answer 9

Как насчет использования itertools.product?

# range is [10000, 1000)
for x, y, z in itertools.product(range(10000, 1000, -1), repeat=3): 
    if x * x == y * y + z * z:
        print(y, z, x)

с битом мусора оптимизировать:

for x, y, z in itertools.product(range(10000, 1000, -1), repeat=3):
    if y >= x or z >= x or x >= (y + z) or z < y:
        continue
    if x * x == y * y + z * z:
        print(y, z, x)

РЕДАКТИРОВАТЬ: Здесь я просто даю способ использовать product вместо нескольких для цикла. И вы можете найти более эффективный метод в вышеупомянутых сообщениях.

Answer 10

Как минимум три петли необходимы для бесконечности. Чтобы сделать что-то гибкое, нужно множество петель. Этот пример является решением Project Euler Problem 9 и более.

#!/usr/bin/env python

def fcount(start=1):
    n = float(start)
    while True:
        yield n
        n += 1

def find_triples():
    for c in fcount():
        for b in fcount():
            if b > c:
                break
            for a in fcount():
                if a > b:
                    break
                if a ** 2 + b ** 2 == c ** 2:
                    yield (a, b, c)

def triples_by_sum(targetsum):
    for a, b, c in find_triples():
        if a + b + c == targetsum:
            yield a, b, c
        if c > targetsum:
            break

if __name__ == '__main__':
    # Finds multiple triples
    for a, b, c in triples_by_sum(252):
        print a, b, c
    # Finds single triples
    a, b, c = triples_by_sum(1000).next()
    print a, b, c
    # Goes forever
    for a, b, c in find_triples():
        print a, b, c