Il tuo compito, se desideri accettarlo, è scrivere un programma che produca un numero intero positivo (maggiore di 0). Se il codice sorgente viene duplicato, l'output deve rimanere lo stesso. La parte difficile è che se il codice sorgente viene digitato tre volte (triplicato?) L'output verrà moltiplicato per 3.

Regole

• È necessario creare un programma completo . Cioè, l'output deve essere stampato su STDOUT.

• La fonte iniziale deve essere lunga almeno 1 byte.

• Entrambi i numeri interi devono essere nella base 10 (è vietato emetterli in qualsiasi altra base o con notazione scientifica).

• Il tuo programma non deve accettare input (o avere input vuoti inutilizzati).

• L'output degli interi con spazi finali / iniziali è consentito.

• Gli zeri iniziali sono consentiti solo se il numero di cifre è coerente, ad esempio: 001 - 001 - 003 o 004 - 004 - 012

• Non puoi assumere una nuova riga tra le copie della tua fonte.

• Questo è code-golf , quindi vince il codice (originale) più breve in ogni lingua !

• Si applicano le lacune predefinite .

Esempio

Supponiamo che il codice sorgente sia Abce l'output corrispondente sia 4. Se AbcAbcinvece scrivo ed eseguo, l'output deve essere ancora 4. Tuttavia, se lo scrivo AbcAbcAbce lo eseguo, l'output deve essere 12.

Derubato senza vergogna Derivato dalla sfida del signor Xcoder

Wumpus , 6 byte

{~)
@O

Provalo online!
Provalo raddoppiato!
Provalo triplicato!

Stampe 1e 3.

Spiegazione

Ho trovato una tonnellata di soluzioni a 6 byte con la ricerca della forza bruta, ma nessuna per 5 byte. Ciò non significa necessariamente che non ce ne siano a 5 byte, ma probabilmente userebbero caratteri strani o qualcosa del genere.

Ho finito per scegliere questa soluzione perché non stampa alcun zero iniziale (molti di loro lo fanno) e ha un flusso di controllo interessante. Cominciamo con il singolo programma:

Quindi il codice eseguito è:

{~)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.

Abbastanza facile. Ora il programma raddoppiato. Poiché la prima riga viene aggiunta alla seconda riga, la griglia si estende fino alla larghezza 5 (e all'altezza 3) che modifica significativamente il flusso di controllo:

L'IP fa il giro del loop esattamente una volta, quindi il codice eseguito è:

{~){~)){~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.

Infine, il programma triplicato è abbastanza simile a quello raddoppiato, ma otteniamo un paio di comandi più importanti su quella terza riga:

Quindi il codice eseguito è:

{~){~)){~~)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.

Buccia , 5 byte

KΣK+1

Provalo online!

Ripetuto due volte!

Ripetuto tre volte!

Spiegazione

È abbastanza difficile costruire un programma ripetibile in Husk. Poiché il sistema dei tipi proibisce una funzione che può essere applicata a se stesso, devo in qualche modo consentire alla prima parte di valutare una funzione e il resto a valutare un valore, ei tipi di built-in esistenti sono progettati per impedire questo tipo di ambiguità. I token del programma sono

• K, che costruisce una funzione costante. K a bè equivalente a a.
• Σ, Che richiede un numero intero n e restituisce il n esimo numero triangolare.
• +, che aggiunge due numeri.
• 1, che è il letterale 1.

Il programma originale viene interpretato in questo modo:

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

La (K+)è una funzione assurdo che viene mangiato dal primo K.

Il programma ripetuto due volte viene interpretato in questo modo:

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

La funzione tra parentesi viene nuovamente utilizzata dal primo K.

Il programma ripetuto tre volte viene interpretato in questo modo:

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

Gelatina , 7 5 byte

»‘µ*Ḃ

Provalo online!

Provalo raddoppiato!

Provalo triplicato!

Come funziona

»‘µ*Ḃ            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 byte

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

Stampe 1: provalo online!

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

Stampa anche 1: provalo online!

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

Stampe 3: provalo online!

Cubix , 5 byte

)<@OP

Provalo online: una , due volte , tre volte .

Spiegazione

Cubix è un linguaggio basato su stack le cui istruzioni sono racchiuse all'esterno di un cubo. È importante notare che lo stack è inizialmente riempito con zero infiniti, il che ci consente di "estrarre valori dal nulla" con gli operatori anziché spingerli esplicitamente.

Devo ammettere che questo è stato trovato da un bruto-forcer; Non l'avrei mai trovato da solo. In effetti, @MartinEnder è stato colui che mi ha chiesto di provare la forza bruta, poiché aveva cercato questa soluzione senza fortuna. Questa è l'unica soluzione trovata dal bruto-forcer e credo sia l'unica e la più breve soluzione in Cubix.

Programma unico

Guarda correre!

Il programma originale si adatta a un cubo unità. Ecco la rete aperta:

  )
< @ O P
  .

L'IP (puntatore alle istruzioni) inizia sulla faccia più a sinistra (la <) rivolta verso est. La <punta immediatamente a ovest e si avvolge attorno alla P. Pè esponenziazione e poiché non c'è nulla nello stack, l'interprete estrae due 0 se calcola 0 ⁰ , che è 1 secondo JavaScript. Oquindi stampa questo valore e @termina il programma.

Doppio programma

Guarda correre!

)<@OP)<@OP

Il programma a 10 byte è troppo lungo per adattarsi a un cubo di unità, quindi viene espanso in un cubo di dimensione 2:

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

Come prima, l'IP inizia nella parte in alto a sinistra della faccia più a sinistra. Questa volta, la prima istruzione è P, che spinge un 1 come prima. Il prossimo è ), che incrementa l'elemento in alto, trasformandolo in un 2 . Quindi <gira l'IP e colpisce di )nuovo, trasformando il 2 in un 3 .

Ecco dove diventa interessante. Paumenta il secondo oggetto dall'alto alla potenza del primo oggetto, che dà 0 ³ = 0 . Quindi l'IP si sposta sulla faccia più a destra e passa attraverso due no-op .prima di colpirne un'altra P. Qui vediamo un'altra stranezza di Cubix: gli operatori binari (come P) non rimuovono i loro operandi dallo stack. Quindi, poiché lo stack è ora [3, 0], calcoliamo 3 ⁰ = 1 , che Ogenera e @termina il programma.

Programma triplo

Guarda correre!

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

Come con il doppio programma, la tripla può adattarsi a un cubo di dimensione 2:

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

Questo programma si avvia allo stesso modo del precedente: Ppreme 1 , )aumenta, <punta l'IP ovest, )aumenta di nuovo e Pora preme 0 . L'IP viene quindi avvolto <sulla faccia più a destra, che non fa nulla poiché l'IP è già puntato verso ovest.

Ecco la differenza dal doppio programma: )incrementa lo 0 in cima allo stack a 1 . Quando Pesegue di nuovo la sua magia, questa volta calcola 3 ¹ = 3 . Oesce e @termina, e dimostriamo in modo conclusivo che la terza volta è davvero il fascino.

Brain-Flak , 10 byte

<>([]{}())

Provalo online!

Provalo raddoppiato!

Provalo triplicato!

Spiegazione:

#Toggle stacks
<>

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

    #The TOS (initially 0) + 
    {}

    #1
    ()
)

Quando lo eseguiamo una volta, verrà inserito (0 + 0 + 1) == 1nello stack alternativo. Ha funzionato una seconda volta, mette lo stesso nello stack principale. Esegui una terza volta, tuttavia, valuta e lo inserisce (1 + 1 + 1) == 3nello stack alternativo e stampa implicitamente.

SQL, 25 24 23 byte

( -1 Byte Rimosso un personaggio che è stato compilato male sempre commentata e non fare niente )
( -1 Byte cambiato SELECTa PRINTcome raccomandato da Razvan Socol )

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

Come funziona:
in SQL, puoi commentare i tag di commento, in questo modo:

/*
'Comment'--*/

vs

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

Codice su 1 riga con commenti esclusi:
prima iterazione: SELECT 2-1output: 1
seconda iterazione: SELECT 2-1*2+1output: 1
terza iterazione: SELECT 2-1*2+1*2+1output:3

SOGL V0.12 , 7 5 4 byte

ē»«I

Provalo qui!

Provalo raddoppiato!

Provalo triplicato!

Spiegazione:

ē»«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 byte

.gDÈ+

Provalo online! o provalo raddoppiato! o provalo triplicato!

Spiegazione

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

Singolo: 0 + (0 % 2 == 0) -> 1
doppio: 1 + (1 % 2 == 0) -> 1
triplo:2 + (2 % 2 == 0) -> 3

> <> , 9 byte

\5 n;
\\1

Provalo online!

Provalo raddoppiato!

Provalo triplicato!

Ho trovato questo tipo di fortuna, usando la filosofia secondo cui "se fai il percorso del pesce abbastanza contorto, alla fine qualcosa funzionerà". Le versioni originali e raddoppiate stampano un 5 e la versione triplicata stampa 1 quindi 5 per fare 15 = 3 × 5. Ecco le versioni moltiplicate, per il tuo esame:

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

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

Python 2 ,  46 45  39 byte

Ispirato dalla risposta di Halvard . Sono contento che la mia sfida abbia ispirato una nuova, che trovo ancora più interessante. 6 byte salvati grazie a Kevin Cruijssen .

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

Provalo online!

Provalo raddoppiato!

Provalo triplicato!

Come funziona (obsoleto)

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.

Quando viene raddoppiato, la lunghezza diventa 90 , ma il nuovo codice viene ignorato grazie a #, quindi k==90valuta True. I booleani sono sottoclassi di numeri interi in Python, quindi k>>Trueè equivalente a k>>1, che è essenzialmente k / 2 = 45 . Quando viene triplicato, il nuovo codice viene nuovamente ignorato, quindi la nuova lunghezza è 135 , che non viene spostata perché viene k==90valutata in False, quindi k>>(k==90) ⟶ k>>(135==90) ⟶ k>>False ⟶ k>>0 ⟶ k, e k viene stampato così com'è.

Python 2 , 36 byte

Questo è stato un suggerimento di Aidan F. Pierce a 38 byte e l'ho giocato a golf di 2 byte. Non sto pubblicando questo come la mia soluzione principale perché non me ne sono inventato da solo.

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

Provalo online! Provalo raddoppiato! Provalo triplicato!

R , 37 31 28 byte

Grazie a Giuseppe per il golf degli ultimi 3 byte.

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

(con una nuova riga finale).

Provalo una volta!

Provalo due volte!

Provalo tre volte!

Questo utilizza il readLines()trucco della risposta di Giuseppe alla sfida delle 8 palle , dove stdinreindirizza al file sorgente. Questo codice sostanzialmente conta solo quante righe esistono al di sotto della prima riga e genera 1se ci sono 1 o 3 linee (cioè il codice è singolo o raddoppiato), o 3se ci sono 5 linee (cioè il codice è triplicato).

Perso , 38 byte

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

Provalo online!

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

Provalo online!

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

Provalo online!

Spiegazione

Lost è un linguaggio molto interessante per questa sfida. La solita tecnica persa è quella di costruire una "trappola". Una trappola è una sezione del programma progettata per catturare tutte le IP in un unico posto in modo che le loro pile possano essere eliminate e possano essere controllate per andare in una direzione specifica. Ciò rende molto più gestibile la scrittura di programmi in Lost. Tuttavia, poiché il programma è duplicato, dobbiamo evitare anche la duplicazione delle trap. Questo ci richiede di progettare una nuova trappola che funzioni correttamente ma quando viene duplicata solo una delle trappole funziona. La mia idea di base qui è la seguente

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

Mentre la pila non è vuota ?, rimuoverà un oggetto e lo farà tornare all'inizio se quell'oggetto è diverso da zero. La chiave qui è che quando questo impila la ^^s line up

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

Ciò significa che, indipendentemente da come entri, uscirai sempre nello stesso posto.

Da qui possiamo tentare di attuare la stessa idea dalla mia risposta Klein .

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

La spina dorsale del nostro programma è il lato sinistro che spinge un numero di 2s. Ogni volta che aggiungiamo una copia del programma, un altro 2viene aggiunto alla spina dorsale del programma, il che significa che un ulteriore 2 viene inserito nello stack. Una volta che scende dal fondo, rimbalza \\>ed esegue il codice

((1+@

Questo rimuove i primi 2 oggetti dello stack, ne aggiunge uno a tutto ciò che rimane ed esce. Una volta che la nostra spina dorsale ha 3 2, aggiungeremo 1 e otterremo 3, se abbiamo meno di 3 oggetti, elimineremo semplicemente l'intero stack e restituiremo 1.

Ora l'unico problema rimasto è che !nel nostro programma può causare un ciclo infinito. Se l'ip inizia a !salire salterà e atterrerà di nuovo dov'era. Questo significa che dobbiamo aggiungere un'altra riga sotto per evitare il loop.

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

Questo ha il leggero problema di mettere alcune ^trappole tra le nostre s nella trappola. Tuttavia, piuttosto miracolosamente, tutto funziona. I nostri ips rimbalzano correttamente in modo che non faccia differenza.

Stax , 5 byte

|dhH^

Esegui ed esegui il debug online! · Raddoppiato · triplicata

Spiegazione

|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 byte

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

Provalo online!

Japt , 8 6 5 byte

-1 byte grazie a @ETHproductions

°U-v

Spiegazione:

°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

Questo valuta 1-0 = 1

Raddoppia la valutazione a 2-1 = 1

Triplicato valuta 3-0 = 3

Pure Bash (no wco altri programmi di utilità esterni), 27

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

• Provalo una volta.
• Provalo due volte.
• Provalo tre volte.

Perl 5 , 18 15 13 12 11 byte

-3 byte grazie a nwellnhof

say 1|
+.7#

Una volta provalo online!

Due volte Provalo online!

Tre volte Provalo online!

> <> , 10 9 8 byte

562gn|

Provalo online!

Provalo raddoppiato!

Provalo triplicato!

Sono sicuro che ci sia una soluzione da 8 byte da qualche parte là fuori.

Il non stampabile alla fine ha il valore ASCII 1 ed è recuperato solo dal gcomando et sulla terza iterazione. Per i primi due stampa 05, quindi stampa 15.

C (gcc) , 107 byte

La mia prima presentazione in C (gcc). Troppo a lungo ...

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

Link TIO: singolo , doppio , triplo .

Labyrinth , 12 11 9 byte

:! #% @
 7

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

JavaScript, 81 77 74 70 byte

^{Salvato 4 byte grazie a Shaggy}

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

Soluzione JS piuttosto scadente. Utilizza i valori [3,1,1]dall'array da destra ( pop()). Registra un timeout per visualizzare il valore corrente in futuro. Se è già stato registrato un timeout, annullarlo. Si basa sulla natura sporca di var, che solleva dichiarazioni variabili.

Due volte:

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)

Tre volte:

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 byte

Nota lo spazio dopo #endif.

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

Provalo online!

Carbone , 12 byte

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

Provalo online! Il collegamento è al codice dettagliato.

Provalo raddoppiato!

Provalo triplicato!

Spiegazione

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

JavaScript, 43 40 byte

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 byte

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

Provalo online!

Provalo raddoppiato!

Provalo triplicato!

Ottiene la propria strada invocazione con $PSCOMMANDPATHe viene effettuato un get- content sul file. Ifil conteggio dei caratteri di quel file è inferiore a 99(controllato tramite wc -cda coreutils), quindi eseguiamo l'output 1e exit(ovvero, fermiamo l'esecuzione). Ciò rappresenta il codice originale e il codice raddoppiato. Altrimenti usciamo 3e usciamo . Il codice effettivo che si trova nelle sezioni raddoppiate o triplicate è insignificante, dal momento che o lo faremo exitprima di arrivare ad esso, oppure è dietro un commento #.

Salvato 6 byte grazie a Mr. Xcoder
Salvato 3 4 byte grazie a Pavel

C # (178 byte)

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

pazza soluzione C #, ma sono felice che sia possibile in una riga in C # affatto. :)

Per me la parte più difficile era avere un C # valido che avrebbe potuto inizializzare o incrementare la stessa variabile, quindi ho finito per abusare di ConfigurationManager perché avevo bisogno di un NameValueCollection statico globale e ConfigurationManager era l'unico a cui potevo pensare di poter aggiornare in memoria. EnvironmentVariables era un'altra opzione che ho scelto ma non ha un indicizzatore, quindi non sono sicuro di come farlo in una riga che può essere copiata e incollata per produrre l'output richiesto secondo le specifiche.

Incantesimi runici , 35 byte

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

Provalo online!

Lavorare su questo mi ha permesso di trovare un errore nel mio parser relativo ai nuovi caratteri del modificatore di ritardo, anche se il risultato finale non ne risente, poiché alla fine non ne ho avuto bisogno.

Funziona a causa del fatto che la riga finale non ha una nuova riga finale (o, del resto, spazi finali), che consente agli IP duplicati di spawnare in un posto diverso. Quello in alto a sinistra finisce per fare un grande giro attorno alla griglia mentre il secondo IP esegue un'operazione di riflessione per sostituire il \sulla sesta riga con a . Questo IP quindi eseguirà il ciclo per sempre e non farà nulla.

Anche il terzo IP fa lo stesso rimpiazzo allo stesso tempo, ma poiché è situato sulla 13a riga, la sua copia di quel riflettore lo invia verso l'alto ed esegue la 1f'3wsequenza presente nell'angolo in alto a destra, che sostituisce 1con a 3con il 14 line, appena prima che l'IP originale lo esegua, causando l'output del programma triplicato 3invece di 1(i valori potrebbero anche essere 2e 6, 3e 9, 4e 12, e 5e / o 15dovuti alla disponibilità di a-fcostanti numeriche; 1e 3sono stati scelti arbitrariamente). Viene quindi lasciato in un ciclo infinito eseguendo più comandi di riflessione che non fanno nulla.

Provalo in triplice copia!

Perl 5, 28 25 byte

-3 byte grazie a @neil!

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

Sposta il cursore indietro (non fa nulla all'inizio della riga) e stampa il valore di $a, prima e terza volta (ovvero, la terza volta che viene stampato un 1, il cursore si sposta e un 3 viene stampato sulla posizione dell'1).

QBasic, 19 byte

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

La fonte dovrebbe includere una nuova riga finale.

Spiegazione

Vogliamo uscita 1, 1, 3. Osserva che questi numeri sono uno in meno dei poteri di 2. Quindi:

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.