В списке списков, как мне посчитать сумму равных сумм в моем списке?

Question

Я довольно новичок в Python и изо всех сил пытаюсь подсчитать мое количество равных сумм в моем списке списков. Я создаю список чисел (список один), согласно Гольдбаху каждое число равно трем основным числам. Теперь у меня есть список всех комбинаций простых чисел, теперь я хочу подсчитать количество комбинаций, которые есть у каждого числа в списке один, и распечатать его. Я попытался использовать "импорт коллекций", который не работал из-за того, что мой код не хэш. Затем я устал добавлять число в пустой список, который увеличивается до равных сумм, но я получаю сообщение об ошибке:

IndexError: индекс назначения списка вне диапазона

Вот мой код, с которым я борюсь:

lijst2 = []
lijst = []
for i in oneven:
    for a in priemgetallen:
        for b in priemgetallen:
            if a >= b:
                c = i - a - b
                if c in priemgetallen and b >= c:
                    lijst.append([c,b,a])
for item in lijst:
    if sum(item) in lijst2:
        lijst2[sum(item)] = lijst2.get(sum(item))+1
    else:
        lijst2[sum(item)] = 1

for k,v in lijst2.items():
    print(str(k)+':'+str(v))

lijst2 = set(lijst)
print(lijst2)

Если вам интересно то, что я пытаюсь сделать, я пытаюсь написать счетчик для теории Гольдбаха, так что вот весь мой Кодекс:

oneven = []
for i in range(7,102,2):
    oneven.append(i)

priemgetallen = [2]
counter = 3
while priemgetallen[-1] < oneven[-1]:
    priemgetallendelers = []
    for i in range (1,counter+1):
        if counter % i == 0:
            priemgetallendelers.append(i)
    if len(priemgetallendelers) == 2:
        priemgetallen.append(counter)
        counter += 1
    else:
        counter +=1

lijst2 = []
lijst = []
for i in oneven:
    for a in priemgetallen:
        for b in priemgetallen:
            if a >= b:
                c = i - a - b
                if c in priemgetallen and b >= c:
                    lijst.append([c,b,a])
for item in lijst:
    if sum(item) in lijst2:
        lijst2[sum(item)] = lijst2.get(sum(item))+1
    else:
        lijst2[sum(item)] = 1

for k,v in lijst2.items():
    print(str(k)+':'+str(v))

lijst2 = set(lijst)
print(lijst2)

В конце это должно выглядеть примерно так:

 7 =  2 +  2 +  3

 9 =  2 +  2 +  5
   =  3 +  3 +  3

11 =  2 +  2 +  7
   =  3 +  3 +  5

13 =  3 +  3 +  7
   =  3 +  5 +  5

Options to write: 7, 9, 11, ...:
1, 2, 2, 2, 3, 4, 3, 5, 5, 5, 7, 7, 6, 9, 8,

Answer 1

Есть несколько мест, где ваш код довольно неэффективен. Прежде всего, если вы знаете верхний предел простых чисел, которые вам нужны, то Sieve of Eratosthenes - гораздо более эффективный способ генерирования простых чисел:

def primes_sieve(limit):
    if limit < 2:
        return []
    res = [2]
    odd_cnt = ((limit + 1) / 2)
    odd_sieve = [True] * odd_cnt
    odd_sieve[0] = False  # 1 is not a prime
    for (i, isprime) in enumerate(odd_sieve):
        if isprime:
            prime = 2 * i + 1
            res.append(prime)
            for n in xrange(i * (prime + 1), odd_cnt, prime):  # Mark factors non-prime, we can safely start at prime^2
                odd_sieve[n] = False
    return res

Тогда ваши петли с внутренними проверками if a >= b: а также if c in priemgetallen and b >= c: очень неэффективны. Гораздо эффективнее перебирать простые числа с 3 вложенными циклами, получать сумму и добавлять ее в соответствующий "мусорный бак". Также, запомнив текущий индекс во "внешней" итерации и начав с него, вы можете оптимизировать свой код, убрав проверку и итератив меньше. Единственный трюк состоит в том, чтобы отфильтровать тройки формы [2, odd_prime, odd_prime] которые производят четные числа. ИМХО самый простой способ сделать это просто запустить отдельный цикл для [2, 2, odd_prime] тройни.

def goldbach(limit = 101):
    primes = primes_sieve(limit)
    primes_except_2 = primes[1:]
    primes_len = len(primes_except_2)

    triplets = [[] for i in xrange(limit + 1)]

    # explicitly handle case [2,2,prime]
    # all other cases [2, prime, prime] generate even results
    for ci in xrange(primes_len):
        c = primes_except_2[ci]
        s = 4 + c # 2 + 2 + c
        if s > limit:
            break
        else:
            triplets[s].append([2, 2, c])

    for ai in xrange(primes_len):
        a = primes_except_2[ai]
        for bi in xrange(ai, primes_len):
            b = primes_except_2[bi]
            for ci in xrange(bi, primes_len):
                c = primes_except_2[ci]
                s = a + b + c
                if s > limit:
                    break
                else:
                    triplets[s].append([a, b, c])

    for k, v in enumerate(triplets):
        if len(v) > 0:
            print(str(k) + ':' + str(v))

goldbach (31) производит следующую продукцию:

7: [[2, 2, 3]]
9: [[2, 2, 5], [3, 3, 3]]
11: [[2, 2, 7], [3, 3, 5]]
13: [[3, 3, 7], [3, 5, 5]]
15: [[2, 2, 11], [3, 5, 7], [5, 5, 5]]
17: [[2, 2, 13], [3, 3, 11], [3, 7, 7], [5, 5, 7]]
19: [[3, 3, 13], [3, 5, 11], [5, 7, 7]]
21: [[2, 2, 17], [3, 5, 13], [3, 7, 11], [5, 5, 11], [7, 7, 7]]
23: [[2, 2, 19], [3, 3, 17], [3, 7, 13], [5, 5, 13], [5, 7, 11]]
25: [[3, 3, 19], [3, 5, 17], [3, 11, 11], [5, 7, 13], [7, 7, 11]]
27: [[2, 2, 23], [3, 5, 19], [3, 7, 17], [3, 11, 13], [5, 5, 17], [5, 11, 11], [7, 7, 13]]
29: [[3, 3, 23], [3, 7, 19], [3, 13, 13], [5, 5, 19], [5, 7, 17], [5, 11, 13], [7, 11, 11]]
31: [[3, 5, 23], [3, 11, 17], [5, 7, 19], [5, 13, 13], [7, 7, 17], [7, 11, 13] ]

Вы также можете оптимизировать triplets внутри goldbach таким же образом, как в primes_sieve хранить только нечетные индексы (и не хранить пустые списки для четных), но я не стал беспокоиться.