Raddoppio la fonte, raddoppi l'uscita!


127

Il tuo compito, se desideri accettarlo, è scrivere un programma che produca un numero intero positivo (maggiore di 0). La parte difficile è che se duplico il codice sorgente, l'output deve essere il doppio dell'intero originale.

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.

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

  • Questo è , 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 8.

Classifica

Questo utilizza il layout di @ manatwork .


2
@ Mr.Xcoder Quindi dovrò solo includerne uno nella mia fonte.
Steenbergh,

3
@ Mr.Xcoder Penso che avresti dovuto impedire di leggere il tuo codice sorgente.
caird coinheringaahing il

1
Deve funzionare solo se raddoppiato una volta ? Non abbiamo bisogno di sostenere n molti raddoppi?
Cody Gray,

6
@Daniel Supponiamo che la tua fonte sia `` (programma vuoto) e produca 5. Se lo raddoppi, la tua fonte è `` (programma vuoto) e anche quello produce 5, qualunque cosa tu faccia. Detto questo, un programma vuoto duplicato è ancora il programma vuoto e produce sempre lo stesso output, tranne nel caso in cui il programma vuoto significhi qualcos'altro (un generatore di numeri casuali, ad esempio), che non potrebbe essere valido comunque.
Mr. Xcoder,

1
Questo non dovrebbe essere difficile per gli esolang che scaricano automaticamente la parte superiore dello stack al termine del programma.
MD XF,

Risposte:


152

Python 2 , 33 byte

print len(open(__file__).read())#

Provalo online!

Provalo raddoppiato

Python 3 , 28 byte

print(len(*open(__file__)))#

Provalo online!

Provalo raddoppiato

Spiegazione

Questo apre il codice sorgente usando open(__file__)e ottiene la sua lunghezza usando lenil #impedisce la lettura di qualsiasi codice aggiuntivo. Quando la fonte viene raddoppiata, aumenta anche la lunghezza.


28
Wow, sono sbalordito ... È così geniale!
Mr. Xcoder,

2
32 byte . Funziona utilizzando la modalità append, impostando la posizione corrente alla fine del file. tell()restituisce la posizione corrente nel file
Halvard Hummel,

@HalvardHummel Nice. Tuttavia non ho intenzione di aggiornare questa risposta. Se desideri pubblicarlo da solo, secondo me è sostanzialmente diverso.
Sriotchilism O'Zaic,

@WheatWizard Questo è comprensibile, ho fatto una risposta
Halvard Hummel,

96

Gelatina , 1 byte

Provalo online!

o provalo due volte!

Non ho idea di come funzioni, ma a quanto pare funziona.


55
Quel momento in cui non hai idea di cosa hai scritto ...
Mr. Xcoder,

2
Accidenti, ho pensato a questi 8 minuti troppo tardi.
HyperNeutrino,

17
Tutti i collegamenti richiedono un argomento. Se il primo elemento della catena è un nilad, il suo risultato diventa l'argomento e il collegamento viene eseguito monadicamente. Se non è presente nilad iniziale, viene utilizzato 0 .
Dennis,

65

Fogli Google, 11 5 byte

Formula anonima del foglio di lavoro che non accetta input e output nella cella che contiene la formula

=4/(2

Come singola formula, questo si traduce in uno stack di chiamate che assomiglia a qualcosa di simile

=4/(2
=4/(2)
=4/2
=2
2

Tuttavia, quando questa formula del foglio di lavoro viene raddoppiata, lo stack di chiamate viene valutato fino a

=4/(2=4/(2
=4/(2=4/(2)
=4/(2=4/(2))
=4/(2=2)
=4/(True)
=4/True
=4/1
=4
4

Naturalmente, un'implicazione dell'uso di questo metodo è che una volta che questo viene ripetuto più di una volta, alla terza e tutte le successive iterazioni del problema, lo stack di chiamate raggiungerà =4/(2=4)e quindi valuterà e genererà =4/0un #DIV/0!errore

-6 byte passando all'algebra lontano dalla =DIVIDE(4,2formula


18
Non mi sarei mai aspettato che Google Sheets avrebbe usato nel golf del codice. Soluzione intelligente
hucancode

11
@hucancode la cosa veramente interessante di questo è che, poiché Excel genera un errore se si esclude la )risposta del trailing , questa è l'unica risposta di Fogli Google che ho visto che non si traduce in una risposta di Excel
Taylor Scott,

45

05AB1E , 2 byte

Originale

XO

Provalo online!

raddoppiato

XOXO

Provalo online!

Spiegazione

X spinge 1 nello stack.
O somma la pila.


48
XOXO, bella soluzione.
Mr. Xcoder,

4
L'hai fatto apposta, mentre sapevi che avresti potuto anche usare 1O!
Erik the Outgolfer,

12
Dove trovate queste lingue ridicole?
DavidB,

7
@DavidB Di solito, li scrivono.
Federico Poloni,

3
@DavidB Sì, la gente non inventano lingue per codegolf, e sì, si può ottenere impressionante punteggi bassi, ma fare cose stupide come inventare una lingua, dopo la sfida di risolvere in 1 byte non sono consentiti, e la programmazione in queste lingue è di solito lontano dal facile.
Esolanging Fruit,

43

C (gcc), 37 byte

i;main(){putchar(i+49);}/*
i=1;//*///

Il file non contiene una nuova riga finale.

Versione doppia, per l'evidenziazione della sintassi:

i;main(){putchar(i+49);}/*
i=1;//*///i;main(){putchar(i+49);}/*
i=1;//*///

Link TIO: singolo , doppio .


3
Puoi spiegare come funziona? perché il commento non sarebbe mai stato commentato?
phil294,

10
Quando si raddoppia il codice sorgente, /*viene commentato da //, il che significa che quanto segue i=1è senza commento. Questo è più facile da vedere se metti la versione raddoppiata del codice in un evidenziatore di sintassi
musicman523

1
Whoa, un trucco di definizione provvisoria. Bello.
aschepler,

39

Esagonia , 7 byte

/)!@.).

Stampa 1 regolarmente e poi 2 raddoppiato.

Provalo online! o provalo raddoppiato online!

Versioni estese:

Regolare:

 / )
! @ .
 ) .

raddoppiato:

  / ) !
 @ . ) .
/ ) ! @ .
 ) . . .
  . . .

Il programma normale segue il percorso: /)!.@che incrementa un fronte di memoria (tutti sono inizializzati a zero) quindi stampa il suo valore numerico. Segue il programma raddoppiato: /.)/)!@che invece aumenta il bordo due volte prima della stampa.


6
Wow bel lavoro. Presumo tu l'abbia trovato a mano? Dato che 6 byte sono nel campo della forza bruta, ho pensato di provarlo e in realtà c'è una soluzione a 4 byte: [@!)(e alcune 570 soluzioni a 5 byte). Dal momento che hai effettivamente avuto il problema di trovare una soluzione a mano, sono perfettamente felice che tu pubblichi la soluzione a 4 byte.
Martin Ender,

1
Se sei interessato, ecco l'elenco completo che include il numero stampato: pastebin.com/TtRujjA4
Martin Ender


36

Braingolf , 1 byte

+

Provalo online!

Ora stiamo parlando!

Output 20o 40quando la sorgente viene raddoppiata.

Spiegazione

+ è ovviamente l'operatore "sum", "add" o "plus", in Braingolf, tuttavia ha funzioni diadiche, monadiche e niladiche.

Quando ci sono almeno 2 oggetti nella pila, è diadico e sommerà i primi 2 oggetti della pila.

Quando c'è solo 1 oggetto in pila, è monadico e raddoppierà l'oggetto.

Quando non ci sono oggetti in pila, è niladico e spinge 20!

Perché spinge 20? Bene, perché un programma Braingolf vuoto stampa semplicemente una nuova riga e il valore ASCII di una nuova riga è 10, quindi ho pensato che avrei fatto niladic +push 20 quindi è come se fosse effettivamente monadico sulla nuova riga implicita (anche se non è in tutti)

Perciò:

+   No input
+   Niladic sum, Push 20
    Implicit output

E quando raddoppiato:

++  No input
+   Niladic sum, Push 20
 +  Monadic sum, Double top of stack
    Implicit output

28

Haskell , 26 18 byte

main=print$0
 +1--

Provalo online!

raddoppiato:

main=print$0
 +1--main=print$0
 +1--

Provalo online!

Ho trovato questa versione mentre rispondevo alla versione tripla della sfida .


Versione a 26 byte senza abuso di commenti:

main|n<-1,nmain<-2=print n

Provalo online! Stampe 1.

Nella protezione del motivo l'identificatore nè impostato su 1e nmainsu 2, quindi print nstampa 1.

Doppio programma:

main|n<-1,nmain<-2=print nmain|n<-1,nmain<-2=print n

Provalo online! Stampe 2.

Nel primo pattern guard nè di nuovo impostato su 1e nmainto 2, comunque l'istruzione print sia diventata print nmain, quindi 2viene stampata. Poiché le dichiarazioni degli identificatori in una protezione di motivi vengono valutate come vere, la seconda protezione di motivi non può mai essere raggiunta.


23

Mathematica, 5 byte

(1+1)

uscite 2 e (1 + 1) (1 + 1) uscite 4

e ovviamente (come molti di voi hanno chiesto)

Mathematica, 3 byte

(2)

1
Funziona (2)?
geokavel,

9
@geokavel 2e uno spazio funzionerebbero, così come +1dovrebbe essere notato che tutti questi presuppongono l'ambiente per notebook di Mathematica
Martin Ender,

1
Se si esegue nella OpenCloud Mathematica Sandbox, un unico spazio diventa x, in modo tale che 2 le uscite 2e 2 2 diventa 2x2 che le stampe 4. È possibile aggiungere che, come una soluzione alternativa.
Mr. Xcoder,

2
(2)funziona pure.
Mr. Xcoder,

6
2 funziona pure.
alephalpha,

17

Brain-Flak , 6 byte

({}())

Provalo online!

Spiegazione

Quello che fa dovrebbe essere abbastanza chiaro. {}prende un valore dallo stack, che implicitamente zero per cominciare, ne ()aggiunge uno e lo (...)spinge. Al secondo giro, dato che c'è già un 1 nello stack, questo ne aggiunge solo un altro per farne due. In effetti, se copi il codice nvolte, verrà sempre emesso n.


17

> <> , 7 6 byte

-1 byte grazie al pellicano Teal

\ln;
0

Provalo online!
Provalo raddoppiato!

Spiegazione

Ho usato un 0ma avrei anche potuto usare 1- 9, a- fperché tutti spingono un singolo valore nello stack.

Non raddoppiato:

\ redirects execution down
0 pushes zero onto stack; STACK: [0]
  (IP wraps around the bottom)
\ redirects execution right
l pushes stack length (1) onto stack; STACK: [0, 1]
n pops off the top value (1) and prints it; STACK: [0]
; end of execution

raddoppiato:

\ redirects execution down
0 pushes zero onto stack; STACK: [0]
0 pushes zero onto stack; STACK: [0, 0]
  (IP wraps around the bottom)
\ redirects execution right
l pushes stack length (2) onto stack; STACK: [0, 0, 2]
n pops off the top value (2) and prints it; STACK: [0, 0]
; end of execution

5
Benvenuti in PPCG! Questa è un'ottima prima risposta, con una spiegazione ben ponderata e un buon codice. Hai guadagnato il mio voto!
Mr. Xcoder,

1
Ho appena visto questa risposta ed è fantastico! Miglioramento molto bello sulla coppia> <> risposte (compresa la mia!) - Dai un'occhiata al link TIO qui; tio.run/##S8sszvj/PyYnz5rLAEL@/w8A - Tutto quello che ho fatto è spostare lo 0 nello spazio e salvare 1 byte. :)
Pellicano verde acqua

1
@Tealpelican Grazie! Non riesco a credere di aver perso un miglioramento così semplice. (In realtà posso, non uso molto> <> e sono nuovo nel golf!) Ad essere sincero, non ho davvero esaminato le altre soluzioni in dettaglio, ho visto che erano relativamente grandi e ho deciso di prova a golf il problema poiché sarebbe più facile competere.
Borka223,

1
Bella risposta! Volevo solo sottolineare che questo utilizza lo stesso metodo della mia risposta Klein . (Non ti accuso di avermi copiato Se qualcuno lo avesse fatto solo indicando due risposte simili.)
Sriotchilism O'Zaic,

14

Retina , 3 byte


1

Provalo online!

Stampe 2. Raddoppiando stampa 4.

Il 1può essere sostituito con praticamente qualsiasi altra cosa.

Spiegazione


1

Sostituisce l'input vuoto con 1.


Conta il numero di partite vuote in 1cui due (una prima 1e una dopo).

Se raddoppiamo il programma, otteniamo una fase aggiuntiva come la prima. Questa volta inserisce una 1prima e una dopo quella iniziale, dando 111. Quando ora contiamo il numero di corrispondenze della regex vuota ne otteniamo quattro.


14

Python REPL, 2 byte

Funziona anche in Pip, Dyalog APL, JavaScript, J e R

+1

Sto realizzando un TIO in questo momento non riesco a far sostituire Python per lavorare su TIO


1
+1è esattamente quello che farò: P ma dannazione, mi hai fatto ninja di circa un minuto> <
HyperNeutrino

1
Questo funziona anche in Dyalog APL.
Kritixi Lithos,


1
Non potresti usare questo e questo per un REPL?
totalmente umano il

1
Hai il mio +1.
Federico Poloni,

12

Neim , 1 byte

>

Aumenta semplicemente la parte superiore della pila.

Lo stack può essere immaginato come una quantità infinita di zero per iniziare, quindi questo incrementa lo zero per ottenerne uno, e raddoppia, lo incrementa di nuovo per ottenerne due.

Provalo online!

Una soluzione alternativa:

Aggiunge 2, anziché 1.



12

Java8, 135 118 110 byte

Singolo , stampa 8

interface T{static void main(String[]a){System.out.print(Byte.SIZE);}}/*
class Byte{static int SIZE=16;}/**///

Raddoppiato , stampa 16

interface T{static void main(String[]a){System.out.print(Byte.SIZE);}}/*
class Byte{static int SIZE=16;}/**///interface T{static void main(String[]a){System.out.print(Byte.SIZE);}}/*
class Byte{static int SIZE=16;}/**///

Risposta anteprime, 118 byte

Singolo , stampa 1

interface T{static void main(String[]a){System.out.print(T.class.getResource("B.class")==null?1:2);}}/*
enum B{}/**///

Raddoppiato , stampa 2

interface T{static void main(String[]a){System.out.print(T.class.getResource("B.class")==null?1:2);}}/*
enum B{}/**///interface T{static void main(String[]a){System.out.print(T.class.getResource("B.class")==null?1:2);}}/*
enum B{}/**///

Come funziona

Il compilatore java crea un singolo file per ogni classe nel file di origine. Quindi posso semplicemente verificare se esiste una risorsa con il nome B.class.


Risposta originale, 135 byte

Singolo , stampa 1

interface T{static void main(String[]a){int i=1;try{Class.forName("B");i=2;}catch(Exception e){}System.out.print(i);}}/*
enum B{}/**///

Raddoppiato , stampa 2

interface T{static void main(String[]a){int i=1;try{Class.forName("B");i=2;}catch(Exception e){}System.out.print(i);}}/*
enum B{}/**///interface T{static void main(String[]a){int i=1;try{Class.forName("B");i=2;}catch(Exception e){}System.out.print(i);}}/*
enum B{}/**///

Quello che hai fatto con il commento è davvero fantastico. Ma hai davvero bisogno della nuova linea?
vikarjramun,

Oh nvm, non ho notato il commento a riga singola sulla seconda riga
vikarjramun,

11

Python 2 , 32 byte

print open(__file__,"a").tell()#

Provalo online!

Doppio codice sorgente

Spiegazione

Questo apre il file del codice sorgente in modalità append

open(__file__,"a")

Troviamo quindi la posizione corrente nel file, questa sarà alla fine del file a causa dell'apertura in modalità append

open(__file__,"a").tell()

Stampiamo questa lunghezza

print open(__file__,"a").tell()

E aggiungi un commento, in modo che il raddoppio del codice sorgente non esegua più codice

print open(__file__,"a").tell()#

9

Excel VBA, 12 byte

Funzione finestra immediata VBE immediata che accetta input e output da range [A1]. Il valore predefinito dell'intervallo [A1]è ""(stringa vuota) e dopo un'esecuzione la seguente imposta 1e incrementa 1con tutte le esecuzioni successive.

[A1]=[A1+1]:

Input Output

Versione singola

[A1]=[A1+1]:
?[A1]    ''# display the value of [A1] to the VBE immediate window
 1

Versione raddoppiata

[A1]=[A1+1]:[A1]=[A1+1]:
?[A1]    ''# display the value of [A1] to the VBE immediate window
 2


8

Buccia , 3 byte

|1"

Provalo online!

Un'idea originale, per quello che ho visto in altre risposte.

Spiegazione

|in Husk è un operatore "o" che restituisce il suo secondo argomento se è sincero, altrimenti il ​​primo argomento. Se applicato ad argomenti di diverso tipo, li trasforma innanzitutto in numeri: la trasformazione per stringhe (e liste in generale) avviene calcolandone la lunghezza.

Nel programma originale applichiamo |1 e una stringa vuota, che viene convertita in 0: il risultato è 1.

Nel programma raddoppiato applichiamo |1 e la stringa "| 1", che viene convertita in 2: il risultato è 2.



7

CJam, 3 byte

5],

Provalo online

Incapsula 5 in array. Restituisce la lunghezza dell'array. Quando si duplica il codice, la lunghezza precedentemente restituita, 1, è già nello stack, quindi si ottiene una matrice di [1,5], che restituisce la lunghezza 2.



7

Wumpus , 4 byte

" O@

Provalo online!

" O@" O@

Provalo online!

Il codice normale viene stampato 32e quello raddoppiato viene stampato 64.

Spiegazione

"funziona come in molti altri Fungeoid: attiva o disattiva la modalità stringa, in cui ogni singolo codice carattere viene inserito nello stack, invece di eseguire il comando. Tuttavia, a differenza della maggior parte degli altri Fungeoid, il campo di gioco di Wumpus non si avvolge, quindi l'IP rifletterà invece la fine e rimbalzerà avanti e indietro attraverso il codice.

Quindi, per il singolo programma, viene effettivamente eseguito il seguente codice:

" O@O " O@

La corda spinge 32, 79, 64, 79, 32. Quindi lo spazio non fa nulla, le Ostampe 32e @il programma termina.

Per il programma raddoppiato, la stringa viene invece terminata prima che l'IP ritorni indietro, quindi il codice viene attraversato una sola volta:

" O@" O@

Questa volta, la stringa spinge 32, 79, 64, Ostampa il 64e @termina il programma.

Questa sembra essere l'unica soluzione a 4 byte.


6

,,, 2 byte

1∑

Spiegazione

1∑

1   push 1
 ∑  pop everything and push the sum of the stack

Mi sto perdendo qualcosa o non sarebbe 3 per un codice sorgente raddoppiato?
Taylor Scott,

@TaylorScott Mi dispiace, avrei dovuto notare che fa saltare tutti gli elementi nello stack.
totalmente umano il

1
Questo ha molto più senso - grazie per il chiarimento
Taylor Scott,

Sigma è di due byte, no?
nishantjr,

1
@nishantjr ,,, usa la propria codepage, che è collegata nell'intestazione.
totalmente umano il

6

Lotto, 13 byte

@echo %~z0
:

Spiegazione: si %~z0espande alla lunghezza del file sorgente, quindi raddoppiare il file raddoppia semplicemente la lunghezza. La seconda riga definisce un'etichetta vuota, che non fa nulla. Quando il file viene raddoppiato, diventa @echo %~z0invece un'etichetta denominata , mentre la terza riga è un'altra etichetta vuota.


6

QBasic,  44  28 byte

Non c'è newline alla fine. Emette 4quando è singolo, 8quando raddoppia.

4
READ x,y
?x+y
END
DATA 4,0

Spiegazione

Per la versione singola:

  • 4 è un numero di riga.
  • READ x,yprende i primi due valori DATAdall'istruzione e li memorizza in xe y. Quindi, xottiene 4e yottiene 0.
  • ?x+y aggiunge i due numeri e li stampa.
  • END esce dal programma.

Nella versione raddoppiata, la DATAdichiarazione diventa DATA 4,04, che assegna 4ad entrambi xe y, rendendo così x+yuguale 8invece.


6

Befunge-98 , 5 byte

90g.@

Provalo online!

gottiene il valore del carattere alla coordinata (9, 0) in Funge-Space; .lo stampa come un numero intero e @interrompe il programma. Nella versione non raddoppiata, (9, 0) non rientra nei limiti del programma e Funge-Space all'esterno del programma viene inizializzato al valore predefinito di uno spazio, quindi stampiamo 32. Nella versione raddoppiata, (9, 0) è il @personaggio, quindi stampiamo 64.


Non era quello che mi aspettavo che la migliore risposta di Befunge-98 fosse ... una risposta davvero creativa!
MildlyMilquetoast


Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.