Votre défi est de créer un code le plus court dans la langue de votre choix qui écrit sur un .txtfichier le code le plus long pour multiplier deux nombres en prenant deux nombres en entrée et en sortie la réponse .

AUCUNE ENTRÉE NÉCESSAIRE À VOTRE CODE QUI FAIT LE TRAVAIL D'ÉCRITURE !

Le code générateur et le code généré peuvent être dans toutes les langues

N'utilisez PAS de séries ou de progression illimitées pour agrandir le fichier texte.
N'utilisez PAS de déclarations inutiles pour augmenter le score.

NOTATION

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

Gagnant

Le gagnant sera choisi dans 1 semaine à partir de maintenant avec le score le plus élevé .

EDIT: la plage d'entrée dans le code multipliant deux nombres doit être comprise entre -32768 et 32767

perl / perl, score illimité selon la règle d'origine avec plage illimitée

Voici un code qui ne gagne pas:

$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 sortie a cette forme:

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(<>,<>)

le fichier de sortie a une longueur de 181030 octets, mais après suppression des espaces et des sauts de ligne, il ne fait que 133109 octets. donc le score est de 133109/248 = 536.7289 ...

Voici un autre code qui ne gagne pas - c'est le même programme sauf les 2 premières lignes:

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

le fichier de sortie est long de 718138 octets, mais après suppression des espaces et des sauts de ligne, il ne fait que 532233 octets. le score est donc de 532233/248 = ~ 2146. mieux! en utilisant 7 donne un score de ~ 8750, 8 rendements ~ 35347, 9 rendements ~ 149129, 10 rendements 151100000 non-espace / 250 = 604 400 ....

bien sûr, nous pouvons le faire aussi longtemps que nous le voulons. la taille du programme source, n, augmentera comme O (log (n)). la taille du programme de sortie est O (2 * n). La limite de 2 * n / log (n) lorsque n va à l'infini est clairement l'infini, donc si je remplace simplement dans mon grand nombre préféré, un googolplex, je gagne (jusqu'à ce que quelqu'un suggère googolplex + 1).

C, 27297/245 = 111,4

Code source (245 octets)

#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");}

Une fois compilé et exécuté avec deux arguments entiers sur la ligne de commande, cela génère un autre fichier C contenant le code nécessaire pour calculer leur produit et le compile avec l' -Eindicateur. Cet indicateur spécifie que le compilateur doit s'arrêter après l'étape de prétraitement et sortir le code source traité (qui inclura tout le contenu de stdio.het stdlib.h).

Fichier de sortie (27297 octets)

# 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);}

Résultat de l'exécution du code de sortie

Le fichier de sortie est enregistré sous add.c, qui peut être compilé et exécuté normalement:

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

perl, 125 caractères, score 1,630,326,497.312

Même approche de base que mon autre réponse, mais cette fois limitée entre -32768 et 32767 selon les règles mises à jour, et tous les espaces inutiles supprimés complètement:

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

Le programme de sortie commence ainsi:

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

et prend fin:

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

Le programme de sortie fait 190 Go. Plus précisément, 203790812164 octets. Note = 203790812164/125 = 1630326497,312

Script de commande Windows: ~ 1 000 000 000 pts

Code: 158 octets

Sortie: ~ 158000000000 octets

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

La sortie se compose à peu près de:

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