Creo que la pregunta anterior es clara, pero por las dudas:

• Escriba un programa completo (no solo una función) que imprima un entero positivo de base 10, opcionalmente seguido de una nueva línea.

• Los programas que califiquen serán aquellos cuya salida es más larga ( en bytes ) que el código fuente del programa, medida en bytes (suponiendo la codificación ASCII o UTF-8 para el código fuente del programa).

  Es decir, el código debe ser más corto que el número de dígitos en el número resultante.

• Los ceros iniciales no se permiten bajo ninguna circunstancia. Contar los ceros a la izquierda trivializa el problema; ignorar los ceros a la izquierda complica innecesariamente la pregunta.

• El programa ganador será el programa de calificación que imprime el número entero con la menor magnitud.

Fragmento de tabla de clasificación

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 , puntaje 1

El programa vacío cuenta el número de coincidencias de la expresión regular vacía en la entrada (que es la cadena vacía). Eso es exactamente 1 partido, por lo que se imprime 1.

Pruébalo en línea.

Pyth , 10

T

Primer intento de usar Pyth. Habiendo aclarado la pregunta, parece que 10 será el número más pequeño. En Pyth, la letra T comienza como el número 10, por lo que simplemente imprime 10cuál es mayor que la longitud del código fuente. Puedes probarlo aquí .

a. C., 10

A

Afortunadamente, bcimprime el resultado de la última expresión por defecto. Ase interpreta como un dígito hexadecimal, por lo que resulta en 10.

Pesca, puntaje 7,958,661,109,946,400,884,391,936 1,208,925,819,614,629,174,706,176

¿Es este el puntaje más alto de aspecto no trivial en un desafío de minimización? (A pesar de que ha sido golfizado por 84.8%)

v+CCCCCCCCCC
  `32`nSSSSP

Explicación

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

El número es 32^16y tiene 25 dígitos. El código tiene 24 bytes de longitud. La respuesta anterior fue 6^32.

MATLAB, 1,000,000,000 (10 ⁹ )

También funciona con octava

disp(1e9)

Nunca voy a vencer a los esolangs, pero solo por diversión, este es el MATLAB / Octave más pequeño que podrá hacer, así que pensé que lo publicaría de todos modos.

TI-84 BASIC, 120

5!

ᴇ2puntuaría mejor si no fuera por el tonto requisito de UTF-8. (Son solo dos bytes en la codificación tokenizada nativa de la calculadora, pero son 4 en UTF-8 ...)

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

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

Eso es 1,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000. Supongo que lo intenté ...

Hexagonía , puntaje 100100

Código:

d!!@

En una forma más legible:

  d !
 ! @ .
  . .

El valor de char des 100. Esto simplemente imprimirá el valor de char dos veces y terminará después.

Pruébalo en línea!

JavaScript, puntaje 100,000,000,000 (o 1 * 10 ¹¹ )

alert(1e11)

Esto es si usa la alerta. Aunque puede obtener una puntuación 100 000 000 veces menor si usa la consola:

1e3

Puntuación 1000 como puede ver, aunque no estoy seguro de que cuente con la consola.

PlatyPar , 59

#

#comienza un literal numérico base-60, y como no se encuentran dígitos, termina como 59. Esto comenzó como un feliz accidente, pero como ya [ab] usé este error en otra respuesta , lo guardé.

Pruébalo en línea !

Aquí hay otro enfoque, mi opinión sobre la forma aburrida que todos y su abuela usaron para este desafío.

PlatyPar , 100000000 (9 dígitos)

'18Md0+;

Explicación

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

Pruébalo en línea !

Brainf ** k , 11111111111111111111111111111111111 (~ 1e34)

Y otra reducción:

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

Lo que da 35 1 consecutivos, o aproximadamente 1e34.

Un poco más pequeño aún

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

Da 36 1's, que es un número aproximadamente 11% mayor que 1e35.

Gracias a @Martin Büttner por eliminar un par de caracteres que reducen la producción total en un factor de 100 con este código (produce 1e36):

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

Mi código anterior (produce 1 + e38):

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

He estado experimentando con esolangs por aburrimiento. Esto es lo mejor que puedo hacer en BF. Me pregunto si es posible hacerlo más pequeño.

Puedes probarlo en línea aquí .

C, 1000000000000000000000000000 (28 dígitos)

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

Similar a mi respuesta de C ++, sin el #include <stdio.h> (Ignorar la advertencia sobre la declaración faltante de printf. Gracias @Dennis)

Newline requeriría 2 bytes adicionales, usando el formato 1%029d\n

Japt , puntaje 10

A

Como muestra el puntaje, imprime 10.

Python 2, 101010101010

print'10'*6

PHP, puntaje 10,000,000

<?=1e7;

Esto imprime 10000000 como se puede ver allí .

Laberinto , puntaje 10,000,000

1!!!!>@

Podría ser posible reducir esto en un orden de magnitud, pero no puedo encontrar nada en este momento.

Las primeras 1!!!!impresiones 1000. Luego >cambia el código fuente a

@1!!!!>

lo que evita la terminación anticipada. Luego, la IP llega a un callejón sin salida y se da vuelta. Ahora !!!!imprime cuatro ceros más y @finaliza el programa.

Pruébalo en línea.

Samau , 42

A

Aempuja la respuesta a la última pregunta de la vida, el universo y todo en la pila. Luego, la parte superior de la pila se imprime automáticamente.

Brainfuck, 3333333333333333333333333 (25 tres)

Esto está escrito "desde cero", así que creo que está bien publicar una respuesta por separado:

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

23 bytes de largo.

DC , 10000

Programa de 4 caracteres:

I4^f

Salida de 5 dígitos:

$ dc<<<'I4^f'
10000

Vitsy , 7! = 5040

7FN

Salidas 5040.

Pruébalo en línea!

C, 11111111111111111111111111111111111 (35 unidades)

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

Tal vez hay un camino más corto. La falta de una forma simple de imprimir grandes números en C hace que sea complicado.

CJam, puntaje 10

A

Pruébalo en línea!

Java, 111111111111111111111111111111111111111111111111111111111111111111111111111111111 (81 unidades)

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

He subrayado la parte que en realidad es "variable" aquí; todo lo demás es absolutamente necesario para que un programa Java funcione.

Presumiblemente, esto es más corto que jugar con Java BigInteger.

Cubix , 100100

@'dOu

Cubix es un esolang bidimensional basado en pila. Cubix es diferente de otros idiomas 2D en que el código fuente se envuelve alrededor del exterior de un cubo.

¡Pruébalo en línea!

Explicación

Lo primero que hace el intérprete es averiguar el cubo más pequeño en el que se ajustará el código. En este caso, la longitud del borde es 1. Luego, el código se rellena sin operaciones .hasta que se llenen los seis lados. El espacio en blanco se elimina antes del procesamiento, por lo que este código es idéntico al anterior:

  @
' d O u
  .

Ahora se ejecuta el código. El IP (puntero de instrucción) comienza en el extremo izquierdo, apuntando hacia el este.

El primer carácter que encuentra la IP es ', que empuja el siguiente byte a la pila; este byte es d, o 100. El siguiente es O, que genera el elemento superior (100) como un entero.

Luego, el IP golpea u, que lo gira hacia la derecha, lo mueve hacia adelante y luego lo vuelve a girar. Cambia a la cara inferior apuntando hacia el norte, luego gira hacia el este. Esto lo envuelve Onuevamente, produciendo 100, y luego hasta @que finaliza el programa.

MATL , 1000

1e3

Nota: la última confirmación de GitHub del compilador funciona tanto en Octave como en Matlab.

Esto interpreta el número en notación científica y lo imprime implícitamente, produciendo así la salida

1000

Perl, 1000000000

print 1e9

Sencillo.

Python 2, 107918163081

print 69**6

C ++, 1e46

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

Newline requeriría 2 bytes adicionales, utilizando el formato "1% 048d \ n"

O, 10

A

Al parecer, la puntuación es el número que imprimimos!

05AB1E , puntaje 10

Código

T

Explicación:

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