97

In questa sfida, è necessario scrivere un programma o una funzione che non accetta input e stampa o restituisce una stringa con lo stesso numero di byte del programma stesso. Ci sono alcune regole:

È possibile emettere solo byte nell'intervallo ASCII stampabile (da 0x20 a 0x7E, inclusi) o newline (0x0A o 0x0D).
Il tuo codice non deve essere un quine, quindi il codice e l'output devono differire in almeno un byte.
Il codice deve essere lungo almeno un byte.
Se l'output contiene nuove righe finali, queste fanno parte del conteggio dei byte.
Se il codice richiede flag della riga di comando non standard, contarli come al solito (ovvero aggiungendo la differenza a una chiamata standard dell'implementazione della propria lingua al conteggio dei byte) e la lunghezza dell'output deve corrispondere al punteggio della soluzione. Ad esempio, se il tuo programma è abe richiede un flag non standard -n(supponiamo che non possa essere combinato con flag standard, quindi è di 3 byte), dovresti generare 5 byte in totale.
L'output non deve sempre essere lo stesso, purché sia possibile dimostrare che ogni output possibile soddisfa i requisiti di cui sopra.
Non si applicano le normali regole di quine . Potresti leggere il codice sorgente o le sue dimensioni, ma dubito che questo sarà più breve del codificarlo nella maggior parte delle lingue.

È possibile scrivere un programma o una funzione e utilizzare uno dei metodi standard per fornire output. Notare che se si stampa il risultato, è possibile scegliere di stamparlo sull'output standard o sul flusso di errori standard, ma solo uno di questi conta.

È possibile utilizzare qualsiasi linguaggio di programmazione , ma si noti che queste scappatoie sono vietate per impostazione predefinita.

Questo è code-golf , quindi la risposta valida più breve - misurata in byte - vince.

Classifica

Mostra snippet di codice

var QUESTION_ID=121056,OVERRIDE_USER=8478;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){var F=function(a){return a.lang.replace(/<\/?a.*?>/g,"").toLowerCase()},el=F(e),sl=F(s);return el>sl?1:el<sl?-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>

Espandi frammento

code-golf self-referential

— Martin Ender
fonte

2

Relazionato. Relazionato.

— Martin Ender,

18

"Il tuo codice non deve essere un quine" ma ... ma ... è taggato quine

— Okx,

4

@Okx Perché è un quine generalizzato, ovvero l'output richiesto dipende dal codice sorgente.

— Martin Ender,

4

@MartinEnder Probabilmente dovresti impedire l'output in base al codice di uscita, che è un valore predefinito. Se lo consenti, è consentito quasi ogni programma a un byte in quasi ogni lingua. Un utente lo ha già fatto

— Wheat Wizard

2

L'output di @WheatWizard per codice di uscita non è una stringa, quindi non si applica qui.

— Martin Ender,

204

C (Linux moderno), 19 byte

main(){puts('s');}

Quando compilato ed eseguito, questo stampa:

Segmentation fault

— MD XF
fonte

20

Questo è geniale: D

— Beta Decay

4

questo è più simile a "C + inglese unix / posix OS;)"

— Florian Castellane,

5

Penso che sarebbe meglio scrivere "C, Linux moderno" piuttosto che "C": sotto Windows il messaggio di errore è diverso e ai vecchi tempi i programmi Linux venivano persino compilati in modo che l'indirizzo 0x73 ('s') fosse leggibile quindi non è stata causata alcuna eccezione.

— Martin Rosenau,

9

Mi sono iscritto al sito solo per votare questa risposta.

— Nitish,

7

Per quanto impressionante sia, non è proprio il programma C che stampa l'output, ma la shell è in esecuzione.

— Dennis

80

Excel, 11 byte

Versione in lingua norvegese:

=SMÅ(13^9)

Versione in lingua inglese (12 byte):

=LOWER(17^9)

Genera un numero di n cifre e lo converte in testo convertendolo in minuscolo.

— Pajonk
fonte

106

Questo dà un significato completamente nuovo a "scegliere la lingua giusta per il lavoro".

— Martin Ender,

4

Questa è una grande idea. Sarebbe più breve da fare =9^7&""che genera un numero di 7 cifre in entrambe le lingue ed è di soli 7 byte.

— OpiesDad,

@OpiesDad Bella soluzione, penso che dovresti pubblicarla come risposta, così posso votare.

— pajonk,

4

@MartinEnder Mi diverte come la tua speculazione / potenziale battuta sia più votata di questa risposta (anche se è vicina).

— HyperNeutrino,

55

Labirinto , 4 byte

!!>@

Provalo online!

stampe 0000

Spiegazione

!   Print an implicit 0 from the stack.
!   Print an implicit 0 from the stack.
>   Rotate the source code right by one cell, so the code now becomes

    @!!>

    The IP is moved along, so it's now at the end of the line, which is 
    a dead end. So the IP turns around and starts moving left.
!   Print an implicit 0 from the stack.
!   Print an implicit 0 from the stack.
@   Terminate the program.

— Martin Ender
fonte

6

È troppo intelligente. Prendi un +1, in casa!

— caird coinheringaahing

54

Bash (solo builtin), 8 byte

{e,,}cho

Stampe cho choe una nuova riga.

— Anders Kaseorg
fonte

40

Retina , 2 byte

no

Provalo online!

Stampe 0e un avanzamento riga.

Esistono molte soluzioni a 2 byte, ma credo che sia ottimale. Retina di default stampa sempre una nuova riga finale e la sua eliminazione richiede troppi byte. Quindi dovremmo trovare un programma a 1 byte che lascia invariato l'input vuoto. Credo che l'unico programma che lo fa sia il programma contenente un singolo avanzamento di riga, che è quindi uguale all'output e quindi non consentito dalla sfida.

La prossima cosa più semplice da fare è vivere con Retina emettendo una singola cifra (il numero di corrispondenze di una regex rispetto all'input vuoto), e possiamo farlo con molti schemi a 2 byte non riusciti (o corrispondenti).

— Martin Ender
fonte

27

+1 Per il codice che mi dice di non eseguirlo: P

— Christopher,

33

Mathematica, 2 byte

4!

fattoriale

24

— J42161217
fonte

1

Gah! troppo intelligente.

— Tuskiomi,

2

battimi! +1. ( Penso che dovresti menzionare che questo è nella versione REPL di Mathematica.)

— Greg Martin,

Se questa è una risposta ragionevole, la risposta "1" non sarebbe anche una risposta ragionevole? (Inserendo '1' nel REPL di Mathematica si restituirebbe anche '1' ...)

— Mark Segal,

3

@MarkSegal Questo violerebbe la regola del no-quine.

— AlexR

6

Regole: ... "... il codice e l'output devono differire in almeno un byte"

— J42161217

29

C, 20 byte

f(){printf("%20d");}

Emette un numero, riempito con spazi per una lunghezza di 20. (Quale numero? Qualunque cosa accada dopo in memoria.)

Alcuni esempi vengono eseguiti sul mio sistema:

llama@llama:...code/c/ppcg121056samelen$ ./a.out 
           -666605944
llama@llama:...code/c/ppcg121056samelen$ ./a.out 
          -1391039592
llama@llama:...code/c/ppcg121056samelen$ ./a.out 
           1727404696
llama@llama:...code/c/ppcg121056samelen$ ./a.out 
             10717352
llama@llama:...code/c/ppcg121056samelen$ ./a.out 
           1485936232

È un peccato che l'output non possa essere byte arbitrari, perché ciò avrebbe consentito questa soluzione a 19 byte:

f(){write(1,f,19);}

che genera 19 byte di posta indesiderata, iniziando fdall'indirizzo.

— Maniglia
fonte

Sono contento di vedere una risposta che utilizza la regola dell'output variabile. :)

— Martin Ender,

Non è possibile questo segfault?

— Daniel,

Dov'è il / i link TIO?

— CalculatorFeline

@Daniel No, il numero stampato verrà dal precedente contenuto del %esiregistro.

— Maniglia della porta

8

@Doorknob ma è ancora un comportamento indefinito, quindi un compilatore più sadico potrebbe fare qualcosa di completamente diverso qui

— Sarge Borsch,

29

Bash su Linux, 6

uname

(seguito da una nuova riga)

Uscite Linuxseguite da una nuova riga.

— Trauma digitale
fonte

2

Tecnicamente unamenon è un build bash - è un eseguibile separato

— Jason Musgrove

-1, e in realtà un builtin

— GammaFunction

@GammaFunction Dove vedi unameun built-in bash? Ogni distro su cui posso mettere le mani adesso è un binario separato, incluso TIO . Viceversa, come mostra la risposta collegata, umaskè incorporato in quasi tutte le shell.

— Trauma digitale il

Io non vedo unamecome incorporato. Quando ho detto "-1, e in realtà un builtin", intendevo "Questa risposta usa umaskper -1 byte ed umaskè in realtà un builtin".

— GammaFunction

@GammaFunction Ci dispiace - ho frainteso il significato di "-1" nel tuo commento - Sono abituato a questi significati downvote e un commento che spiega il perché.

— Trauma digitale il

27

Javascript ES6, 9 byte

Utilizzo delle stringhe modello

_=>`${_}`

f=

_=>`${_}`

console.log(f());
console.log(typeof f());

Espandi frammento

— Weedoze
fonte

È undefinedconsiderata una stringa?

— Shaggy,

3

@Shaggy Vedi la modifica. Sto usando l'interpolazione di stringhe

— Weedoze

Caspita, questo è il mio secondo post su PPCG e 14 voti positivi! Grazie

— Weedoze

1

Perché semplice siero di latte si può avere difficile? (_=>_+'').

— GOTO 0

1

@ GOTO0 Oh ok tieni la parentesi. Questa è un'altra opzione. Personalmente preferisco il mio hehe

— Weedoze

24

Schema piramidale , 74 43 42 byte

Risparmiato 31 byte grazie a Khuldraeseth na'Barya! Salvato 1 byte grazie alla soluzione riprogettata di JoKing!

  ^
 /^\
^---^
-^ ^-
 -^-
 /2\
/ 8 \
-----

Provalo online! Emette il numero di 41 cifre 28^28 = 33145523113253374862572728253364605812736, seguito da una nuova riga finale.

Vecchia versione

  ^
 / \
/out\
-----^
    /^\
   ^---^
  /1\ /9\
 /606\---
/51015\
-------

Provalo online!

Uscite 71277303925397560663333806233294794013421332605135474842607729452115234375= 160651015 ** 9, o circa 10 ⁷⁴ .

— Conor O'Brien
fonte

6

Ehi, stai cercando di vendere la tua lingua? In tal caso, sei in arresto. - The Cops

— NoOneIsHere

2

@NoOneIsHere perdono?

— Conor O'Brien,

3

Siamo spiacenti, si chiama Pyramid Scheme, che è anche il nome di un tipo di truffa.

— NoOneIsHere il

1

ohhhhhhhhhhhh rofl

— Conor O'Brien,

1

L'output implicito ti porta a 43 byte .

— Khuldraeseth na'Barya, il

23

Python 2 , 9 byte

print{+1}

Questo stampa set([1])e un avanzamento di riga.

Provalo online!

— Dennis
fonte

11

Dai programmi di forzatura bruta a partire da print, non ci sono soluzioni più brevi e gli unici 9 byte sono varianti di questo e di Luis Mendo print 1e5 .

— xnor

23

Python 2 , 9 byte

print 1e5

L'output visualizzato contiene una nuova riga finale.

Provalo online!

— Luis Mendo
fonte

Le nuove righe finali contano come carattere per l'output? Altrimenti, questo stampa otto byte.

— OldBunny2800,

@ OldBunny2800 Sì, la sfida dice Se l'output contiene nuove righe finali, queste fanno parte del conteggio dei byte . Comunque, lo chiarirò nella mia risposta

— Luis Mendo,

18

Brainfuck , 25 byte

--[-->+<]+++++[->-.....<]

Provalo online! Nota: richiede un'implementazione con celle senza segno a 8 bit

Produzione:

~~~~~}}}}}|||||{{{{{zzzzz

Spiegazione

--[         254
 -->+<]      /2 = 127 into the second cell
+++++[      Five times
 ->-.....<]  Print the second cell - 1 five times

— Zack C.
fonte

4

Esistono molte variazioni BF come un nastro a celle a 8 bit. o un nastro limitato e celle infinite. Sono abbastanza sicuro che il tuo sia un modello di cella a 8 bit senza segno, ma penso che sarebbe bello se lo includessi nella tua risposta.

— Roman Gräf,

@ RomanGräf Un buon punto! Di solito includo tali informazioni se è richiesta un'implementazione non standard. Questa risposta dovrebbe funzionare su qualsiasi implementazione standard (celle senza segno a 8 bit, qualsiasi nastro), ma aggiungerò una nota per chiarire.

— Zack C.

Non potresti avere un programma da 1 byte .che stampa il NULLcarattere non stampabile ?

— Graviton,

@Graviton Ciò violerebbe la prima regola di questa sfida. Tuttavia, questa è una soluzione valida in un derivato BF che viene impostato automaticamente su un valore stampabile (vedi: la mia risposta brainbool ).

— Zack C.,

24 byte

— Jo King

16

C (Ideone), 14 byte

f(){warn(0);}

Su Ideone , che nomina il suo eseguibile prog, questo genera il seguente con una nuova riga finale.

prog: Success

C (GCC), 15 byte

f(){warn(00);}

Poiché GCC scrive un eseguibile denominato a.outper impostazione predefinita (in assenza di flag aggiuntivi che costerebbero byte), ciò genera quanto segue con una nuova riga finale.

a.out: Success

— Anders Kaseorg
fonte

7

@MDXF Le specifiche indicano il programma o la funzione, quindi l'invio di una funzione è perfettamente valido. Dal momento che il nome del file non è scelto dall'utente qui (sia Ideone che gcc hanno impostazioni predefinite), penso che vada bene (opinione personale).

— Dennis,

15

C (gcc) , 18 17 byte

f(){puts('@C');}

Nota che c'è un byte STX ( 0x02 ) tra @e C.

Provalo online!

portabilità

Questo è stato testato con gcc 6.3.1 e clang 3.9.1 su Fedora 25, gcc 4.8.4 su Ubuntu 14.04.4 e gcc 4.8.3 su openSUSE 13.2, dove stampa il seguente output.

inux-x86-64.so.2

Mi aspetto che questo produca lo stesso output con tutte le versioni di gcc, purché si compili in un eseguibile del seguente tipo.

ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2

Piattaforme diverse richiedono un indirizzo di memoria diverso e possibilmente un ordine diverso per i byte nella costante di carattere multi-carattere.

Ad esempio, sostituendo @\2Ccon @\2\4stampe exec/ld-elf.so.1e una nuova riga su FreeBSD 11 con clang 3.8.0.

Verifica offline

$ printf "%b\n" "f(){puts('@\2C');}main(){f();}" > quine.c
$ gcc -w -o quine quine.c
$ ./quine
inux-x86-64.so.2
$ ./quine | wc -c
17

Come funziona

Per impostazione predefinita, ld utilizza 0x400000 come indirizzo di base del segmento di testo, il che significa che possiamo trovare il contenuto dell'ELF a partire dall'indirizzo di memoria 0x400000 .

I primi 640 byte dell'ELF sono in gran parte indipendenti dal codice sorgente effettivo. Ad esempio, se la dichiarazione di f è seguita da main(){f();}e nient'altro, appaiono come segue.

00000000: 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00  .ELF............
00000010: 02 00 3e 00 01 00 00 00 00 04 40 00 00 00 00 00  ..>.......@.....
00000020: 40 00 00 00 00 00 00 00 e8 19 00 00 00 00 00 00  @...............
00000030: 00 00 00 00 40 00 38 00 09 00 40 00 1e 00 1b 00  ....@.8...@.....
00000040: 06 00 00 00 05 00 00 00 40 00 00 00 00 00 00 00  ........@.......
00000050: 40 00 40 00 00 00 00 00 40 00 40 00 00 00 00 00  @.@.....@.@.....
00000060: f8 01 00 00 00 00 00 00 f8 01 00 00 00 00 00 00  ................
00000070: 08 00 00 00 00 00 00 00 03 00 00 00 04 00 00 00  ................
00000080: 38 02 00 00 00 00 00 00 38 02 40 00 00 00 00 00  8.......8.@.....
00000090: 38 02 40 00 00 00 00 00 1c 00 00 00 00 00 00 00  8.@.............
000000a0: 1c 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00  ................
000000b0: 01 00 00 00 05 00 00 00 00 00 00 00 00 00 00 00  ................
000000c0: 00 00 40 00 00 00 00 00 00 00 40 00 00 00 00 00  ..@.......@.....
000000d0: 04 07 00 00 00 00 00 00 04 07 00 00 00 00 00 00  ................
000000e0: 00 00 20 00 00 00 00 00 01 00 00 00 06 00 00 00  .. .............
000000f0: 08 0e 00 00 00 00 00 00 08 0e 60 00 00 00 00 00  ..........`.....
00000100: 08 0e 60 00 00 00 00 00 1c 02 00 00 00 00 00 00  ..`.............
00000110: 20 02 00 00 00 00 00 00 00 00 20 00 00 00 00 00   ......... .....
00000120: 02 00 00 00 06 00 00 00 20 0e 00 00 00 00 00 00  ........ .......
00000130: 20 0e 60 00 00 00 00 00 20 0e 60 00 00 00 00 00   .`..... .`.....
00000140: d0 01 00 00 00 00 00 00 d0 01 00 00 00 00 00 00  ................
00000150: 08 00 00 00 00 00 00 00 04 00 00 00 04 00 00 00  ................
00000160: 54 02 00 00 00 00 00 00 54 02 40 00 00 00 00 00  T.......T.@.....
00000170: 54 02 40 00 00 00 00 00 44 00 00 00 00 00 00 00  T.@.....D.......
00000180: 44 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00  D...............
00000190: 50 e5 74 64 04 00 00 00 b0 05 00 00 00 00 00 00  P.td............
000001a0: b0 05 40 00 00 00 00 00 b0 05 40 00 00 00 00 00  ..@.......@.....
000001b0: 3c 00 00 00 00 00 00 00 3c 00 00 00 00 00 00 00  <.......<.......
000001c0: 04 00 00 00 00 00 00 00 51 e5 74 64 06 00 00 00  ........Q.td....
000001d0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
000001e0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
000001f0: 00 00 00 00 00 00 00 00 10 00 00 00 00 00 00 00  ................
00000200: 52 e5 74 64 04 00 00 00 08 0e 00 00 00 00 00 00  R.td............
00000210: 08 0e 60 00 00 00 00 00 08 0e 60 00 00 00 00 00  ..`.......`.....
00000220: f8 01 00 00 00 00 00 00 f8 01 00 00 00 00 00 00  ................
00000230: 01 00 00 00 00 00 00 00 2f 6c 69 62 36 34 2f 6c  ......../lib64/l
00000240: 64 2d 6c 69 6e 75 78 2d 78 38 36 2d 36 34 2e 73  d-linux-x86-64.s
00000250: 6f 2e 32 00 04 00 00 00 10 00 00 00 01 00 00 00  o.2.............
00000260: 47 4e 55 00 00 00 00 00 02 00 00 00 06 00 00 00  GNU.............
00000270: 20 00 00 00 04 00 00 00 14 00 00 00 03 00 00 00   ...............

L'uso, ad esempio, main(int c, char**v){f();}invece modifica alcuni byte, ma non l'offset della stringa /lib64/ld-linux-x86-64.so.2, che useremo per produrre output.

L'offset di detta stringa è 0x238 ed è lungo 27 byte. Vogliamo solo stampare 17 byte (e l'ultimo sarà una nuova riga se usiamo puts), quindi aggiungiamo 11 all'offset per ottenere 0x243 , l'offset di inux-x86-64.so.2. Aggiungendo 0x400000 e 0x243 si ottiene 0x400243 , la posizione di memoria di inux-x86-64.so.2.

Per ottenere questo indirizzo di memoria, possiamo usare costanti di caratteri multi-carattere, che mostrano comportamenti definiti dall'implementazione. 0x400243 è (64) (2) (67) nella base 256 e le costanti di caratteri multi-carattere di gcc usano l'ordine dei byte big-endian, quindi '@\2C'restituisce l'indirizzo di memoria della stringa desiderata.

Infine, putsstampa la puntura (terminata con null) in quella posizione di memoria e una nuova riga finale, creando 17 byte di output.

— Dennis
fonte

Questa è magia ... assume questo l'ordine dei byte dell'assembly compilato o qualcosa del genere?

— Patrick Roberts,

Output sul mio sistema (Linux con GCC 6.3.1): Udurante la compilazione con -Df=main. Udurante la compilazione con main(){f();}.

— MD XF,

@PatrickRoberts A questo punto, non sono davvero sicuro di quali siano le ipotesi. Dal momento che fa capolino nel file ELF assemblato, dipende praticamente da tutto ciò che il compilatore scrive prima del codice effettivo.

— Dennis,

@MDXF Trovato un modo più breve per ottenere un indirizzo di memoria adatto. Funziona sul mio Ubuntu 14.04 VPS ora, ma ymmv.

— Dennis,

@Dennis Funziona bene ora (dang it). La ricompensa è tua se entro la fine della settimana nessuno trova una soluzione più breve.

— MD XF,

13

Brainfuck automodificante , 5 byte

<[.<]

Provalo online!

Produzione:

]<.[<

Spiegazione:

Davvero semplice, stampa la fonte al contrario. In SMBF, il contenuto del programma è memorizzato sul nastro, a sinistra della posizione iniziale del puntatore. Scorrendo a sinistra e la stampa restituirà il codice sorgente all'indietro.

Dal momento che la lettura della fonte è consentita in questa sfida, questo dovrebbe sicuramente rientrare nelle regole.

— Zack C.
fonte

13

Calcolatrice aritmetica di base , 2 byte

1=

stampe 1.o:

    |
    |
    |  .

su quegli sciocchi display a sette segmenti.

Per riprodurre, prendi qualsiasi calcolatrice casuale; tutti hanno questo linguaggio di programmazione installato in qualche modo.

— OldBunny2800
fonte

1

È vero per tutti i calcolatori? Sono sicuro che mostrano costantemente il punto decimale

— Decadimento Beta

Non è 1.invece di 1x? Anche questo è un quine, che è vietato dalle regole.

— Erik the Outgolfer,

No, 1=ho sbagliato. Volevo dire 1xche implicito è uguale, ma ho dimenticato che =è un pulsante.

— OldBunny2800,

Emette solo 1su TI-36 e TI-84 CE. Questi non contano come calcolatori "base"?

— Benjamin Urquhart,

No, una TI 84 non è una calcolatrice aritmetica, è una calcolatrice grafica. Non so del 36, ma sono abbastanza sicuro che sia una calcolatrice scientifica. Questa risposta è per i calcolatori a quattro funzioni.

— OldBunny2800

13

Fourier, 26 22 20 byte

5^(`na`&i)` Batman!`

Provalo su FourIDE!

Uscite:

nananananana Batman!

Per una corretta capitalizzazione, sono 4 byte extra:

`N`7^(`an`i^~i)`a Batman!`

Provalo su FourIDE!

Nanananananananana Batman!

_{RIP Adam West}

— Decadimento beta
fonte

1

Non devi includere NC (solo se hai realizzato la stampa di stringhe per questa sfida (e sarebbe sciocco)

— Christopher,

@Christopher Huh, non lo sapevo

— Decadimento beta

12

Brachylog , 1 byte

Provalo online!

Spiegazione

wè la "scrittura" integrata. Qui, scriverà l'input. Poiché l'input è una variabile libera, wverrà etichettato come intero prima della stampa. Il primo numero intero che prova è 0.

— Fatalize
fonte

Here, it will write the Input."Input" è il programma stesso? Non conta come leggere la fonte, che per impostazione predefinita è barare in un quine?

— MD XF,

4

@MDXF "Non si applicano le regole del solito quine"

— Rob Watts,

3

@MDXF L'Input è una speciale variabile Brachylog che è possibile impostare quando si chiama un programma Brachylog. Entra nella parte Input di TryItOnline. Qui non impostiamo nulla sull'Input, quindi è effettivamente una variabile. Non è il programma.

— Fatalizza

10

Java (OpenJDK 8) , 11 byte

o->1e8-1+""

Provalo online!

Produzione:

9.9999999E7

Solo un po 'più elaborata la risposta ovvia, ()->"".format("%23s",0).

Salva

18 -> 16 byte: combinazione più vantaggiosa di arrotondamento e potenza di 10, grazie a PunPun1000
16 -> 13 byte: formula migliore, grazie a JollyJoker
13 -> 11 byte: formula migliorata, grazie a Kevin Cruijssen

— Olivier Grégoire
fonte

2

()->1E10-1+"", "9.999999999E9" (13)salva altri tre byte

— JollyJoker

1

È possibile salvare 1 byte cambiando 1e10a 1e9, o 2 byte utilizzando un ingresso vuoto anziché() simili: o->1e8-1+""(uscite 9.9999999E7length byte-count 11 ).

— Kevin Cruijssen,

9

05AB1E , 1 byte

õ

Emette una nuova riga. õinserisce una stringa vuota ed è implicitamente emessa con una nuova riga.

Provalo online!

Alcune altre soluzioni a 2 byte, per il tuo piacere di visione (l'output è tra parentesi e tutto l'output ha una nuova riga finale):

X, (1)
Y, (2)
¾, (0)
¼, (1)
¶, (newline)
ð, (space)
Î, (0)

Ci sono comunque molte più soluzioni a 2 byte.

— Okx
fonte

"che è un metodo di output accettato" solo per soluzioni funzionali, non per programmi completi.

— Martin Ender,

@MartinEnder Queste soluzioni valgono quindi come funzioni? Non sono sicuro, dato che non uso spesso le funzioni qui.

— Okx,

Non ne so abbastanza di 05AB1E ma sono considerate funzioni solo se in realtà sono espressioni che valutano un oggetto funzione (cosa che dubito che facciano poiché il loro utilizzo provoca immediatamente l'esecuzione del comando).

— Martin Ender,

9

V / vim, 1 byte

Questo stampa una nuova riga.

Provalo online!

Ci sono un sacco di varianti su questo che funzionerebbe anche. Per esempio,

in vim, e

Ä
ä
ï
Ï

in V.

Esistono anche molte molte molte soluzioni a tre byte. Per esempio:

3ii
i³i
¬ac

Questi sono tutti specifici di V.

— DJMcMayhem
fonte

3ii non si espande fino a quando non si preme Esc, quindi dovrebbero essere tre o quattro byte (o sequenze di tasti, piuttosto)?

— algmyr,

@algmyr In vim, hai ragione. Dovrebbe essere 4ii<ESC>Tuttavia V riempie implicitamente la fuga alla fine del programma.

— DJMcMayhem

8

Lotto, 12 byte

@echo %OS%

Il conteggio dei byte include la nuova riga finale sia per lo script che per l'output, ovvero

Windows_NT

— Neil
fonte

Sembra che siano 11 byte non 12.

— Erik the Outgolfer

Ovviamente @EriktheOutgolfer cmd.exefarà eco a un CRLF dopo il Windows_NT, quindi 12 byte.

— Neil,

Quindi dovresti chiarire?

— Erik the Outgolfer,

8

Esagonia , 3 byte

o!@

Provalo online!

Stampe 111.

non piegato:

 o !
@ . .
 . .

Ma il codice è davvero solo eseguito nell'ordine o!@.

o   Set the memory edge to 111, the code point of 'o'.
!   Print this value as a decimal integer.
@   Terminate the program.

— Martin Ender
fonte

8

/// , 12 byte

/a/bcd/aaaa/

Provalo online!

Questo stampa bcdbcdbcdbcde poiché questi sono 12 byte, ho aggiunto un innocuo / alla fine del codice per completarlo.

— steenbergh
fonte

8

R, 7 byte

mode(T)

Stampa "logica"

— Ivanneke
fonte

Benvenuti in PPCG!

— Martin Ender,

7

MATL , 2 byte

C'è una nuova riga finale.

Provalo online!

Spiegazione

Appunti H contiene numeri 2per impostazione predefinita. Hspinge quel contenuto nello stack, che viene implicitamente visualizzato con una nuova riga finale.

— Luis Mendo
fonte

7

Carbone , 2 byte

→¹

Provalo online!

Stampa una linea orizzontale di lunghezza 1 -a destra e una nuova riga.

— ASCII-only
fonte

Il carbone di legna è una lingua davvero ingegnosa, dovrei impararla un po 'di tempo

— Skidsdev,

7

Gelatina , 1 byte

Un po 'di Jelly uno byters - questo è uno - valuta l'argomento sinistro che, quando non viene fornito nulla come input, viene impostato automaticamente a zero che a sua volta viene valutato a zero e il risultato viene stampato implicitamente, a 0.

Provalo online!

Infatti, dei 256 byte nella tabella codici ci sono solo 95 che attualmente non producono un diverso output di un byte all'interno dell'intervallo specificato quando vengono eseguiti come un programma completo; questi sono (come caratteri della tabella codici in ordine di byte):

¡¢£¦©½¿€ÇÑÞßçıȷñ÷þ"#&',-./0123456789:;?@IMRTVZ\`dmpstxyz{}~°³⁴⁵⁹ƓƈɠḶỌṬḊĖİĿṄȮṖṘẆẊṃọṣṭḃḟḣŀṁṗṡẋż’“

Appunti:

La maggior parte dei programmi a 1 byte stampa a 0(no-ops / produce un elenco con un singolo zero in, che stampa a 0), la maggior parte degli altri stampa a 1( 0=0e simili)
Ọè un programma che fa produrre un byte diverso, ma uno che è fuori portata secondo le specifiche - produce il null-byte (getta la 0a carattere)
⁶ produce uno spazio (un letterale)
⁷ produce un feed di riga (letterale)
Alcuni byte che funzionano ora potrebbero non farlo in futuro - ci sono alcuni byte riservati (credo) per valori niladici che, se assegnati, quasi sicuramente non produrranno output a un byte.

— Jonathan Allan
fonte

1

Collegamento morto perbyte

— Weedoze,

7

Befunge , 2 byte

.@

Provalo online!

Stampa 0con uno spazio finale. Funziona anche in Befunge 98.

— Martin Ender
fonte

Uscita con la stessa lunghezza del codice

Classifica

C (Linux moderno), 19 byte

Excel, 11 byte

Labirinto , 4 byte

Spiegazione

Bash (solo builtin), 8 byte

Retina , 2 byte

Mathematica, 2 byte

C, 20 byte

Bash su Linux, 6

Javascript ES6, 9 byte

Schema piramidale , 74 43 42 byte

Vecchia versione

Python 2 , 9 byte

Python 2 , 9 byte

Brainfuck , 25 byte

Spiegazione

C (Ideone), 14 byte

C (GCC), 15 byte

C (gcc) , 18 17 byte

portabilità

Verifica offline

Come funziona

Brainfuck automodificante , 5 byte

Spiegazione:

Calcolatrice aritmetica di base , 2 byte

Fourier, 26 22 20 byte

Brachylog , 1 byte

Spiegazione

Java (OpenJDK 8) , 11 byte

Salva

05AB1E , 1 byte

V / vim, 1 byte

Lotto, 12 byte

Esagonia , 3 byte

/// , 12 byte

R, 7 byte

MATL , 2 byte

Spiegazione

Carbone , 2 byte

Gelatina , 1 byte

Befunge , 2 byte