Nesse desafio, você deve escrever um programa ou função que não aceite entrada e imprima ou retorne uma sequência com o mesmo número de bytes que o próprio programa. Existem algumas regras:

• Você só pode enviar bytes no intervalo ASCII imprimível (0x20 a 0x7E, inclusive) ou novas linhas (0x0A ou 0x0D).
• Seu código não deve ser quine; portanto, o código e a saída devem diferir em pelo menos um byte.
• Seu código deve ter pelo menos um byte.
• Se sua saída contiver novas linhas à direita, elas farão parte da contagem de bytes.
• Se o seu código exigir sinalizadores de linha de comando não padrão, conte-os como de costume (ou seja, adicionando a diferença a uma invocação padrão da implementação do seu idioma na contagem de bytes), e o comprimento da saída deverá corresponder à pontuação da sua solução. Por exemplo, se o seu programa é abe requer um sinalizador não padrão -n(presumimos que ele não possa ser combinado com sinalizadores padrão, portanto são 3 bytes), você deve gerar 5 bytes no total.
• A saída nem sempre precisa ser a mesma, desde que você possa mostrar que todas as saídas possíveis atendem aos requisitos acima.
• Regras habituais de quine não se aplicam. Você pode ler o código fonte ou seu tamanho, mas duvido que seja mais curto do que codificá-lo na maioria dos idiomas.

Você pode escrever um programa ou uma função e usar qualquer um dos métodos padrão de fornecimento de saída. Observe que, se você imprimir o resultado, poderá optar por imprimi-lo na saída padrão ou no fluxo de erros padrão, mas apenas um deles conta.

Você pode usar qualquer linguagem de programação , mas observe que essas brechas são proibidas por padrão.

Isso é código-golfe , então a resposta mais curta e válida - medida em bytes - vence.

Entre os melhores

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>

C (Linux moderno), 19 bytes

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

Quando compilado e executado, isso imprime:

Segmentation fault

Excel, 11 bytes

Versão em idioma norueguês:

=SMÅ(13^9)

Versão em inglês (12 bytes):

=LOWER(17^9)

Gera um número de n dígitos e converte em texto convertendo para minúsculas.

Labirinto , 4 bytes

!!>@

Experimente online!

Impressões 0000

Explicação

!   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.

Bash (somente interno), 8 bytes

{e,,}cho

Imprime cho choe uma nova linha.

Retina , 2 bytes

no

Experimente online!

Imprime 0e um avanço de linha.

Existem muitas soluções de 2 bytes, mas acredito que isso é ideal. Por padrão, a retina sempre imprime uma nova linha à direita e a remoção dela leva muitos bytes. Portanto, teríamos que encontrar um programa de 1 byte que deixasse a entrada vazia inalterada. Eu acredito que o único programa que faz isso é o programa que contém um único avanço de linha, que é, portanto, igual à saída e, portanto, não é permitido pelo desafio.

A próxima coisa mais simples a fazer é conviver com a Retina produzindo um único dígito (o número de correspondências de alguma regex contra a entrada vazia), e podemos fazer isso com muitos padrões de 2 bytes com falha (ou correspondência).

Mathematica, 2 bytes

4!

fatorial

24

C, 20 bytes

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

Produz algum número, preenchido com espaços até 20 (Qual número? O que acontecerá a seguir na memória).

Alguns exemplos são executados no meu 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

É uma pena que a saída não possa ter bytes arbitrários, porque isso teria permitido esta solução de 19 bytes:

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

que gera 19 bytes de lixo eletrônico, começando no fendereço de.

Bash no Linux, 6

uname

(seguido por uma nova linha)

Saídas Linuxseguidas por uma nova linha.

Javascript ES6, 9 bytes

Usando seqüências de caracteres de modelo

_=>`${_}`

f=

_=>`${_}`

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

Esquema da pirâmide , 74 43 42 bytes

Economizou 31 bytes graças a Khuldraeseth na'Barya! Economizou 1 byte graças à solução redesenhada do JoKing!

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

Experimente online! Produz o número de 41 dígitos 28^28 = 33145523113253374862572728253364605812736, seguido por uma nova linha à direita.

Versão antiga

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

Experimente online!

Saídas 71277303925397560663333806233294794013421332605135474842607729452115234375= 160651015 ** 9, ou aproximadamente 10 ⁷⁴ .

Python 2 , 9 bytes

print{+1}

Isso imprime set([1])e um avanço de linha.

Experimente online!

Python 2 , 9 bytes

print 1e5

A saída exibida contém uma nova linha à direita.

Experimente online!

brainfuck , 25 bytes

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

Experimente online! Nota: Requer uma implementação com células não assinadas de 8 bits

Resultado:

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

Explicação

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

C (Ideona), 14 bytes

f(){warn(0);}

No Ideone , que nomeia seu executável prog, isso gera o seguinte com uma nova linha à direita.

prog: Success

C (GCC), 15 bytes

f(){warn(00);}

Como o GCC grava um executável nomeado a.outpor padrão (na ausência de sinalizadores adicionais que custariam bytes), isso gera o seguinte com uma nova linha à direita.

a.out: Success

C (gcc) , 18 17 bytes

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

Observe que há um byte STX ( 0x02 ) entre @eC .

Experimente online!

Portabilidade

Isso foi testado com o gcc 6.3.1 e clang 3.9.1 no Fedora 25, gcc 4.8.4 no Ubuntu 14.04.4 e gcc 4.8.3 no openSUSE 13.2, onde imprime a seguinte saída.

inux-x86-64.so.2

Espero que isso produza a mesma saída com todas as versões do gcc, desde que seja compilado para um executável do tipo a seguir.

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

Plataformas diferentes exigirão um endereço de memória diferente e possivelmente uma ordem diferente para os bytes na constante de caracteres com vários caracteres.

Por exemplo, substituindo @\2Cpor @\2\4impressões exec/ld-elf.so.1e uma nova linha no FreeBSD 11 pelo clang 3.8.0.

Verificação 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

Como funciona

Por padrão, ld usa 0x400000 como o endereço base do segmento de texto, o que significa que podemos encontrar o conteúdo do ELF começando no endereço de memória 0x400000 .

Os primeiros 640 bytes do ELF são amplamente independentes do código-fonte real. Por exemplo, se a declaração de f for seguida por main(){f();}e mais nada, elas terão a seguinte aparência.

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  [email protected]...@.....
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  [email protected].......
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   ...............

Usar, por exemplo, main(int c, char**v){f();}altera alguns bytes, mas não o deslocamento da string /lib64/ld-linux-x86-64.so.2, que usaremos para produzir saída.

O deslocamento da referida string é 0x238 e tem 27 bytes. Queremos imprimir apenas 17 bytes (e o último será uma nova linha se usarmos puts); portanto, adicionamos 11 ao deslocamento para obter 0x243 , o deslocamento de inux-x86-64.so.2. A adição de 0x400000 e 0x243 fornece 0x400243 , o local da memória deinux-x86-64.so.2 .

Para obter esse endereço de memória, podemos usar constantes de caracteres com vários caracteres, que exibem um comportamento definido pela implementação. 0x400243 é (64) (2) (67) na base 256 e as constantes de caracteres com vários caracteres do gcc usam a ordem de bytes big-endian, portanto, '@\2C'gera o endereço de memória da string desejada.

Por fim, putsimprime a picada (terminada por nulo) nesse local da memória e em uma nova linha à direita, criando 17 bytes de saída.

Brainfuck auto-modificável , 5 bytes

<[.<]

Experimente online!

Resultado:

]<.[<

Explicação:

Realmente simples, imprime a fonte ao contrário. No SMBF, o conteúdo do programa é armazenado na fita, à esquerda da posição inicial do ponteiro. Deslizar para a esquerda e imprimir imprimirá o código-fonte para trás.

Como a fonte de leitura é permitida neste desafio, isso definitivamente deve estar dentro das regras.

Calculadora aritmética básica , 2 bytes

1=

impressões 1. ou:

    |
    |
    |  .

naqueles displays bobos de sete segmentos.

Para reproduzir, pegue qualquer calculadora aleatória; todos eles têm essa linguagem de programação instalada de alguma forma.

Fourier, 26 22 20 bytes

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

Experimente no FourIDE!

Saídas:

nananananana Batman!

Para uma capitalização adequada, são 4 bytes extras:

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

Experimente no FourIDE!

Nanananananananana Batman!

_{RIP Adam West}

Braquilog , 1 byte

w

Experimente online!

Explicação

wé a "gravação" interna. Aqui, ele escreverá a entrada. Como a Entrada é uma variável livre, wa rotulará como um número inteiro antes da impressão. O primeiro número inteiro que ele tenta é 0.

Java (OpenJDK 8) , 11 bytes

o->1e8-1+""

Experimente online!

Resultado:

9.9999999E7

Apenas um pouco mais elaborado do que a resposta óbvia ()->"".format("%23s",0).

Economizar

• 18 -> 16 bytes: combinação mais vantajosa de arredondamento e potência de 10, graças ao PunPun1000
• 16 -> 13 bytes: melhor fórmula, graças ao JollyJoker
• 13 -> 11 bytes: fórmula melhorada, graças a Kevin Cruijssen

05AB1E , 1 byte

õ

Gera uma única nova linha. õempurra uma string vazia e é implicitamente gerada com uma nova linha.

Experimente online!

Algumas outras soluções de 2 bytes, para seu prazer visual (a saída está entre parênteses e toda a saída possui uma nova linha à direita):

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

Existem muito mais soluções de 2 bytes.

V / vim, 1 byte

o

Isso imprime uma única nova linha.

Experimente online!

Há muitas variantes nisso que também funcionariam. Por exemplo,

O

no vim, e

Ä
ä
ï
Ï

em V.

Existem também muitas soluções de três bytes. Por exemplo:

3ii
i³i
¬ac

Tudo isso é específico de V.

Lote, 12 bytes

@echo %OS%

A contagem de bytes inclui uma nova linha à direita para script e saída, que é

Windows_NT

Hexagonia , 3 bytes

o!@

Experimente online!

Impressões 111 .

Desdobrado:

 o !
@ . .
 . .

Mas o código é realmente executado apenas na ordem o!@.

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

/// , 12 bytes

/a/bcd/aaaa/

Experimente online!

Isso é impresso bcdbcdbcdbcde, como são 12 bytes, adicionei um inofensivo / ao final do código para preenchê-lo.

R, 7 bytes

mode(T)

Imprime "lógico"

MATL , 2 bytes

H

Há uma nova linha à direita.

Experimente online!

Explicação

A área de transferência H contém o número 2por padrão. Henvia esse conteúdo para a pilha, que é exibida implicitamente com uma nova linha à direita.

Carvão , 2 bytes

→¹

Experimente online!

Imprime uma linha horizontal de comprimento 1 -da direita e uma nova linha.

Geléia , 1 byte

V

Um número considerável de Jelly one byters - este é um - avalia o argumento esquerdo que, quando nada é fornecido como entrada, o padrão é zero, que por sua vez avalia zero e o resultado é implicitamente impresso, a 0.

Experimente online!

De fato, dos 256 bytes na página de códigos, existem apenas 95 que atualmente não produzem uma saída de um byte diferente dentro do intervalo especificado quando executados como um programa completo; são eles (como caracteres da página de código em ordem de bytes):

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

Notas:

• A maioria dos programas de 1 byte imprime a 0(no-ops / produzindo uma lista com um único zero in, que imprime a 0), a maioria dos outros imprime a 1( 0=0e similares)

• Ọé o programa que faz produzir um byte diferente, mas um que está fora do alcance de acordo com as especificações - produz o nulo de byte (a lança 0para personagem)

• ⁶ produz um espaço (um literal)

• ⁷ produz um feed de linha (um literal)

• Alguns bytes que funcionam agora podem não o fazer no futuro - existem alguns bytes reservados (acredito) para valores niládicos que, quando atribuídos, quase certamente não produzirão uma saída de um byte.

Befunge , 2 bytes

.@

Experimente online!

Imprime 0com um espaço à direita. Também funciona no Befunge 98.