De elfen aan boord van de slee excuseren zich voor de vertraging, en garanderen dat de volgende puzzel op de ochtend van 24 december beschikbaar gemaakt zal worden. Ze vermelden verder dat hun boordcomputer een complex multiplexing patroon gebruikt. Als input wordt een rij van gehele getallen opgegeven, dat fase per fase omgezet wordt in nieuwe rijen van dezelfde lengte. Om dit te doen, wordt het patroon [0, 1, 0, -1] gebruikt om de verschillende elementen te vermenigvulden. Als de oorspronkelijke rij [9, 8, 7, 6, 5, 4] was, worden de elementen paarsgewijs vermenigvuldigd met dit patroon, en wordt de som berekend:

9 * 0 + 8 * 1 + 7 * 0 + 6 * (-1) + 5 * 0 + 4 * 1

Daarna wordt enkel het laatste cijfer behouden: 38 wordt bijvoorbeeld 8, terwijl -17 een 7 wordt. Dit wordt gedaan voor elk van de getallen in de nieuwe rij, maar het patroon verandert wel: de elementen worden eenmaal herhaald voor het eerste karakter, tweemaal voor het tweede, derde voor het derde, enzovoort. Voor het derde karakter gebruiken we dus het patroon [0, 0, 0, 1, 1, 1, 0, 0, 0, -1, -1, -1, ...]. Daarnaast moet er nog opgemerkt worden dat het van het eerste element in het patroon, de eerste instantie overgeslagen wordt. Het patroon hierboven moet dus eigenlijk [0, 0, 1, 1, 1, 0, 0, 0, -1, -1, -1, ...] zijn.

Zodra dit proces uitgevoerd wordt om elk element van de lijst te berekenen, wordt de fase beëindigd en kan de lijst gebruikt worden als input van de volgende fase. Gegeven het signaal [1, 2, 3, 4, 5, 6, 7, 8], zien de eerste twee fasen er als volgt uit:

1*1  + 2*0  + 3*(-1) + 4*0  + 5*1  + 6* 0   + 7*(-1) + 8*0  = 4
1*0  + 2*1  + 3*1    + 4*0  + 5*0  + 6*(-1) + 7*(-1) + 8*0  = 8
1*0  + 2*0  + 3*1    + 4*1  + 5*1  + 6*0    + 7*0    + 8*0  = 2
1*0  + 2*0  + 3*0    + 4*1  + 5*1  + 6*1    + 7*1    + 8*0  = 2
1*0  + 2*0  + 3*0    + 4*0  + 5*1  + 6*1    + 7*1    + 8*1  = 6
1*0  + 2*0  + 3*0    + 4*0  + 5*0  + 6*1    + 7*1    + 8*1  = 1
1*0  + 2*0  + 3*0    + 4*0  + 5*0  + 6*0    + 7*1    + 8*1  = 5
1*0  + 2*0  + 3*0    + 4*0  + 5*0  + 6*0    + 7*0    + 8*1  = 8
--> [4, 8, 2, 2, 6, 1, 5, 8]

4*1  + 8*0  + 2*(-1) + 2*0  + 6*1  + 1*0    + 5*(-1) + 8*0  = 3
4*0  + 8*1  + 2*1    + 2*0  + 6*0  + 1*(-1) + 5*(-1) + 8*0  = 4
4*0  + 8*0  + 2*1    + 2*1  + 6*1  + 1*0    + 5*0    + 8*0  = 0
4*0  + 8*0  + 2*0    + 2*1  + 6*1  + 1*1    + 5*1    + 8*0  = 4
4*0  + 8*0  + 2*0    + 2*0  + 6*1  + 1*1    + 5*1    + 8*1  = 0
4*0  + 8*0  + 2*0    + 2*0  + 6*0  + 1*1    + 5*1    + 8*1  = 4
4*0  + 8*0  + 2*0    + 2*0  + 6*0  + 1*0    + 5*1    + 8*1  = 3
4*0  + 8*0  + 2*0    + 2*0  + 6*0  + 1*0    + 5*0    + 8*1  = 8
--> [3, 4, 0, 4, 0, 4, 3, 8]

De honderste fase zal uiteindelijk leiden tot:

3*1  + 4*0  + 0*(-1) + 4*0  + 0*1  + 4*0    + 3*(-1) + 8*0  = 2
3*0  + 4*1  + 0*1    + 4*0  + 0*0  + 4*(-1) + 3*(-1) + 8*0  = 3
3*0  + 4*0  + 0*1    + 4*1  + 0*1  + 4*0    + 3*0    + 8*0  = 8
3*0  + 4*0  + 0*0    + 4*1  + 0*1  + 4*1    + 3*1    + 8*0  = 4
3*0  + 4*0  + 0*0    + 4*0  + 0*1  + 4*1    + 3*1    + 8*1  = 5
3*0  + 4*0  + 0*0    + 4*0  + 0*0  + 4*1    + 3*1    + 8*1  = 6
3*0  + 4*0  + 0*0    + 4*0  + 0*0  + 4*0    + 3*1    + 8*1  = 7
3*0  + 4*0  + 0*0    + 4*0  + 0*0  + 4*0    + 3*0    + 8*1  = 8
--> [2, 3, 8, 4, 5, 6, 7, 8]

Gevraagd wordt nu om een functie "transformatie" te voorzien, die als input een lijst van gehele getallen heeft (de input van de eerste fase) en als output een lijst van gehele getallen teruggeeft (de eerste acht getallen van het resultaat van de honderste fase). Bijvoorbeeld:

transformatie([1, 2, 3, 4, 5, 6, 7, 8]) # [2, 3, 8, 4, 5, 6, 7, 8]