Как очистить мой код

Вы можете полностью избавиться от списка. Просто сохраните два последних числа Фибоначчи в двух переменных и вычислите следующее в цикле (аналогично вашему первому циклу).

Затем сохраните промежуточную сумму всех чисел, которые соответствуют условию (т. Е. Четные и меньше миллиона) в том же цикле .

В Python все выглядит красивее!

def fibb():
    ret = 2 # to take into account the first 2
    fib = [1, 2]

    while True:
        latest = fib[-1] + fib[-2]
        if latest >= 4000000: return ret

        fib.append(latest)
        if latest % 2 == 0: ret += latest

Примечание: это было больше упражнение по программированию, чем что-либо еще. Я понимаю, что переходить на Python, вероятно, нецелесообразно.

Отредактируйте, вот более эффективный с точки зрения памяти подход без использования списков:

def fibb():
    ret = 0
    f0, f1 = (1, 1)

    while True:
        f0, f1 = (f1, f0 + f1)
        if f1 >= 4000000: return ret
        if f1 % 2 == 0: ret += f1

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

f0=1 #pre-last number
f1=1 #last number
while(...) {
    t = f0 + f1
    if (t%2 == 0) # replaces your second loop 
         sum += t 
    f0 = f1
    f1 = t
}

Затем вы можете заметить, что числа всегда идут в последовательности:

odd, odd, even, odd, odd, even [...]

и оптимизируйте дальше, если вам нужно

Прежде всего, прежде чем пытаться переписать какой-либо код, полезно провести модульный тест. Даже самое очевидное изменение может сломать нечто неожиданное.

Во-вторых, важно быть очень осторожным. Вы часто увидите в коде, что X-вызовы одних и тех же функций могут быть заменены одним вызовом, присвоением переменной и использованием этой переменной.

Однако при этом нужно быть осторожным. Например, в вашем текущем коде вы не можете действительно заменить list.size (), потому что размер изменяется все время между вызовами в одной и той же итерации.

Что в основном затрудняет понимание вашего кода, так это то, что вы ссылаетесь на индексы списков, когда обновляете списки. Вам нужно сохранить индексы в переменных, разделить на несколько строк и, возможно, добавить некоторые комментарии, чтобы сделать его более читабельным.

Ну, во-первых, член последовательности Фибоначчи порождается двумя предыдущими значениями перед ним. Почему бы просто не хранить два числа в буфере и не проверить, является ли число четным. Если оно четное, добавьте его к своей сумме и остановитесь, когда достигнете четырех миллионов.

код:

public int fibEvenSum(int a, int b) {

int sum = 0;
int c = a + b;

while (c <= 4000000) {

if (c % 2 == 0) {
sum += c;
}

//Shift the sequence by 1
a = b;
b = c;

c = a + b;

} //repeat

return sum;
}

Вот мой совет (я не собираюсь давать ответ, так как всегда лучше делать выводы самостоятельно)

Постарайтесь подумать, почему вам нужно сохранять значения последовательности? Ваша программа будет хранить 4000000 целых чисел в большом массиве, действительно ли в этом есть необходимость? Вы можете просто использовать 2 элемента и пролистывать их (используя расчет Фибоначчи), добавляя четные числа к переменной Total.

Вы бы сильно упростили, если бы не сохранили все значения в списке. Вы можете проверить, находятся ли они даже «на ходу»

, например так:

int old, current;
old = 1;
current = 1;

long value = 0;

while(current < 4000000) {
 if(current % 2  == 0) value += current;

 int tmp = old + current;
 old = current;
 current = tmp;
}

return value;

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

• Итак, перебираем последовательность Фибоначчи, используя какой-то цикл for / while.
• Добавьте его к переменной счета, если он четный.

Чтобы выполнить простую итерацию по последовательности, вам нужно записать только два самых последних значения ( f (n) и f (n-1) ) и (в зависимости от на вашем языке) временная переменная, когда вы обновляете эти значения. Обычно что-то вроде:

temp = current;
current = current + previous; // temp holds old value of current so the next line works.
previous = temp;

Простой подход - это базовый цикл for. Или вы можете создать свой собственный класс, реализующий интерфейс Iterator , если хотите, чтобы он был полностью объектно-ориентированным. Тогда ваш код мог бы быть таким простым, как:

Fib fib = new Fib();
for(long n : fib) {
    if(n % 2 == 0) t += n;
}

Это напомнило мне, что однажды я должен снова вернуться к Эйлеру.

Как решение @John Kugelman, но более эффективное. Этот цикл будет повторяться только 1/3 времени, и каждый цикл будет короче с меньшим количеством ветвлений и без необходимости проверки на четность. Здесь используется тот факт, что каждое третье значение fib является четным, и просто вычисляются значения между ними, чтобы сбросить значения a и b.

public static long fibb() {
    int a = 1, b = 1;
    long total = 0;
    while (true) {
        int c = a + b;
        if (c >= 4000000) return total;
        total += c;
        a = b + c;
        b = c + a;
    }
}