Escreva dois fragmentos de código, que chamaremos de s_zero e s_one.

O programa (l, n) consiste em l cópias de s_zero e s_one correspondentes aos dígitos de n em binário, preenchidos com s_zero à esquerda.

Por exemplo, se s_zero = fooe s_one =, barentão
Programa (4, 0) = foofoofoofoo
Programa (4, 1) = foofoofoobar
Programa (4, 2) = foofoobarfoo
etc.

O programa (l, n) deve imprimir a fonte do programa (l, (n + 1) mod (2 ^ l)) para sair do padrão. No exemplo acima, foobarfoofoodeve-se imprimir foobarfoobarquando executado.

Sua pontuação é a soma dos comprimentos dos fragmentos s_zero e s_one

CJam, 29 + 29 = 58 bytes

O código 0:

0{"_~"]]z(3\+2b(2b2>a\+z~[}_~

O código 1:

1{"_~"]]z(3\+2b(2b2>a\+z~[}_~

Explicação

0                       " Push the current bit. ";
{"_~"                   " The basic quine structure. ";
    ]                   " Make an array of the current bit, the function and _~.
                          That is the code fragment itself. ";
    ]                   " Make an array of all code fragments in the stack. ";
    z(                  " Extract the array of the bits. ";
    3\+2b(2b2>          " Convert from base 2, decrease by one and convert back,
                          keeping the length. ";
    a\+z                " Put the bits back to the original position. ";
    ~                   " Dump the array of code fragments back into the stack. ";
    [                   " Mark the beginning position of the array of the next code fragment. ";
}_~

CJam, 47 + 47 = 94 bytes

O código 0:

{`"_~"+]:+T2*0+:T)\AsSerS/_,(@2Y$#+2bU@->]zs}_~

O código 1:

{`"_~"+]:+T2*1+:T)\AsSerS/_,(@2Y$#+2bU@->]zs}_~

Desculpe o palavrão.

Tenho certeza de que ainda posso cortar alguns bytes por lá. Acrescentarei uma explicação assim que decidir que não posso mais me dar ao trabalho de jogar golfe.

Teste aqui.

CJam, 45 + 45 = 90 bytes

O código 0 :

{`]W=L0+:L,Ua*L2b)2b+L,W*>\f{X$!s/\s*"_~"}}_~

O código 1 :

{`]W=L1+:L,Ua*L2b)2b+L,W*>\f{X$!s/\s*"_~"}}_~

Explicação em breve.

Experimente online aqui

GolfScript, 37 + 37 = 74 bytes

0{`".~"+:q;]-2%1\{1$^.@&q@}%\;-1%~}.~

1{`".~"+:q;]-2%1\{1$^.@&q@}%\;-1%~}.~

Não é tão curto quanto a solução CJam do user23013 , mas achei que iria postar isso de qualquer maneira, apenas para (marginalmente) aumentar a diversidade dos idiomas usados.

Minha solução não se baseia diretamente em nenhuma das soluções existentes (e, de fato, não as examinei em detalhes, pois ainda não leio muito bem o CJam), mas todas elas apresentam variantes da mesma estrutura básica de quine ( {".~"}.~em GolfScript, {"_~"}_~em CJam). Isso não é realmente muito surpreendente, pois parece ser uma das maneiras mais eficientes de escrever um quine com uma carga arbitrária nesses idiomas.

Não gosto muito de várias partes desse código e suspeito que talvez seja possível jogar mais, mas passei muito tempo nisso.