97

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

Mostrar snippet de código

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>

Expand snippet

code-golf self-referential

— Martin Ender
fonte

2

Relacionado. Relacionado.

— Martin Ender

18

"Seu código não deve ser um Quine", mas ... mas ... está marcado Quine

— Okx

4

@Okx Por se tratar de uma solução generalizada, ou seja, a saída necessária depende do código fonte.

— Martin Ender

4

@ MartinEnder Você provavelmente deve proibir a saída pelo código de saída, que é o padrão. Se você permitir quase todos os programas de um byte em quase todos os idiomas, é permitido. Um usuário já fez isso

— Assistente de Trigo 17/05

2

A saída @WheatWizard pelo código de saída não é uma string, portanto não se aplica aqui.

— Martin Ender

204

C (Linux moderno), 19 bytes

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

Quando compilado e executado, isso imprime:

Segmentation fault

— MD XF
fonte

20

Isso é brilhante: D

— Beta Decay

4

isso é mais como "idioma C + inglês unix / posix OS;)"

— Florian Castellane

5

Eu acho que seria melhor escrever "C, Linux moderno" do que apenas "C": No Windows, a mensagem de erro é diferente e, nos velhos tempos, os programas Linux eram compilados de uma maneira que o endereço 0x73 ('s') era legível portanto, nenhuma exceção foi causada.

— Martin Rosenau

9

Entrei no site apenas para votar esta resposta.

— Nitish

7

Tão impressionante como este é, não é realmente o programa C que imprime a saída, mas o shell que está sendo executado no.

— Dennis

80

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.

— pajonk
fonte

106

Isso dá um novo significado a "escolher o idioma certo para o trabalho".

— Martin Ender

4

Esta é uma ótima idéia. Seria mais curto, o =9^7&""que gera um número de 7 dígitos em qualquer idioma e tem apenas 7 bytes.

— OpiesDad

@OpiesDad Boa solução, acho que você deve publicá-la como resposta, para que eu possa votar.

— Pajonk

4

@MartinEnder Me diverte como a sua especulação / piada em potencial é mais votada do que esta resposta (embora seja próxima).

— HyperNeutrino

55

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.

— Martin Ender
fonte

6

Isso é muito inteligente. Tenha um +1 em casa!

— caird coinheringaahing

54

Bash (somente interno), 8 bytes

{e,,}cho

Imprime cho choe uma nova linha.

— Anders Kaseorg
fonte

40

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

— Martin Ender
fonte

27

+1 Para o código que me diz para não executá-lo: P

— Christopher

33

Mathematica, 2 bytes

4!

fatorial

24

— J42161217
fonte

1

Gah! esperto demais.

— Tuskiomi 17/05/19

2

bata-me a isso! +1. ( Eu acho que você deve mencionar que este é na versão REPL de Mathematica.)

— Greg Martin

Se esta for uma resposta razoável, a resposta "1" também não seria uma resposta razoável? (Colocar '1' no REPL do Mathematica também retornaria '1' ...)

— Mark Segal

3

@ MarkSegal Isso violaria a regra do não-quine.

— AlexR

6

Regras: ... "... o código e a saída devem diferir em pelo menos um byte"

— J42161217 20/17

29

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.

— Maçaneta da porta
fonte

Fico feliz em ver uma resposta que faz uso da regra de saída variável. :)

— Martin Ender

Não foi possível esse segfault?

— Daniel

Onde estão os links do TIO?

— CalculatorFeline

@ Daniel Não, o número impresso será proveniente do conteúdo anterior do %esiregistro.

— Maçaneta

8

@Doorknob, mas ainda é um comportamento indefinido, portanto, um compilador mais sádico pode fazer algo completamente diferente aqui

— Sarge Borsch

29

Bash no Linux, 6

uname

(seguido por uma nova linha)

Saídas Linuxseguidas por uma nova linha.

— Trauma Digital
fonte

2

Tecnicamente unamenão é um builtin festa - é um executável separado

— Jason Musgrove

-1, e realmente um builtin

— GammaFunction

@GammaFunction Onde você vê o unamebash? Toda distro em que eu posso colocar minhas mãos agora é um binário separado, incluindo o TIO . Por outro lado, como mostra sua resposta vinculada, umaskestá embutido na maioria / todas as conchas.

— Digital Trauma

Eu não vejo unamecomo um embutido. Quando eu disse "-1, e realmente um builtin", quis dizer "Esta resposta usa umask-1 bytes e umaské realmente um builtin".

— GammaFunction

@ GammaFunction Desculpe - eu não entendi o significado do "-1" no seu comentário - estou acostumado com os significados negativos e um comentário explicando o porquê.

— Digital Trauma

27

Javascript ES6, 9 bytes

Usando seqüências de caracteres de modelo

_=>`${_}`

f=

_=>`${_}`

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

Expandir snippet

— Weedoze
fonte

É undefinedconsiderado uma string?

— Salsicha

3

@ Shaggy Veja a edição. Eu estou usando interpolação de String

— Weedoze 17/17/17

Uau, este é o meu segundo post no PPCG e 14 upvotes! Obrigado

— Weedoze

1

Por que soro simples você pode ter dificuldade? (_=>_+'').

— GOTO 0

1

@ GOTO0 Oh ok, você fica com parênteses. Essa é outra opção. Eu pessoalmente prefiro o meu hehe

— Weedoze

24

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 ⁷⁴ .

— Conor O'Brien
fonte

6

Ei, você está tentando vender seu idioma? Se assim for, você está preso. - Os Cops

— NoOneIsHere

2

@NoOneIsHere perdão?

— Conor O'Brien

3

Desculpe, é chamado de esquema de pirâmide, que também é o nome de um tipo de golpe.

— NoOneIsHere

1

ohhhhhhhhhhh rofl

— Conor O'Brien

1

A saída implícita reduz a 43 bytes .

— Khuldraeseth na'Barya

23

Python 2 , 9 bytes

print{+1}

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

Experimente online!

— Dennis
fonte

11

Desde os programas de força bruta que começam com print, não há soluções mais curtas, e os únicos de 9 bytes são variantes disso e de Luis Mendo print 1e5 .

— Xnor

23

Python 2 , 9 bytes

print 1e5

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

Experimente online!

— Luis Mendo
fonte

As novas linhas finais contam como um caractere até a saída? Caso contrário, isso imprime oito bytes.

— OldBunny2800

@ OldBunny2800 Sim, o desafio diz que, se sua saída contiver novas linhas à direita, elas farão parte da contagem de bytes . Enfim, vou esclarecer isso na minha resposta

— Luis Mendo

18

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

— Zack C.
fonte

4

Existem muitas variações de BF, como uma fita infita de 8 bits. ou uma fita limitada e células infinitas. Tenho certeza de que o seu é um modelo de célula de 8 bits não assinado, mas acho que seria bom se você incluísse isso em sua resposta.

— Roman Gräf

@ RomanGräf Bom ponto! Normalmente, incluo essas informações se for necessária uma implementação não padrão. Esta resposta deve funcionar em qualquer implementação padrão (células não assinadas de 8 bits, qualquer fita), mas adicionarei uma observação para esclarecer.

— Zack C.

Você não poderia ter um programa de 1 byte .que imprime o NULLcaractere não imprimível ?

— Graviton 17/05

@Graviton Isso violaria a primeira regra deste desafio. No entanto, essa é uma solução válida em um derivado de BF que tem como padrão um valor imprimível (consulte: minha resposta de brainbool ).

— Zack C.

24 bytes

— Jo King

16

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

— Anders Kaseorg
fonte

7

@MDXF A especificação diz programa ou função, portanto, o envio de uma função é perfeitamente válido. Como o nome do arquivo não foi escolhido pelo usuário aqui (tanto o Ideone quanto o gcc têm padrões), acho que isso é bom (opinião pessoal).

— Dennis

15

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

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.

— Dennis
fonte

Isso é mágica ... isso assume a ordem dos bytes do assembly compilado ou algo assim?

— Patrick Roberts

Saída no meu sistema (Linux com GCC 6.3.1): Uao compilar com -Df=main. Uao compilar com main(){f();}.

— MD XF

@PatrickRoberts Neste momento, não tenho muita certeza de quais são as suposições. Uma vez que aparece no arquivo ELF montado, depende praticamente de tudo o que o compilador escreve antes do código real.

— Dennis

@MDXF Encontrei uma maneira mais curta de obter um endereço de memória adequado. Ele funciona no meu Ubuntu 14.04 VPS agora, mas sim.

— Dennis

@Dennis funciona bem agora (dang it). A recompensa é sua se, no final da semana, ninguém encontrar uma solução mais curta.

— MD XF

13

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.

— Zack C.
fonte

13

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.

— OldBunny2800
fonte

1

Isso é verdade para todas as calculadoras? Eu tenho certeza que eles mostram constantemente o ponto decimal

— Decay Beta

Não é em 1.vez de 1x? Além disso, este é um quine, que não é permitido pelas regras.

— Erik the Outgolfer

Não, 1=eu errei. Eu quis dizer 1xque é igual a implícito, mas esqueci que =é um botão.

— OldBunny2800

Só é emitido 1nas minhas TI-36 e TI-84 CE. Não contam como calculadoras "básicas"?

— Benjamin Urquhart

Não, uma TI 84 não é uma calculadora aritmética, é uma calculadora gráfica. Não sei sobre os 36, mas tenho certeza de que é uma calculadora científica. Esta resposta é para calculadoras de quatro funções.

— OldBunny2800

13

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}

— Beta Decay
fonte

1

Você não tem de incluir NC (apenas se você fez a impressão corda para este desafio (e que seria tolo)

— Christopher

@ Christopher Huh, eu não sabia disso

— Decay Beta

12

Braquilog , 1 byte

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.

— Fatalizar
fonte

Here, it will write the Input.'Input' é o próprio programa? Isso não conta como ler a fonte, que, por padrão, é trapaça em um quine?

— MD XF

4

@MDXF "Regras comuns de quine não se aplicam"

— Rob Watts

3

@MDXF A Entrada é uma variável Brachylog especial que você pode definir ao chamar um programa Brachylog. Ele entra na parte de entrada do TryItOnline. Aqui não configuramos nada para a entrada, portanto ela é efetivamente uma variável. Não é o programa.

— Fatalize

10

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

— Olivier Grégoire
fonte

2

()->1E10-1+"", "9.999999999E9" (13)salva mais três bytes

— JollyJoker

1

Você pode salvar 1 byte alterando 1e10para 1e9ou 2 bytes usando uma entrada vazia em vez de() : o->1e8-1+""(saídas 9.9999999E7; comprimento & contagem de bytes 11 ).

— Kevin Cruijssen

9

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.

— Okx
fonte

"que é um método de saída aceito" apenas para soluções de funções, não para programas completos.

— Martin Ender

@ MartinEnder Essas soluções contariam como funções, então? Não tenho muita certeza, pois não costumo usar funções aqui.

— Okx 17/05/19

Eu não sei o suficiente sobre 05AB1E, mas elas são consideradas funções apenas se forem realmente expressões que são avaliadas para um objeto de função (o que duvido que façam desde que usá-las imediatamente faz com que o comando seja executado).

— Martin Ender

9

V / vim, 1 byte

Isso imprime uma única nova linha.

Experimente online!

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

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.

— DJMcMayhem
fonte

3ii não se expande até você pressionar escape, então isso deve ser de três ou quatro bytes (ou pressionamentos de teclas)?

— Algmyr

@algmyr No vim, você está correto. Teria que ser, no 4ii<ESC>entanto, V implicitamente preenche a fuga no final do programa.

— DJMcMayhem

8

Lote, 12 bytes

@echo %OS%

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

Windows_NT

— Neil
fonte

Parece que é 11 bytes não 12.

— Erik as Outgolfer

O @EriktheOutgolfer, cmd.exeé claro, ecoará um CRLF após o Windows_NT, portanto, 12 bytes.

— Neil

Então você deve esclarecer?

— Erik the Outgolfer

8

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.

— Martin Ender
fonte

8

/// , 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.

— steenbergh
fonte

8

R, 7 bytes

mode(T)

Imprime "lógico"

— Ivanneke
fonte

Bem-vindo ao PPCG!

— Martin Ender

7

MATL , 2 bytes

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.

— Luis Mendo
fonte

7

Carvão , 2 bytes

→¹

Experimente online!

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

— Somente ASCII
fonte

O carvão vegetal do homem é uma linguagem realmente bacana, eu deveria aprendê-la em algum momento #

— Skidsdev

7

Geléia , 1 byte

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.

— Jonathan Allan
fonte

1

Link morto parabyte

— Weedoze 17/05

7

Befunge , 2 bytes

.@

Experimente online!

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

— Martin Ender
fonte

Saída com o mesmo comprimento que o código

Entre os melhores

C (Linux moderno), 19 bytes

Excel, 11 bytes

Labirinto , 4 bytes

Explicação

Bash (somente interno), 8 bytes

Retina , 2 bytes

Mathematica, 2 bytes

C, 20 bytes

Bash no Linux, 6

Javascript ES6, 9 bytes

Esquema da pirâmide , 74 43 42 bytes

Versão antiga

Python 2 , 9 bytes

Python 2 , 9 bytes

brainfuck , 25 bytes

Explicação

C (Ideona), 14 bytes

C (GCC), 15 bytes

C (gcc) , 18 17 bytes

Portabilidade

Verificação offline

Como funciona

Brainfuck auto-modificável , 5 bytes

Explicação:

Calculadora aritmética básica , 2 bytes

Fourier, 26 22 20 bytes

Braquilog , 1 byte

Explicação

Java (OpenJDK 8) , 11 bytes

Economizar

05AB1E , 1 byte

V / vim, 1 byte

Lote, 12 bytes

Hexagonia , 3 bytes

/// , 12 bytes

R, 7 bytes

MATL , 2 bytes

Explicação

Carvão , 2 bytes

Geléia , 1 byte

Befunge , 2 bytes