Eu acho que a pergunta acima é clara, mas apenas no caso:

• Escreva um programa completo (não apenas uma função) que imprima um número inteiro positivo de base 10, opcionalmente seguido por uma única nova linha.

• Os programas qualificados serão aqueles cuja saída for maior ( em bytes ) do que o código fonte do programa, medido em bytes (assumindo a codificação ASCII ou UTF-8 para o código fonte do programa).

  Ou seja, o código deve ser menor que o número de dígitos no número resultante.

• Os zeros à esquerda não são permitidos em todas as circunstâncias. Contar zeros à esquerda banaliza o problema; ignorar zeros à esquerda complica desnecessariamente a questão.

• O programa vencedor será o programa de qualificação que imprime o número inteiro com a menor magnitude.

Snippet de cabeçalho

var QUESTION_ID = 67921;
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;
function answersUrl(index) { return "https://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; }
function commentUrl(index, answers) { return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; }
function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); }
getAnswers();
var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*)(?:,|[-\u2013] ).*?([\d,^!e+]+)(?=\:?[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;
var OVERRIDE_REG = /^Override\s*header:\s*/i;
function getAuthorName(a) { return a.owner.display_name; }
function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.replace(/<sup>([^\n<]*)<\/sup>/g, "^$1").replace(/\(\d+(?:\^\d+,)? [\w\s]+\)/g, "").replace(/floor\(10\^(\d+)\/9\)/g, "$1 ones").replace(/(\d+) ones/g, function (_, x) { return Array(+x + 1).join(1); }).match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2].replace(/,/g, "").replace(/(\d+)\s*\^\s*(\d+)/, function (_, a, b) { return Math.pow(a, b); }).replace(/(\d+)!/, function (_, n) { for (var i = 1, j = 1; i <= n; i++) j *= i; return j; }), language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> 
<div id="language-list"> <h2>Shortest Solution 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> <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> <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>

Retina , pontuação 1

O programa vazio conta o número de correspondências do regex vazio na entrada (que é a cadeia vazia). Isso é exatamente uma correspondência, portanto é impresso 1.

Experimente online.

Pitão , 10

T

Primeira tentativa de usar Pyth. Tendo a pergunta esclarecida, parece que 10 será o menor número. Em Pyth, a letra T começa como o número 10, então isso simplesmente imprime 10que é maior que o comprimento do código-fonte. Você pode tentar aqui .

bc, 10

A

Felizmente, bcimprime o resultado da última expressão por padrão. Aé interpretado como um dígito hexadecimal, resultando em 10.

Fishing, score 7.958.661.109.946.400.884.391.936 1.208.925.819.614.629.174,70676

Essa é a pontuação mais alta e sem trivial de todos os tempos em um desafio de minimização? (Mesmo tendo sido um golfe de 84,8%)

v+CCCCCCCCCC
  `32`nSSSSP

Explicação

v              Sets the casting direction to down
 +             Increments the casting distance by 1
  CCCCCCCCCC   Casts the rod

`32`         Pushes a string "32" to the stack
    n        Converts the stack from a string to an integer
     SSSS    Repeated squaring of the stack
         P   Prints the stack

O número é 32^16e tem 25 dígitos. O código tem 24 bytes. A resposta anterior foi 6^32.

MATLAB, 1.000.000.000 (10 ⁹ )

Também funciona com o Octave

disp(1e9)

Nunca superando os esolangs, mas apenas por diversão, este é o menor MATLAB / Octave capaz de fazer, então pensei em publicá-lo de qualquer maneira.

TI-84 BASIC, 120

5!

ᴇ2teria uma pontuação melhor se não fosse o requisito bobo de UTF-8. (São apenas dois bytes na codificação token nativa da calculadora, mas são 4 em UTF-8 ...)

C #, pontuação 10 ^ 72 10 ^ 70 10 ^ 64 10 ^ 63

class A{static void Main(){System.Console.Write($"1{0:D63}");}}

Isso é 1.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000. Acho que tentei ...

Hexagonia , pontuação 100100

Código:

d!!@

De uma forma mais legível:

  d !
 ! @ .
  . .

O valor do char dé 100. Isso simplesmente imprime o valor do char duas vezes e termina depois.

Experimente online!

JavaScript, pontuação 100.000.000.000 (ou 1 * 10 ¹¹ )

alert(1e11)

Isso é se estiver usando alerta. Embora você possa obter uma pontuação 100.000.000 vezes menor se estiver usando o console:

1e3

Pontuação 1000, como você pode ver, embora não tenha certeza se conta usando o console.

PlatyPar , 59

#

#inicia um literal numérico de base 60 e, como nenhum dígito é encontrado, ele termina como 59. Isso começou como um acidente feliz, mas como eu já [ab] usei esse bug em outra resposta , eu o mantive.

Experimente online !

Aqui está outra abordagem, minha opinião sobre a maneira chata que todos e sua avó usaram para esse desafio.

PlatyPar , 100000000 (9 dígitos)

'18Md0+;

Explicação

'1        ## push "1" (a string) to the stack
  8Md  ;  ## repeat 8 times
     0+    ## add a 0
          ## [implicitly] print the result

Experimente online !

Brainf ** k , 11111111111111111111111111111111111 (~ 1e34)

E outra redução:

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

O que fornece 35 1s consecutivos, ou aproximadamente 1e34.

Um pouco menor ainda

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

Dá 36 1, que é um número cerca de 11% maior que 1e35.

Agradecemos a @Martin Büttner por eliminar alguns caracteres, reduzindo a produção total em um fator de 100 com este código (rendimento 1e36):

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

Meu código antigo (produz 1 + e38):

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

Eu tenho experimentado esolangs por tédio. Este é o melhor que eu poderia fazer em BF. Gostaria de saber se é possível torná-lo menor?

Você pode experimentá-lo online aqui .

C, 1000000000000000000000000000 (28 dígitos)

main(){printf("1%027d",0);}

Semelhante à minha resposta em C ++, sem a #include <stdio.h> (Ignore o aviso de falta de declaração de printf. Obrigado @ Dennis)

A nova linha exigiria 2 bytes adicionais, usando o formato 1%029d\n

Japt , 10 pontos

A

Como mostra a pontuação, imprime 10.

Python 2, 101010101010

print'10'*6

PHP, pontuação 10.000.000

<?=1e7;

Isso imprime 10000000 como pode ser visto lá .

Labirinto , pontuação 10.000.000

1!!!!>@

Pode ser possível reduzir isso em uma ordem de magnitude, mas não consigo encontrar nada no momento.

As primeiras 1!!!!impressões 1000. Em seguida, >muda o código fonte para

@1!!!!>

o que evita a rescisão antecipada. Então o IP atinge um beco sem saída e se vira. Agora !!!!imprime mais quatro zeros e @finaliza o programa.

Experimente online.

Samau , 42

A

Acoloca a resposta para a questão final da vida, do universo e de tudo na pilha. Em seguida, a parte superior da pilha é impressa automaticamente.

Brainfuck, 3333333333333333333333333 (25 anos)

Como está escrito "do zero", acho que não há problema em postar uma resposta separada:

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

23 bytes.

DC , 10000

Programa de 4 caracteres:

I4^f

Saída de 5 dígitos:

$ dc<<<'I4^f'
10000

Vitsy , 7! = 5040

7FN

Saídas 5040.

Experimente online!

C, 11111111111111111111111111111111111 (35 unidades)

main(c){while(c++<36)putchar(49);}

Talvez exista um caminho mais curto. A falta de uma maneira simples de imprimir grandes números em C torna complicado.

CJam, pontuação 10

A

Experimente online!

Java, 1111111111111111111111111111111111111111111111111111111111111111111111111111111 (81 ones)

interface A{static void main(String[]a){for(A i:new A[81])System.out.print(1);}}
                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Sublinhei a parte que é realmente "variável" aqui; tudo o mais é absolutamente necessário para um programa Java funcional.

Presumivelmente, isso é mais curto do que mexer com o Java BigInteger.

Cubix , 100100

@'dOu

Cubix é um esolang bidimensional baseado em pilha. O Cubix é diferente de outros idiomas 2D, pois o código-fonte está envolvido na parte externa de um cubo.

Teste online!

Explicação

A primeira coisa que o intérprete faz é descobrir o menor cubo no qual o código se ajustará. Nesse caso, o comprimento da borda é 1. Em seguida, o código é preenchido com no-ops .até que todos os seis lados sejam preenchidos. O espaço em branco é removido antes do processamento, portanto, esse código é idêntico ao acima:

  @
' d O u
  .

Agora o código está sendo executado. O IP (ponteiro de instrução) inicia na face esquerda extrema, apontando para leste.

O primeiro caractere que o IP encontra é o 'que coloca o próximo byte na pilha; esse byte é dou 100. A seguir O, é apresentado o item superior (100) como um número inteiro.

Em seguida, o IP atinge u, que o vira para a direita, move-o para a frente e depois vira-o novamente. Ele alterna para a face inferior apontando para o norte e depois gira para o leste. Isso o envolve Onovamente, produzindo 100 e até @o final do programa.

MATL , 1000

1e3

Nota: o último commit do GitHub do compilador funciona no Octave e no Matlab.

Isso interpreta o número na notação científica e o imprime implicitamente, produzindo assim a saída

1000

Perl, 1000000000

print 1e9

Direto.

Python 2, 107918163081

print 69**6

C ++, 1e46

#include <stdio.h>
main(){printf("1%046d",0);}

A nova linha exigiria 2 bytes adicionais, usando o formato "1% 048d \ n"

O, 10

A

Aparentemente, a pontuação é o número que imprimimos!

05AB1E , pontuação 10

Código

T

Explicação:

T         # Puts 10 onto the stack
          # Implicit, print the last item of the stack