Просто за да превърши бързо ... в примера 

0    1    2   3   4   5   6   7 => 8

25 31   6  9   2   4   7   0

когато алгоритъма се изпълни .. ще стигне до момент където loserList,Count == 7

това е за да може просто веднага да превърши обхождането 

и ще стане numberList.Count който ни е 8

=> 8 - 7 = 1 ... и при следващото врътване на цикъла нека се прекъсне ... и се извърши while проверката дали е останало 1 число 

Гарантирам ти че ако махнеш проверката .. ще си имаш проблеми с паметта 

Колега, здравей.

Знам че въпросът ми е малко глупав, но не мога да разбера защо на задачата Snowmen последния ред на втория примерен изход е 1 performed harakiri , а не 1 x 0 -> 0 wins. Би ли обяснил малко по - подробно защо е така? Благодаля предварително.

Имаш в задачата : 

индекси       ->    0    1     2    3    4    5    6     => 7 елемента в листа

стойности ->    25  31   6    9    2     4   7

започваме от първия индекс (т.е 0 със стойност 25) => стойността 25 е по-голяма от дължината на листа (т.е 7 )=>

ако 25 > 7 => 25 % 7 = 3 (4) или 25 % 7 = 4 (получаваме кое ще нападаме (т.е 4))

индекс 0 ще нападне индекс 4 => |0 - 4| = 4

=> 4 e четно (по правилата ще следва че ) => индекс 0 е победила индекс 4

ще има изход  :   0 x 4 => 0

                 loserList = ( 4 , )

следва ... индекс 1 ; Има стойност 31 ... стойността 31 е по-голяма от дължината на листа (т.е 7)=>

31 % 7 = 4 (3) или 31 % 7 = 3  (получаваме кое ще нападаме (т.е 3))

индекс 1 ще нападне индекс 3 => |1 - 3| = 2 е четно (по правилата ще следва че ) => индекс 1 е победила индекс 3

ще има изход  :   1 x 3 => 1

                 loserList = ( 4 , 3 )

следва ... индекс 2 ; Има стойност 6 ... стойността 6 не е по-голяма от дължината на листа (т.е 7)=>

индекс 2 ще нападне индекс 6 => |2 - 6| = 4 е четно (по правилата ще следва че ) => индекс 2 е победила индекс 6

ще има изход  :   2 x 6 => 2

                 loserList = ( 4 , 3 , 6 )

следва индекс 4 ... пропускаме  тъй като го има в  loserList = ( 4 , 3 , 6 )

следва индекс 5 ... Има стойност 4 ... стойността 4 не е по-голяма от дължината на листа (т.е 7)=>

индекс 5 ще нападне индекс 4 => |5 - 4| = 1 е нечетно (по правилата ще следва че ) => индекс 5 ще изгуби пред индекс 4

ще има изход  :   5 x 4 => 4

               loserList = ( 4 , 3 , 6 , 5 ) !!!! внимание няма никакво правило , което да казва че трябва ако победи да се вади от листа 

следва индекс 6 ... пропускаме  тъй като го има в  loserList = ( 4 , 3 , 6 )

   Добре обходихме листта един път ... махаме ... индексите в loserList-a

ще имаме ... нов лист 

0     1     2  => дължина 3

25  31   6

започваме както правихме горе ... (от индекс 0)

започваме от първия индекс (т.е 0 със стойност 25) => стойността 25 е по-голяма от дължината на листа (т.е 3 )=>

ако 25 > 3 => 25 % 3 = 8 (1) или 25 % 3 = 1 (получаваме кое ще нападаме (т.е 1))

индекс 0 ще нападне индекс 1 => |0 - 1| = 1

=> 1 e нечетно (по правилата ще следва че ) => индекс 0 ще загуби пред индекс 1

ще има изход  :   0 x 1 => 1

                 loserList = ( 0 , )

следва ... индекс 1 ; Има стойност 31 ... стойността 31 е по-голяма от дължината на листа (т.е 3)=>

31 % 3 = 10 (1) или 31 % 3 = 1  (получаваме кое ще нападаме (т.е 1))

индекс 1 ще нападне индекс 1 => |1 - 1| = 0 не ни интерисува дали е четно (по правилата ще следва че ) => индекс 1 ще удря индекс 1 => т.е това е самоубиство 

ще има изход  :  1 performed harakiri

                 loserList = ( 0 , 1 )

остава ни индекс 2 със стойност 6 (дебъгни програмата :Д и ще видиш как и това се решава )

Дано съм помогнал ... 

Или казано с думи прости просто трябва да се пазят числата от началото до края и да се делят на променящия се по големина размер на масива модулно.