Su tarea, si desea aceptarlo, es escribir un programa que genere un número entero positivo (mayor que 0). Si el código fuente está duplicado, la salida debe permanecer igual. La parte difícil es que si el código fuente se escribe tres veces (¿triplicado?) La salida se multiplicará por 3.

Reglas

• Debes construir un programa completo . Es decir, su salida debe imprimirse en STDOUT.

• La fuente inicial debe tener al menos 1 byte de longitud.

• Ambos enteros deben estar en la base 10 (está prohibido emitirlos en cualquier otra base o con notación científica).

• Su programa no debe tomar entrada (o tener una entrada vacía no utilizada).

• La salida de los enteros con espacios finales / iniciales está permitida.

• Los ceros a la izquierda solo se permiten si el número de dígitos es consistente, por ejemplo: 001 - 001 - 003 o 004 - 004 - 012

• No puede asumir una nueva línea entre copias de su fuente.

• Este es el código de golf , por lo que gana el código más corto (original) en cada idioma .

• Se aplican las lagunas predeterminadas .

Ejemplo

Digamos que su código fuente es Abcy su salida correspondiente es 4. Si escribo en su AbcAbclugar y lo ejecuto, la salida aún debe ser 4. Sin embargo, si lo escribo AbcAbcAbcy lo ejecuto, la salida debe ser 12.

Robado descaradamente Derivado del desafío del Sr. Xcoder

Wumpus , 6 bytes

{~)
@O

Pruébalo en línea!
¡Pruébalo doblado!
¡Pruébalo triplicado!

Impresiones 1y 3.

Explicación

Encontré una tonelada de soluciones de 6 bytes por búsqueda de fuerza bruta, pero ninguna de 5 bytes. Eso no significa necesariamente que no haya ninguno en 5 bytes, pero probablemente usarían caracteres extraños o algo así.

Terminé eligiendo esta solución porque no imprime ceros a la izquierda (la mayoría lo hace) y tiene un flujo de control interesante. Comencemos con el programa único:

Entonces el código ejecutado es:

{~)O@

{   Turn the IP left by 60°.
~   Swap two implicit zeros on the stack, does nothing.
)   Increment the top zero to 1.
O   Print it.
@   Terminate the program.

Suficientemente fácil. Ahora el programa duplicado. Como la primera línea se agrega a la segunda línea, la cuadrícula se extiende hasta el ancho 5 (y la altura 3), lo que cambia significativamente el flujo de control:

La IP recorre ese ciclo exactamente una vez, por lo que el código ejecutado es:

{~){~)){~O@

{~) As before, we end up with a 1 on top of the stack.
{   Turn left by 60° again.
~   Swap the 1 with the 0 underneath.
))  Increment the zero to 2.
{   Turn left by 60° again.
~   Swap the 2 with the 1 underneath.
O   Print the 1.
@   Terminate the program.

Finalmente, el programa triplicado es bastante similar al duplicado, pero obtenemos un par de comandos más importantes en esa tercera línea:

Entonces el código ejecutado es:

{~){~)){~~)O@

{~){~)){~
    As before. We end up with a 1 on top of the stack and a 2 underneath.
~   Swap the 1 with the 2 underneath.
)   Increment the 2 to a 3.
O   Print the 3.
@   Terminate the program.

Casco , 5 bytes

KΣK+1

Pruébalo en línea!

Repetido dos veces!

Repetido tres veces!

Explicación

Es bastante difícil construir un programa repetible en Husk. Debido a que el sistema de tipos prohíbe una función que se puede aplicar a sí misma, tengo que permitir de alguna manera que la primera parte evalúe una función, y el resto evalúe un valor, y los tipos de incorporados existentes están diseñados para evitar esto. tipo de ambigüedad Los tokens del programa son

• K, que construye una función constante. K a bes equivalente a a.
• Σ, Que toma un número entero n y devuelve el n ésimo número triangular.
• +, que suma dos números.
• 1, que es el literal 1.

El programa original se interpreta así:

   K Σ (K+) 1
== Σ 1
== 1

La (K+)es una función sin sentido que se come por el primero K.

El programa repetido dos veces se interpreta así:

   K Σ (K+1KΣK+) 1
== Σ 1
== 1

La función entre paréntesis vuelve a ser utilizada por el primero K.

El programa repetido tres veces se interpreta así:

   K (Σ (K (+1) (KΣK+) 1)) (KΣK+1)
== Σ (K (+1) (KΣK+) 1)
== Σ ((+1) 1)
== Σ (+1 1)
== Σ 2
== 3

Jalea , 7 5 bytes

»‘µ*Ḃ

Pruébalo en línea!

¡Pruébalo doblado!

¡Pruébalo triplicado!

Cómo funciona

»‘µ*Ḃ            Main link. No arguments. Implicit argument: x = 0

 ‘               Increment; yield x + 1 = 1.
»                Take the maximum of x and 1. Yields 1.
  µ              Begin a new, monadic chain. Argument: y = 1
    Ḃ            Bit; yield 1 if y is odd, 0 if it is even. Yields 1.
   *             Power; yield y**1 = 1.

»‘µ*Ḃ»‘µ*Ḃ       Main link.

»‘µ*Ḃ            As before.
      ‘          Increment; yield y + 1 = 2.
     »           Take the maximum of 1 and 2. Yields 2.
       µ         Begin a new, monadic chain. Argument: z = 2
         Ḃ       Bit; yield 1 if z is odd, 0 if it is even. Yields 0.
        *        Power; yield z**0 = 1.

»‘µ*Ḃ»‘µ*Ḃ»‘µ*Ḃ  Main link.

»‘µ*Ḃ»‘µ*Ḃ       As before.
           ‘     Increment; yield z + 1 = 3.
          »      Take the maximum of 1 and 3. Yields 3.
            µ    Begin a new, monadic chain. Argument: w = 3
              Ḃ  Bit; yield 1 if w is odd, 0 if it is even. Yields 1.
             *   Power; yield w**1 = 3.

Haskell , 24 bytes

main=print.div 3$4
 -1--

Impresiones 1: ¡ Pruébelo en línea!

main=print.div 3$4
 -1--main=print.div 3$4
 -1--

También imprime 1: ¡ Pruébelo en línea!

main=print.div 3$4
 -1--main=print.div 3$4
 -1--main=print.div 3$4
 -1--

Impresiones 3: ¡ Pruébelo en línea!

Cubix , 5 bytes

)<@OP

Pruébelo en línea: una vez , dos veces , tres veces .

Explicación

Cubix es un lenguaje basado en pila cuyas instrucciones están envueltas alrededor del exterior de un cubo. Es importante tener en cuenta que la pila se llena inicialmente con ceros infinitos, lo que nos permite "extraer valores de la nada" con los operadores en lugar de empujarlos explícitamente.

Debo admitir que esto fue encontrado por un brujo forzador; Nunca lo habría encontrado por mi cuenta. De hecho, @MartinEnder fue quien me pidió que intentara forzar la fuerza bruta, ya que había estado buscando esta solución sin suerte. Esta es la única solución que encontró el brute-forcer, y creo que es la única solución más corta en Cubix.

Programa único

¡Míralo correr!

El programa original se ajusta a un cubo unitario. Aquí está la red desplegada:

  )
< @ O P
  .

El IP (puntero de instrucción) comienza en la cara más a la izquierda (el <) hacia el este. El <apunta inmediatamente al oeste, y se envuelve alrededor de la P. Pes la exponenciación, y como no hay nada en la pila, el intérprete saca dos 0 sy calcula 0 ⁰ , que es 1 según JavaScript. Oluego imprime este valor y @finaliza el programa.

Programa doble

¡Míralo correr!

)<@OP)<@OP

El programa de 10 bytes es demasiado largo para caber en un cubo unitario, por lo que se expande a un cubo de tamaño 2:

    ) <
    @ O
P ) < @ O P . .
. . . . . . . .
    . .
    . .

Como antes, la IP comienza en la parte superior izquierda de la cara más a la izquierda. Esta vez, la primera instrucción es P, que empuja un 1 como antes. El siguiente es ), que incrementa el elemento superior, convirtiéndolo en un 2 . Luego <da vuelta la IP, y golpea )nuevamente, transformando el 2 en un 3 .

Aquí es donde se pone interesante. Peleva el segundo elemento desde la parte superior a la potencia del primer elemento, lo que da 0 ³ = 0 . Luego, la IP se ajusta a la cara más a la derecha y pasa por dos no-ops .antes de golpear a otra P. Aquí vemos otra peculiaridad de Cubix: los operadores binarios (como P) no eliminan sus operandos de la pila. Entonces, dado que la pila es ahora [3, 0], calculamos 3 ⁰ = 1 , que Ogenera y @finaliza el programa.

Programa triple

¡Míralo correr!

)<@OP)<@OP)<@OP

Al igual que con el programa doble, el triple puede caber en un cubo de tamaño 2:

    ) <
    @ O
P ) < @ O P ) <
@ O P . . . . .
    . .
    . .

Este programa comienza de la misma manera que el anterior: Pempuja 1 , )incrementa, <apunta la IP hacia el oeste, )incrementa nuevamente, y Pahora empuja 0 . Luego, la IP se envuelve <en la cara más a la derecha, lo que no hace nada ya que la IP ya está apuntando hacia el oeste.

Aquí está la única diferencia del programa doble: )incrementa el 0 en la parte superior de la pila a un 1 . Cuando Prealiza su magia nuevamente, esta vez calcula 3 ¹ = 3 . Osalidas y @termina, y demostramos de manera concluyente que la tercera vez es realmente el encanto.

Brain-Flak , 10 bytes

<>([]{}())

Pruébalo en línea!

¡Pruébalo doblado!

¡Pruébalo triplicado!

Explicación:

#Toggle stacks
<>

#Push
(
    #Stack-height (initially 0) + 
    []

    #The TOS (initially 0) + 
    {}

    #1
    ()
)

Cuando ejecutamos esto una vez, se colocará (0 + 0 + 1) == 1en la pila alternativa. Corrió por segunda vez, pone lo mismo en la pila principal. Sin embargo, si se ejecuta por tercera vez, se evalúa (1 + 1 + 1) == 3y lo empuja a la pila alternativa e imprime implícitamente.

SQL, 25 24 23 bytes

( -1 Byte Se eliminó un carácter mal escrito que siempre se comentaba y no hacía nada )
( -1 Byte se cambió SELECTa PRINTlo recomendado por Razvan Socol )

PRINT 2/*
*2+1--*/-1
--

Cómo funciona:
en SQL, puede comentar las etiquetas de comentarios, así:

/*
'Comment'--*/

vs

--/*
'Not Comment'--*/

Código en 1 línea con comentarios excluidos:
Primera iteración: SELECT 2-1Salida: 1
Segunda iteración: SELECT 2-1*2+1Salida: 1
Tercera iteración: SELECT 2-1*2+1*2+1Salida:3

SOGL V0.12 , 7 5 4 bytes

ē»«I

Pruébalo aquí!

¡Pruébalo doblado!

¡Pruébalo triplicado!

Explicación:

ē»«I
ē     push counter, then increment it.
      First time running this will push 0, then 1, then 2.
             TOS on each: 0  1  2
 »    floor divide by 2   0  0  1
  «   multiply by 2       0  0  2
   I  and increment       1  1  3

05AB1E , 6 5 bytes

.gDÈ+

Pruébalo en línea! o Pruébalo doblado! o Pruébalo triplicado!

Explicación

.g     # push length of stack
  D    # duplicate
   È   # check if even
    +  # add

Individual: 0 + (0 % 2 == 0) -> 1
Doble: 1 + (1 % 2 == 0) -> 1
Triple:2 + (2 % 2 == 0) -> 3

> <> , 9 bytes

\5 n;
\\1

Pruébalo en línea!

¡Pruébalo doblado!

¡Pruébalo triplicado!

Encontré este tipo de suerte, usando la filosofía de que "si haces que el camino del pez sea lo suficientemente complicado, eventualmente algo funcionará". Las versiones original y duplicada imprimen un 5, y la versión triplicada imprime 1 y luego 5 para hacer 15 = 3 × 5. Aquí están las versiones multiplicadas, para su lectura:

\5 n;
\\1\5 n;
\\1

\5 n;
\\1\5 n;
\\1\5 n;
\\1

Python 2 ,  46 45  39 bytes

Inspirado por la respuesta de Halvard . Me alegra que mi desafío haya inspirado uno nuevo, que encuentro aún más interesante. Guardado 6 bytes gracias a Kevin Cruijssen .

print open(__file__,"a").tell()/79*3|1#

Pruébalo en línea!

¡Pruébalo doblado!

¡Pruébalo triplicado!

Cómo funciona (anticuado)

k=open(__file__,"a").tell() # Read the source code in "append" mode and get its length.
                            # Assign it to a variable k.
;print k>>(k==90)#          # Print k, with the bits shifted to the right by 1 if k
                            # is equal to 90, or without being shifted at all overwise.
                            # By shifting the bits of a number to the right by 1 (>>1),
                            # we basically halve it.

Cuando se duplica, la longitud se convierte en 90 , pero el nuevo código se ignora gracias a #, por lo que se k==90evalúa como True. Los booleanos son subclases de enteros en Python, por lo que k>>Truees equivalente a k>>1, que es esencialmente k / 2 = 45 . Cuando se triplica, el nuevo código se ignora nuevamente, por lo tanto, la nueva longitud es 135 , que no se desplaza porque se k==90evalúa a False, entonces k>>(k==90) ⟶ k>>(135==90) ⟶ k>>False ⟶ k>>0 ⟶ k, y k se imprime tal cual.

Python 2 , 36 bytes

Esta fue una sugerencia de Aidan F. Pierce a 38 bytes, y la jugué por 2 bytes. No estoy publicando esto como mi solución principal porque no se me ocurrió.

0and""
True+=1
print True>3and 3or 1

Pruébalo en línea! ¡Pruébalo doblado! ¡Pruébalo triplicado!

R , 37 31 28 bytes

Gracias a Giuseppe por jugar golf en los últimos 3 bytes.

length(readLines())%/%2*2+1

(con una nueva línea al final).

¡Pruébalo una vez!

¡Pruébalo dos veces!

¡Pruébalo tres veces!

Esto utiliza el readLines()truco de la respuesta de Giuseppe al desafío de 8 bolas , donde se stdinredirige al archivo fuente. Básicamente, este código solo cuenta cuántas líneas existen debajo de la primera línea y genera salidas 1si hay 1 o 3 líneas (es decir, el código es simple o doble), o 3si hay 5 líneas (es decir, el código se triplica).

Perdido , 38 bytes

\\<<<<</<<<<>
2>((1+@>?!^%^
.........v

Pruébalo en línea!

\\<<<<</<<<<>
2>((1+@>?!^%^
.........v\\<<<<</<<<<>
2>((1+@>?!^%^
.........v

Pruébalo en línea!

\\<<<<</<<<<>
2>((1+@>?!^%^
.........v\\<<<<</<<<<>
2>((1+@>?!^%^
.........v\\<<<<</<<<<>
2>((1+@>?!^%^
.........v

Pruébalo en línea!

Explicación

Lost es un lenguaje muy interesante para este desafío. La técnica habitual de Lost es construir una "trampa". Una trampa es una sección del programa diseñada para atrapar todos los ips en un solo lugar para que sus pilas se puedan despejar y se pueda controlar para ir en una dirección específica. Esto hace que los programas de escritura en Lost sean mucho más manejables. Sin embargo, dado que el programa está duplicado, también debemos evitar la duplicación de trampas. Esto requiere que diseñemos una nueva trampa que funcione correctamente, pero cuando se duplica solo una de las trampas funciona. Mi idea básica aquí es la siguiente

v<<<<>
>%?!^^

Mientras la pila no esté vacía ?, eliminará un elemento y hará que vuelva al principio si ese elemento no es cero. La clave aquí es que cuando esto se acumula la ^^línea s

v<<<<>
>%?!^^v<<<<>
>%?!^^v<<<<>
>%?!^^v<<<<>
>%?!^^v<<<<>
>%?!^^

Lo que significa que no importa cómo ingrese, siempre saldrá en el mismo lugar.

Desde aquí podemos intentar implementar la misma idea de mi respuesta de Klein .

\\<<<<<v<<<<>
2>((1+@>?!^%^

La columna vertebral de nuestro programa es el lado izquierdo que empuja varios 2s. Cada vez que agregamos una copia del programa, 2se agrega otra a la columna vertebral del programa, lo que significa que se agregan 2 adicionales a la pila. Una vez que sale del fondo, rebota \\>y ejecuta el código

((1+@

Esto elimina los primeros 2 elementos de la pila, agrega uno a lo que queda y sale. Una vez que nuestra columna vertebral tenga 3 2s, agregaremos 1 y obtendremos 3; si tenemos menos de 3 elementos, descartaremos toda la pila y devolveremos 1.

Ahora el único problema que queda es que !en nuestro programa puede causar un bucle infinito. Si la ip comienza a !subir, saltará y aterrizará de nuevo donde estaba. Esto significa que tenemos que agregar otra línea debajo para evitar el bucle.

\\<<<<</<<<<>
2>((1+@>?!^%^
.........^

Esto tiene el ligero problema de poner algunas barras entre nuestros ^s en la trampa. Sin embargo, bastante milagrosamente, todo funciona. Nuestros ips rebotan adecuadamente para que no haga la diferencia.

Stax , 5 bytes

|dhH^

Ejecutar y depurar en línea! · Doblado · Triplicado

Explicación

|dhH^
|d       Push Current stack depth `d`, originally 0
         Doubled -> 1, Tripled -> 2
  hH^    Map d to 2*(floor(d/2))+1
         Implicit print

C (gcc) , 95 91 85 bytes

#ifndef a
#define a-1
main(){puts(3
#include __FILE__
?"1":"3");}
#define a
#endif
a

Pruébalo en línea!

Japt , 8 6 5 bytes

-1 byte gracias a @ETHproductions

°U-v

Explicación:

°U-v
 U     # variable U=0                # U=0
°U     # ++U                         # U=1
  -    # minus:
   v   #   1 if U is divisible by 2  
       #     else
       #   0                         # U=1

Esto evalúa a 1-0 = 1

Doble evalúa a 2-1 = 1

Triplicado evalúa a 3-0 = 3

Pure Bash (sin wcu otras utilidades externas), 27

trap echo\ $[a++&2|1] EXIT

• Pruébalo una vez.
• Inténtalo dos veces.
• Pruébalo tres veces.

Perl 5 , 18 15 13 12 11 bytes

-3 bytes gracias a nwellnhof

say 1|
+.7#

Una vez Pruébelo en línea!

Dos veces Pruébelo en línea!

Tres veces Pruébelo en línea!

> <> , 10 9 8 bytes

562gn|

Pruébalo en línea!

¡Pruébalo doblado!

¡Pruébalo triplicado!

Estoy seguro de que hay una solución de 8 bytes en algún lugar.

Lo no imprimible al final tiene el valor ASCII 1, y solo se obtiene con el gcomando et en la tercera iteración. Para los dos primeros imprime 05, y luego imprime 15.

C (gcc) , 107 bytes

Mi primera presentación en C (gcc). Demasiado tiempo ...

i;
#ifdef c
#define c
#ifdef b
i=2;
#else
#define b
#endif
#else
#define c main(){putchar(i+49);}
#endif
c

Enlaces TIO: simple , doble , triple .

Laberinto , 12 11 9 bytes

: #%! @
 7 7

TIO (1x) , TIO (2x) , TIO (3x)

JavaScript, 81 77 74 70 bytes

^{Guardado 4 bytes gracias a Shaggy}

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

Bastante patética solución JS. Consume los valores de la [3,1,1]matriz desde la derecha ( pop()). Registra un tiempo de espera para mostrar el valor actual en el futuro. Si ya se registró un tiempo de espera, cancélelo. Se basa en la naturaleza sucia de var, que levanta declaraciones variables.

Dos veces:

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

Tres veces:

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

C (gcc) , 53 52 bytes

Tenga en cuenta el espacio después #endif.

n;main(){putchar(n+49);}
#if __LINE__>7
n=2;
#endif 

Pruébalo en línea!

Carbón de leña , 12 bytes

⎚≔⁺ι¹ιＩ⁻ι⁼ι²

Pruébalo en línea! El enlace es a código detallado.

¡Pruébalo doblado!

¡Pruébalo triplicado!

Explicación

⎚             Clear
 ≔⁺ι¹ι        Assign plus(i, 1) to i
       Ｉ      Cast (and implicitly print)
         ⁻ ⁼ι² Subtract equals(i, 2) from
          ι    i

JavaScript, 43 40 bytes

var t=t?--t:~!setTimeout`t=alert(1|~t)`;

2x:

var t=t?--t:~!setTimeout`t=alert(1|~t)`;var t=t?--t:~!setTimeout`t=alert(1|~t)`;

3x:

var t=t?--t:~!setTimeout`t=alert(1|~t)`;var t=t?--t:~!setTimeout`t=alert(1|~t)`;var t=t?--t:~!setTimeout`t=alert(1|~t)`;

PowerShell , 54 48 45 44 bytes

if(99-gt(gc $PSCOMMANDPATH|wc -c)){1;exit}3#

Pruébalo en línea!

¡Pruébalo doblado!

¡Pruébalo triplicado!

Obtiene su propio camino con la invocación $PSCOMMANDPATHy realiza una get- contenido en el archivo. Ifel recuento de caracteres de ese archivo es menor que 99(verificado a través wc -cde coreutils), luego generamos 1y exit(es decir, detenemos la ejecución). Eso explica el código original y el código duplicado. De lo contrario, salimos 3y salimos . El código real que está en las secciones duplicadas o triplicadas no tiene sentido, ya que lo haremos exitantes de llegar a él o está detrás de un comentario #.

Guardado 6 bytes gracias a Mr. Xcoder
Guardado 3 4 bytes gracias a Pavel

C # (178 bytes)

Console.WriteLine(1+2*4%int.Parse(System.Configuration.ConfigurationManager.AppSettings["z"]=(int.Parse(System.Configuration.ConfigurationManager.AppSettings["z"]??"0"))+1+""));

solución loca de C #, pero estoy feliz de que sea posible en una línea en C #. :)

Para mí, la parte más difícil fue tener un C # válido que inicializara o incrementara la misma variable, así que terminé abusando del ConfigurationManager porque necesitaba un NameValueCollection global estático y ConfigurationManager era el único que podía pensar que podía actualizar en la memoria. EnvironmentVariables fue otra opción que busqué pero no tiene un indexador, por lo que no estoy seguro de cómo hacerlo en una línea que se pueda copiar y pegar para producir el resultado requerido según las especificaciones.

Encantamientos rúnicos , 35 bytes

^w3'\
    f
    1
/1@
/
 '54\w
/yyy

Pruébalo en línea!

Trabajar en este me permitió encontrar un error en mi analizador relacionado con los nuevos caracteres modificadores de retraso, aunque el resultado final no se ve afectado por él, ya que terminé sin necesitarlos.

Funciones debido al hecho de que la línea final no tiene una nueva línea final (o, para el caso, espacios finales), lo que permite que las IP duplicadas se generen en un lugar diferente. El de arriba a la izquierda termina haciendo un gran bucle alrededor de la cuadrícula, mientras que el segundo IP realiza una operación de reflexión para reemplazar el \en la sexta línea con a . Esta IP se repetirá para siempre y no hará nada.

La tercera IP también hace este mismo reemplazo al mismo tiempo, pero debido a que está situada en la línea 13 , su copia de ese reflector lo envía hacia arriba y ejecuta la 1f'3wsecuencia presente en la esquina superior derecha, que reemplaza la 1con una 3en el 14 línea, justo antes de que la IP original lo ejecute, lo que hace que el programa triplicado salga en 3lugar de 1(los valores también podrían ser 2y 6, 3y 9, 4y 12, 5y 15debido a la disponibilidad de a-fconstantes numéricas; 1y 3fueron elegidos arbitrariamente). Luego se deja en un bucle sin fin realizando más comandos de reflexión que no hacen nada.

¡Pruébalo por triplicado!

Perl 5, 28 25 bytes

-3 bytes gracias a @neil!

print"\e[D$a"if(++$a!=2);

Mueve el cursor hacia atrás (no hace nada al inicio de la línea) e imprime el valor de la $aprimera y la tercera vez (es decir, la tercera vez que se imprime un 1, el cursor se mueve y se imprime un 3 en la posición del 1).

QBasic, 19 bytes

CLS
x=2^x
?x-1OR 1

La fuente debe incluir una nueva línea final.

Explicación

Queremos salida 1, 1, 3. Observe que estos números son uno menos que las potencias de 2. Entonces:

CLS      ' CLear Screen of any output from previous copies of the code

x        ' Numeric variables are preset to 0...
 =2^x    ' so as this statement is repeated, the value of x goes 1, 2, 4

 x-1     ' Therefore x-1 goes 0, 1, 3...
    OR 1 ' and we bitwise OR it with 1 to change the 0 to 1...
?        ' and print.