Je pense que la question ci-dessus est claire, mais juste au cas où:

• Ecrivez un programme complet (pas seulement une fonction) qui affiche un nombre entier positif en base 10, éventuellement suivi d'un simple retour à la ligne.

• Les programmes qualifiés seront ceux dont la sortie est plus longue ( en octets ) que le code source du programme, mesurée en octets (en supposant un codage ASCII ou UTF-8 pour le code source du programme).

  En d'autres termes, le code doit être plus court que le nombre de chiffres du nombre résultant.

• Les zéros non significatifs sont interdits en toutes circonstances. Compter les zéros au début banalise le problème; ignorer les zéros de tête complique inutilement la question.

• Le programme gagnant sera le programme de qualification qui imprimera l’entier de la plus petite magnitude.

Extrait de classement

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>

Rétine , score 1

Le programme vide compte le nombre de correspondances de l'expression rationnelle vide dans l'entrée (qui est la chaîne vide). C'est exactement 1 correspondance, donc ça s'imprime 1.

Essayez-le en ligne.

Pyth , 10

T

Première tentative d'utilisation de Pyth. Après avoir clarifié la question, il semble que 10 sera le plus petit nombre. En Pyth, la lettre T commence par le chiffre 10, elle indique donc simplement ce 10qui est plus grand que la longueur du code source. Vous pouvez l' essayer ici .

bc, 10

A

Heureusement, bcaffiche le résultat de la dernière expression par défaut. Aest interprété comme un chiffre hexadécimal 10.

Pêche, score 7,958,661,109,946,400,884,391,936 1,208,925,819,614,629,174,706,176

Est-ce le score le plus élevé jamais obtenu dans un défi de minimisation? (Même s'il a été joué au golf par 84,8%)

v+CCCCCCCCCC
  `32`nSSSSP

Explication

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

Le numéro est 32^16et a 25 chiffres. Le code a une longueur de 24 octets. La réponse précédente était 6^32.

MATLAB, 1 000 000 000 (10 ⁹ )

Fonctionne également avec Octave

disp(1e9)

Ne va jamais battre les esolangs, mais juste pour le fun, c'est le plus petit MATLAB / Octave sera capable de le faire, alors j'ai pensé le poster de toute façon.

TI-84 BASIC, 120

5!

ᴇ2marquerait mieux si pas pour l'exigence stupide UTF-8. (Ce n'est que deux octets dans l'encodage tokenisé natif de la calculatrice, mais il s'agit de 4 en UTF-8 ...)

C #, score 10 ^ 72 10 ^ 70 10 ^ 64 10 ^ 63

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

C'est 1 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000. Je suppose que j'ai essayé ...

Hexagony , score 100100

Code:

d!!@

Sous une forme plus lisible:

  d !
 ! @ .
  . .

La valeur de caractère dest 100. Ceci affichera simplement la valeur de caractère deux fois et se terminera après.

Essayez-le en ligne!

JavaScript, score 100 000 000 000 (ou 1 * 10 ¹¹ )

alert(1e11)

C'est si vous utilisez alert. Bien que vous puissiez obtenir 100 000 000 fois moins de points si vous utilisez la console:

1e3

Score 1000 comme vous pouvez le voir, je ne suis pas sûr que cela compte avec la console.

PlatyPar , 59 ans

#

#démarre un littéral numérique de base 60, et comme aucun chiffre n’est trouvé, il se termine par 59. Cela a commencé comme un heureux accident, mais comme j'ai déjà utilisé ce bug dans une autre réponse , je l'ai gardé.

Essayez-le en ligne !

Voici une autre approche, ma vision de la façon ennuyeuse utilisée par tous et leur grand-mère pour relever ce défi.

PlatyPar , 100000000 (9 chiffres)

'18Md0+;

Explication

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

Essayez-le en ligne !

Brainf ** k , 1111111111111111111111111111111111111 (~ 1e34)

Et une autre réduction:

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

Ce qui donne 35 1 consécutifs, soit environ 1e34.

Un peu plus petit encore

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

Donne 36 1 ce qui est un nombre environ 11% plus grand que 1e35.

Merci à @Martin Büttner d’avoir éliminé quelques caractères, ce qui a permis de réduire de 100 le nombre total de sorties avec ce code (donne 1e36):

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

Mon ancien code (donne 1 + e38):

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

J'ai expérimenté des esolangs par ennui. C’est ce que je pouvais faire de mieux en petit ami. Je me demande s'il est possible de le réduire

Vous pouvez l'essayer en ligne ici .

C, 1000000000000000000000000000 (28 chiffres)

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

Similaire à ma réponse C ++, sans le #include <stdio.h> (Ignorer l'avertissement concernant la déclaration manquante de printf. Merci @Dennis)

Newline nécessiterait 2 octets supplémentaires, en utilisant le format 1%029d\n

Japt , score 10

A

Comme le montre la partition, imprime 10.

Python 2, 101010101010

print'10'*6

PHP, score 10 000 000

<?=1e7;

Ceci imprime 10000000 comme on peut le voir ici .

Labyrinthe , score 10 000 000

1!!!!>@

Il serait peut-être possible de réduire ce facteur d'un ordre de grandeur, mais je ne trouve rien pour l'instant.

Les premiers 1!!!!tirages 1000. >Déplace ensuite le code source sur

@1!!!!>

ce qui évite une résiliation anticipée. Ensuite, l'IP se trouve dans une impasse et se retourne. !!!!Affiche maintenant quatre autres zéros et @termine le programme.

Essayez-le en ligne.

Samau , 42

A

Apousse la réponse à la question ultime de la vie, de l'univers et de tout sur la pile. Ensuite, le haut de la pile est automatiquement imprimé.

Brainfuck, 3333333333333333333333333 (25 threes)

Ceci est écrit "à partir de zéro", donc je pense que ça va de poster une réponse séparée:

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

23 octets de long.

DC , 10000

Programme 4 caractères:

I4^f

Sortie 5 chiffres:

$ dc<<<'I4^f'
10000

Vitsy , 7! = 5040

7FN

Sorties 5040.

Essayez-le en ligne!

C, 1111111111111111111111111111111111111 (35 unités)

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

Peut-être y a-t-il un moyen plus court. L'absence d'un moyen simple d'imprimer de gros chiffres en C rend la tâche difficile.

CJam, score 10

A

Essayez-le en ligne!

Java, 11111111111111111111111111111111111111111111111111111111111111111111111111111111111 (81 unités)

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

J'ai souligné la partie qui est réellement "variable" ici; tout le reste est absolument nécessaire pour un programme Java fonctionnel.

Vraisemblablement, cela est plus court que de fouiller avec Java BigInteger.

Cubix , 100100

@'dOu

Cubix est un esolang bidimensionnel basé sur une pile. Cubix est différent des autres langages 2D en ce que le code source est encapsulé à l’extérieur d’un cube.

Testez-le en ligne!

Explication

La première chose à faire par l’interprète consiste à déterminer le plus petit cube sur lequel le code s’intégrera. Dans ce cas, la longueur du bord est 1. Ensuite, le code est .rempli avec no-ops jusqu'à ce que les six côtés soient remplis. Les espaces sont supprimés avant le traitement, ce code est donc identique à celui ci-dessus:

  @
' d O u
  .

Maintenant, le code est exécuté. L'IP (pointeur d'instruction) commence sur la face gauche extrême, en direction est.

Le premier caractère que l'IP rencontre est celui 'qui pousse l'octet suivant dans la pile; cet octet est d, ou 100. Next est l’ Oaffichage de l’élément supérieur (100) sous forme d’entier.

Puis l’IP frappe u, qui le tourne à droite, le fait avancer, puis le tourne à nouveau. Il bascule vers la face inférieure pointant vers le nord, puis tourne vers l'est. Cela l’enveloppe à Onouveau, en générant 100, puis @termine le programme.

MATL , 1000

1e3

Remarque: le dernier commit GitHub du compilateur fonctionne sur Octave ainsi que sur Matlab.

Ceci interprète le nombre en notation scientifique et l’imprime implicitement, produisant ainsi la sortie

1000

Perl, 1000000000

print 1e9

Simple.

Python 2, 107918163081

print 69**6

C ++, 1e46

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

Newline nécessiterait 2 octets supplémentaires, en utilisant le format "1% 048d \ n"

O, 10

A

Apparemment, le score est le nombre que nous imprimons!

05AB1E , score 10

Code

T

Explication:

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