La sfida

Scrivere un programma completo che scriva nell'output standard il doppio dei byte rispetto alla lunghezza del programma.

Regole

• Il programma deve scrivere caratteri ASCII nell'output standard.

• Il contenuto dell'output non ha importanza.

• L'output, misurato in byte, deve essere esattamente il doppio della lunghezza del programma, anch'esso misurato in byte, a meno che non si realizzi il bonus.

• Qualsiasi nuova riga finale è inclusa nel conteggio byte dell'output.

indennità

Il tuo programma può facoltativamente prendere un numero n, come input. In tal caso, l'output deve essere esattamente di n * program lengthbyte. Puoi presumere che n sarà sempre un numero intero positivo. Se non viene fornito alcun input, il nvalore predefinito è 2.

Se lo fai, puoi sottrarre 25 byte dal tuo punteggio.

Vince il programma più breve.

restrizioni

• Nessuna scappatoia standard.

• Il programma deve essere lungo almeno 1 byte.

• Non è necessario aggiungere spazi bianchi non necessari al codice sorgente per modificarne la lunghezza. Allo stesso modo, i commenti non contano.

• A meno che non si adempia al bonus, il programma non deve accettare input. Se realizzi il bonus, l'intero deve essere l'unico input.

Il punteggio più basso (durata del programma in byte - bonus) vince.

La risposta più breve per ogni lingua vince per quella lingua .

Classifiche

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, utilizzando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

# Perl, 43 + 2 (-p flag) = 45 bytes

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

var QUESTION_ID=59436,OVERRIDE_USER=41505;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\-?\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\-?\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

HQ9 + , 2 byte

QQ

uscite

QQQQ

Penso che non sia proibito qui.

Shakespeare, 768

Sì, Shakespeare non è molto un linguaggio da golf. Produce 1.536 spazi.

Rosencrantz and Guildenstern: A Series of Tedious Events.

Rosencrantz, a count of extraordinary determination.
Guildenstern, a spacy character.

Act I: The Long Conversation

Scene I: A Tortured Friendship

[Enter Rosencrantz and Guildenstern]

Rosencrantz:
 You are a gentle, noble, valiant, loyal, loving companion.

Guildenstern:
 You are nothing!

Scene II: Asking the Hard Questions

Rosencrantz:
 Speak your mind.

Guildenstern:
 You are as fair as the sum of yourself and a daisy. Are you as
 daring as the sum of a big, bold, fiery, feisty, rough, rowdy,
 ham-fisted, hawk-eyed, broad-shouldered, bright-eyed lad and a
 large, yellow, vicious, hairy, wild, scary, long-tailed,
 sharp-clawed, small-eared lion?

Rosencrantz:
 If not, let us return to scene II.

Modifica: 256

Okay, lo giocherò davvero. Nota che quanto sopra non viene compilato in nessuna implementazione esistente di Shakespeare perché l'ho scritto scrupolosamente a mano (ma sono pronto a difenderne la correttezza).

Quanto segue si traduce in C con un avviso in spl-1.2.1 e genera 512 spazi:

Ummm.Ajax,1.Puck,2.Act I:I.Scene I:A.[Enter Ajax and Puck]Ajax:You old old old old old cow.Puck:You are zero!Scene II:B.Ajax:Speak thy mind.Puck:You are the sum of you and a red cat.Are you as big as the square of me?Ajax:If not, let us return to scene II.

Richiama, 17 byte

................!

16 NOOP. Quindi !viene richiamato il debugger e scarica la memoria sulla console. La memoria è vuota, ma l'intestazione è lunga 34 byte:

-- STATE DUMP --
----------------

Provalo qui .

Mathematica REPL, 1 byte

#

Stampe #1.

CJam, -17 byte

r2e|i8,*

Il codice sorgente è lungo 8 byte e si qualifica per il bonus di -25 byte .

Provalo online nell'interprete CJam .

Come funziona

r         e# Read a token from STDIN.
 2        e# Push 2.
  e|      e# Logical OR; keep the token if it's not empty, 2 otherwise.
    i     e# Cast to integer.
     8,   e# Push [0 1 2 3 4 5 6 7].
       *  e# Repeat the array the corresponding number of times.

Python 2.6, 10

print`-.1`

Stampe -0.10000000000000001, che è di 20 caratteri.

Si noti che la stringa repr mostra più precisione. print-.1dà solo -.1e print.1/3dà 0.0333333333333solo 13 cifre di precisione.

Seme , 10 byte

4 56111240

Questo si compila al programma Befunge (trovato dalla forza bruta)

9k.@

che produce i seguenti 20 byte durante l'esecuzione (testato in CCBI, notare lo spazio finale):

0 0 0 0 0 0 0 0 0 0 

Non avendo familiarità con Befunge 98, ho dovuto ricontrollare le specifiche alcune volte per questo:

• k mi sembra abbastanza rotto, eseguendolo ancora una volta del previsto a causa del passaggio dell'IP nelle istruzioni ripetute
• Le pile di Befunge 98 hanno zero infiniti in fondo
• . genera un numero, seguito da uno spazio

R, 3 2 byte

Codice

!0           # NOT FALSE

Uscite

TRUE

Caspita, finalmente R, finalmente.

Sembra che {}funzioni anche, produceNULL

Bonus 33 16 byte:

Codice

rep(1,number*16)

Uscite

# if number is not defined
> rep(1,number*16)                     
> Error: object 'number' not found     # output is 32 (or 2*16) bytes long error

# if number is defined
> number = 3                            
> rep(1,number*16)                     # output is 16*number bytes long
> 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

Matlab, 7 5 byte

2 byte in meno grazie a @flawr!

123;3

Produzione:

L'output contiene , quindi 10 byte.newline ans = newline newline 3 newline

JavaScript, 2 byte!

Anche più breve della soluzione a 3 byte:

!0

Ritorna truedopo l'esecuzione.

Python 2, 11

print`id`*1

Stampa la rappresentazione di stringa del built-in id, che è di 22 caratteri:

<built-in function id>

Il *1è quello di ottenere il codice a 11 caratteri. Potresti anche fare print id;00.

11 alternative più noiose sono:

print'1'*22
print 9**21

dc, 10-25 = -15

2?A*Ar^1-n

Prende una riga vuota per "nessun input".

Calcola 10 ^ (10 * n) - 1, dove n è l'input o 2 se l'input è vuoto. Stampa una stringa di 9s della lunghezza richiesta.

• 2 spingere 2 nello stack nel caso in cui l'ingresso sia vuoto
• ? spingere l'input nello stack
• Aspingere 10 nello stack (dc ha scorciatoie A- Fper 10-15)
• * pop due volte e moltiplicare (moltiplicare input per 10)
• A spingere 10 nello stack
• r inverti i due elementi superiori della pila
• ^ esponente 10 ^ (10 * input)
• 1- sottrarre 1 dalla parte superiore della pila
• n stampa senza newline.

TI-Basic, 3 byte

1ᴇ5

Stampe 100000.

Brainfuck, 14 byte

+++++++[....-]

Questo è un piccolo esercizio matematico. Indichiamo il numero di +caratteri nel codice per ae il numero di .caratteri per b.

Il codice genera a*bbyte, con valori da agiù a 1(sono byte non ASCII, ma sembra OK secondo le specifiche). La lunghezza del codice è a+b+3. Quindi abbiamo

a*b = 2 * (a+b+3)

Provando valori diversi per ae b, vediamo che a+b+3viene raggiunto il minimo per

a = 4       or       a = 7
b = 7                b = 4

gs2 , -18 byte

CP437 :W↕0!↨.2

Discarica esadecimale: 57 12 30 21 17 2e 32

Wlegge i numeri da STDIN in un elenco. ↕0aggiunge un 2 all'elenco ed !estrae il primo elemento. Quindi ↨.(l'elenco [0,1,2,3,4,5,6]) viene ripetuto ( 2) molte volte.

Questo è molto simile alla risposta CJam di Dennis: gs2 combina re si itrasforma in un byte.

Nota : ho dovuto correggere un bug gs2nell'implementazione affinché funzionasse: in precedenza, ogni programma aveva una riga nascosta aggiunta al suo output, che era del tutto involontario. È emerso solo dopo che ho provato a risolvere questo programma (il linguaggio è stato progettato per il golf dell'anarchia, che ignora le nuove linee finali in tutti i problemi), e ho spinto solo una correzione per padroneggiare ora, quindi sentiti libero di prendere questa risposta con un granello di sale.

Perl 5, 16 byte - 25 = -9

$_ =$]x($_*2||4)

Questo è un approccio strano al problema.

Esegui con l' -pargomento della riga di comando.

Di seguito ho visto una risposta Perl che utilizzava una variabile speciale per stampare più testo e quindi ridurre il numero di byte. Quindi ho usato una variabile speciale molto più dettagliata. Stampa 8 caratteri con un nome variabile di 2 caratteri. Pertanto, con un numero di byte di 16 (riempito con un carattere di spazio bianco per renderlo 16), stampa 2 * $], dove $]viene stampata la versione Perl 5.xxxxxx, a seconda della versione Perl. Senza input, lo stampa quattro volte, eguagliando 8*4o 32, che è il doppio del numero di byte del codice.

Adoro il Perl.

Pyth , 10 9 - 25 = -16

-1 di Dennis

**N9?zvz2

Stampa [input] * 9 caratteri di virgolette o 2 * 9 se l'input è vuoto.

isaacg ha una risposta più breve qui

Pyth , 1 byte

T

Stampe 10. È una variabile integrata che viene inizializzata su 10.

Maccheroni 0.0.2 , 23 caratteri

print tobase pow 32 9 2

Stampa 32 ⁹ in binario, che risulta convenientemente lungo 46 caratteri (è 1000000000000000000000000000000000000000000000), senza una nuova riga finale.

JavaScript, 4 byte

~$ cat main.js
+1/0
~$ nodejs main.js
Infinity

Penso che questa sia la soluzione JS più breve possibile senza ES6: P

C, 27 25

main(){printf("%50f",0);}

• Grazie @Titus per aver eliminato 2 byte

E per la mia soluzione non competitiva a 16 byte in C, vai qui: https://codegolf.stackexchange.com/a/111330/16513

^ Dico non competitivo perché il codice di errore potrebbe dipendere dal tuo compilatore, nota anche che sto usando GCC in quella soluzione. Inoltre non sono sicuro che infrange o meno la regola 1, penso che probabilmente lo faccia, quindi sono andato avanti e l'ho etichettato come non competitivo

V , 2 byte

4é

Questo produce

ÿÿÿÿ

Provalo online!

Spiegazione

Questa è una risposta davvero confusa e funziona abusando degli interni di V. Essenzialmente funziona come ÿun comando in V che segnala che il programma è finito e che tutti i comandi in sospeso devono essere completati. Altrimenti, alcuni finali impliciti non funzionerebbero e l'interpretazione si bloccherebbe più spesso. Questo comando viene inviato automaticamente più volte alla fine del programma e la maggior parte delle volte non ha alcun effetto sull'output.

éè un comando che inserisce un singolo carattere. Tuttavia, lo fa afferrando un byte non elaborato, quindi non interpreta ÿ"fine", lo interpreta come "questo è il carattere che devi inserire". 4élo fa inserire questo personaggio 4 volte invece di uno.

bash, 11 byte

Ecco un uso piacevolmente ironico di uno strumento di compressione dei dati :) ...

gzip -f<<<2

Ecco un dump esadecimale dell'output (22 byte) ...

0000000: 1f 8b 08 00 e3 ce 32 59 00 03 33 e2 02 00 90 af  ......2Y..3.....
0000010: 7c 4c 02 00 00 00                                |L....

dc, 19-25 = -6

2?19*[1n1-d0<l]dslx

Prende un numero (2 viene inserito nello stack come backup) e lo moltiplica per 19. Stampa un 1(nessuna nuova riga) e diminuisce il numero. Cicli mentre il numero è maggiore di 0.

C ++, 80 byte

#include<iostream>
int main(){int i=0;while(i<20){std::cout<<&i;i++;}return 0;}

si noti che il carattere di nuova riga è di due caratteri. (se non vuoi che sia, cambia i <20 in i <= 19 per tornare allo stesso numero di byte.)

Output del campione (cambierà ogni volta)

0088FA0C0088FA0C0088FA0C0088FA0C0088FA0C0088FA0C0088FA0C0088FA0C0088FA0C0088FA0C0088FA0C0088FA0C0088FA0C0088FA0C0088FA0C0088FA0C0088FA0C0088FA0C0088FA0C0088FA0C

stesso indirizzo di memoria di 8 caratteri 20 volte.

CJam, -9

q_,{i}{;2}?G*'X*

Spiegazione

• q_,

Legge l'intero input e lo spinge, quindi spinge la lunghezza.

• {i}{;2}?

Se la lunghezza dell'input è superiore a zero, convertirla in un numero intero. Altrimenti, inserire l'ingresso e premere 2.

• G*

Spinge 16 (la lunghezza del programma), quindi lo moltiplica per 2 se non c'è input o per input.

• 'X*

Spinge X e lo moltiplica per la parte superiore della pila.

> <> , 19 + 2 (-v flag) - 25 = -4 byte

l?!2f4+*v
-1o;!?::<

provalo qui!

Grazie Cole e Sp3000

Per prima cosa controlla la lunghezza dello stack, se è 0 metti 2 nello stack. Lo moltiplica per 21 (lunghezza del codice), quindi genera la rappresentazione unicode di quel numero e lo decrementa di 1, scorre fino a 0. (dovrete ispezionare l'output per vedere i caratteri, poiché il browser non li visualizza)

JavaScript (ES5), 68 byte - 25 bonus = 43

alert(Array(1+(+prompt()||2)).join(document.scripts[0].textContent))

(nel caso in cui il tuo browser non consenta l'esecuzione dello snippet per motivi di sicurezza, prova questo violino http://jsfiddle.net/thePivottt/c3v20c9g/ )

Questo script funziona solo in un browser che segue almeno DOM3 (con Node.textContent) ed ECMAScript 5 (o forse una versione precedente). Ho provato a rendere il più standard possibile e compatibile. Presuppone inoltre che lo script sia nel primo scriptelemento del documento.

In realtà concatena più copie dello script stesso, il che è piuttosto fantastico . Si noti che lo strumento frammento su SE aggiunge spazi bianchi extra allo script. Potremmo ignorare quello spazio bianco con .trim()ma non lo trovo necessario considerando che il programma è perfetto senza l'ingerenza di SE. Basta salvare questo file HTML5 se si desidera vederlo funzionare perfettamente.

<!DOCTYPE html>
<html>
  <head>
    <title>Minimalist HTML5 page</title>
    <script>alert(Array(1+(+prompt()||2)).join(document.scripts[0].textContent))</script>
  </head>
</html>

Questo script utilizza prompte alertperché console.lognon fa parte di alcuno standard, anche se viene utilizzato dalla maggior parte dei browser moderni. Se il numero di ripetizioni passate non è un numero valido o è vuoto, il valore predefinito è 2. Se l'input è un numero decimale, il programma si arresta in modo anomalo a causa della lunghezza dell'array non valida.

Il codice utilizza alcune interessanti funzionalità di JavaScript:

• Array(1+(+prompt()||2))

  • Array(INT) crea una matrice di celle INT.

  • +prompt()accetta un input e lo trasforma in un numero. Se passassimo l'input come stringa, la Arrayfunzione lo avvolgerebbe semplicemente in un array a un elemento.

  • +prompt()||2restituisce l'input se è vero , altrimenti restituisce 2.

  • Questo intero codice crea una matrice di N elementi vuoti, dove N è uno in più rispetto alla quantità di ripetizioni richieste.

• .join(document.scripts[0].textContent)

  • Il join(STRING)metodo dell'array crea una stringa concatenando tutte le celle, mettendo la STRING fornita tra i valori. In questo programma, ci sono N + 1 elementi vuoti nell'array o esattamente N tra i punti. Il risultato sarà una stringa contenente N volte la STRING fornita.

  • document.scripts[o]è il primo <script>elemento del documento.

  • L' istanza di textContentof Noderestituisce l'intero testo trovato al loro interno e i relativi nodi figlio, inclusi gli script.

JavaScript ES6, 33-25 = 8

(a=2)=>Array(a*33).fill(0).join``

Provalo online!

Julia, 42 byte - 25 = 17

print("@"^42((r=readline())>""?int(r):2))

Questo legge una riga da STDIN usando readline(). Se è vuoto, ovvero non è stato fornito alcun input, allora n è definito come l'input convertito in un numero intero. In caso contrario, n è 2. Abbiamo poi stampiamo 42 n @ s a STDOUT.

Perl, 18-25 = -7

print$=x(<>*9||18)

La variabile speciale $=, aka $FORMAT_LINES_PER_PAGE, inizia la sua vita come 60, e quindi deve essere duplicata solo la metà del numero di byte necessari.