Su desafío es crear un código más corto en el idioma de su elección que escriba en un .txtarchivo el código más largo para multiplicar dos números tomando dos números como entrada y salida de la respuesta .

¡NO SE NECESITA ENTRADA EN SU CÓDIGO QUE ESTÁ HACIENDO EL TRABAJO DE ESCRITURA !

El código generador y el código generado pueden estar en cualquier idioma

NO use series o progresiones ilimitadas para agrandar el archivo de texto.
NO use declaraciones innecesarias para aumentar el puntaje.

PUNTUACIÓN

( size of text file generated in bytes )  (without any unnecessary white spaces, tabs or newlines)
-----------------------------------------
     ( size of your code in bytes )  

Ganador

El ganador será elegido después de 1 semana a partir de ahora con la puntuación más alta .

EDITAR: el rango de entrada en el código que multiplica dos números debe estar entre -32768 y 32767

perl / perl, puntaje ilimitado bajo la regla original con rango ilimitado

Aquí hay un código que no gana:

$l=-2**5-1;
$h=2**5;
sub p{print@_}
p"sub add {(\$i,\$j)=\@_;\n";
for($i=$l;$i<=$h;++$i){
  for ($j=$l;$j<=$h;++$j){
    p" return ".($i*$j)." if (\$i == $i) && (\$j == $j);\n";
  }
}
p"}print add(<>,<>)\n";

La salida tiene esta forma:

sub add {($i,$j)=@_;
 return 1089 if ($i == -33) && ($j == -33);
 return 1056 if ($i == -33) && ($j == -32);
 return 1023 if ($i == -33) && ($j == -31);
 return 990 if ($i == -33) && ($j == -30);
...
 return 928 if ($i == 32) && ($j == 29);
 return 960 if ($i == 32) && ($j == 30);
 return 992 if ($i == 32) && ($j == 31);
 return 1024 if ($i == 32) && ($j == 32);
}print add(<>,<>)

el archivo de salida tiene una longitud de 181030 bytes, pero después de eliminar espacios y líneas nuevas, solo tiene 133109 bytes. entonces, el puntaje es 133109/248 = 536.7289 ...

Aquí hay otro código que no gana: es el mismo programa, excepto las primeras 2 líneas:

$l=-2**6-1;
$h=2**6;

el archivo de salida tiene una longitud de 718138 bytes, pero después de eliminar espacios y líneas nuevas, solo tiene 532233 bytes. entonces, el puntaje es 532233/248 = ~ 2146. ¡mejor! usando 7 produce un puntaje de ~ 8750, 8 rinde ~ 35347, 9 rinde ~ 149129, 10 rinde 151100000 sin espacio / 250 = 604,400 ...

por supuesto que podemos hacer esto todo el tiempo que queramos. el tamaño del programa fuente, n, aumentará a medida que O (log (n)). El tamaño del programa de salida es O (2 * n). El límite de 2 * n / log (n) cuando n va al infinito es claramente infinito, así que si solo sustituyo en mi gran número favorito, un googolplex, gano (hasta que alguien sugiera googolplex + 1).

C, 27297/245 = 111,4

Código fuente (245 bytes)

#include<stdio.h>
main(int c,char**v){char*s;FILE*f=fopen("/tmp/x.c","w");fprintf(f,"#include<stdio.h>\n#include<stdlib.h>\nmain(){int a=%s,b=%s;printf(\"%s * %s = %%d\\n\",a*b);}",v[1],v[2],v[1],v[2]);fclose(f);system("cc -E /tmp/x.c >add.c");}

Cuando se compila y ejecuta con dos argumentos enteros en la línea de comando, esto genera otro archivo C que contiene el código necesario para calcular su producto, y lo compila con el -Eindicador. Este indicador especifica que el compilador debe detenerse después de la etapa de preprocesamiento y generar el código fuente procesado (que incluirá todo el contenido de stdio.hy stdlib.h).

Archivo de salida (27297 bytes)

# 1 "/tmp/x.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "/tmp/x.c"
# 1 "/usr/include/stdio.h" 1 3 4
# 64 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/_types.h" 1 3 4
# 27 "/usr/include/_types.h" 3 4
# 1 "/usr/include/sys/_types.h" 1 3 4
# 32 "/usr/include/sys/_types.h" 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 33 "/usr/include/sys/_types.h" 2 3 4

********* LINES 13-1273 OMITTED *********

long long
  strtoq(const char *, char **, int);
unsigned long long
  strtouq(const char *, char **, int);

extern char *suboptarg;
void *valloc(size_t);







# 3 "/tmp/x.c" 2
main(){int a=6,b=7;printf("6 * 7 = %d\n",a*b);}

Resultado de ejecutar el código de salida

El archivo de salida se guarda como add.c, que se puede compilar y ejecutar normalmente:

$ ./a.out 6 7
$ cc add.c -o add
$ ./add
6 * 7 = 42
$ 

perl, 125 caracteres, puntaje 1,630,326,497.312

El mismo enfoque básico que mi otra respuesta, pero esta vez limitado entre -32768 y 32767 según las reglas actualizadas, y todos los espacios en blanco innecesarios se eliminan por completo:

$l=-($h=32767)-1;print"sub a{";for$i($l..$h){print"return ".$i*$_." if\$_[0]==$i&&\$_[1]==$_;"for$l..$h;}print"}print a<>,<>"

El programa de salida comienza así:

sub a{return 1073741824 if $_[0]==-32768&&$_[1]==-32768;return 1073709056 if $_[0]==-32768&&$_[1]==-32767;

y termina:

return 1073643522 if $_[0]==32767&&$_[1]==32766;return 1073676289 if $_[0]==32767&&$_[1]==32767;}print a<>,<>

El programa de salida tiene 190 GB de longitud. Más precisamente, 203790812164 bytes. Puntuación = 203790812164/125 = 1630326497.312

Script de comandos de Windows: ~ 1,000,000,000 pts

Código: 158 bytes

Salida: ~ 158000000000 bytes

echo>.txt @goto :%%1_%%2
set,=for /l %%a in (-32768 1 32767) do call :
%,%1 %%a
:1
%,%2 %1 %%a
:2
set/a]=%1*%2
echo :%1_%2>>.txt
echo @echo.%]%^&exit/b0>>.txt

El resultado consiste básicamente en:

@goto :%1_%2
:-32768_-32768
@echo.1073741824&exit/b0
:-32768_-32767
@echo.1073709056&exit/b0
...
:32767_32767
@echo.1073676289&exit/b0