Escriba dos fragmentos de código, que llamaremos s_zero y s_one.

El programa (l, n) consiste en l copias de s_zero y s_one correspondientes a los dígitos de n en binario, rellenadas con s_zero a la izquierda.

Por ejemplo, si s_zero = fooy s_one = barentonces
Program (4, 0) = foofoofoofoo
Program (4, 1) = foofoofoobar
Program (4, 2) = foofoobarfoo
etc.

El programa (l, n) debe imprimir la fuente del programa (l, (n + 1) mod (2 ^ l)) a la salida estándar. En el ejemplo anterior, foobarfoofoodebe imprimir foobarfoobarcuando se ejecuta.

Su puntaje es la suma de las longitudes de los fragmentos s_zero y s_one

CJam, 29 + 29 = 58 bytes

El código 0:

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

El 1 código:

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

Explicación

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

El código 0:

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

El 1 código:

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

Disculpe el improperio.

Estoy seguro de que todavía puedo reducir algunos bytes allí. Agregaré una explicación una vez que decida que no puedo molestarme más en jugar golf.

Pruébalo aquí.

CJam, 45 + 45 = 90 bytes

El código 0 :

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

El 1 código:

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

Explicación pronto.

Pruébalo en línea aquí

GolfScript, 37 + 37 = 74 bytes

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

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

No es tan corto como la solución CJam de user23013 , pero pensé que publicaría esto de todos modos, aunque solo fuera (marginalmente) para aumentar la diversidad de los idiomas utilizados.

Mi solución no se basa directamente en ninguna de las soluciones existentes (y, de hecho, no las he examinado en detalle, ya que todavía no leo CJam muy bien), pero todas presentan variantes de la misma estructura básica de quine ( {".~"}.~en GolfScript, {"_~"}_~en CJam). Eso no es realmente muy sorprendente, ya que parece ser una de las formas más eficientes de escribir un quine con una carga útil arbitraria en estos idiomas.

Hay varias partes de este código que realmente no me gustan, y sospecho que es posible jugar golf más allá, pero he pasado demasiado tiempo en esto.