Ihre Herausforderung besteht darin , einen kürzesten Code in der Sprache Ihrer Wahl zu .txterstellen, der den längsten Code in eine Datei schreibt , um zwei Zahlen zu multiplizieren, indem zwei Zahlen als Eingabe und Ausgabe der Antwort verwendet werden .

KEINE EINGABE FÜR IHREN CODE ERFORDERLICH, DER DEN SCHREIBJOB TUT !

Der Generatorcode und der generierte Code können in beliebigen Sprachen vorliegen

Verwenden Sie KEINE unbegrenzten Serien oder Progressionen, um eine große Textdatei zu erstellen. Verwenden
Sie KEINE unnötigen Anweisungen, um die Punktzahl zu erhöhen.

WERTUNG

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

Gewinner

Der Gewinner wird nach 1 Woche mit der höchsten Punktzahl ausgewählt .

BEARBEITEN: Der Eingabebereich im Code, der zwei Zahlen multipliziert, sollte zwischen -32768 und 32767 liegen

Perl / Perl, unbegrenzte Punktzahl unter der ursprünglichen Regel mit unbegrenzter Reichweite

Hier ist ein Code, der nicht gewinnt:

$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";

Die Ausgabe hat folgende Form:

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

Die Ausgabedatei ist 181030 Byte lang, nach dem Entfernen von Leerzeichen und Zeilenumbrüchen jedoch nur 133109 Byte. Die Punktzahl ist also 133109/248 = 536.7289 ...

Hier ist ein anderer Code, der nicht gewinnt - es ist dasselbe Programm mit Ausnahme der ersten beiden Zeilen:

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

Die Ausgabedatei ist 718138 Byte lang, nach dem Entfernen von Leerzeichen und Zeilenumbrüchen jedoch nur 532233 Byte. Die Punktzahl ist also 532233/248 = ~ 2146. besser! bei Verwendung von 7 ergibt sich eine Punktzahl von ~ 8750, 8 ergibt sich ~ 35347, 9 ergibt sich ~ 149129, 10 ergibt sich 151100000 non-space / 250 = 604,400 ....

Natürlich können wir das tun, solange wir wollen. Die Größe des Quellprogramms, n, erhöht sich als O (log (n)). Die Größe des Ausgabeprogramms ist O (2 * n). Die Grenze von 2 * n / log (n), wenn n gegen unendlich geht, ist eindeutig unendlich. Wenn ich also nur meine Lieblingszahl Googolplex einsetze, gewinne ich (bis jemand Googolplex + 1 vorschlägt).

C 27297/245 = 111,4

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

Beim Kompilieren und Ausführen mit zwei Ganzzahlargumenten in der Befehlszeile wird eine weitere C-Datei generiert, die den für die Berechnung des Produkts erforderlichen Code enthält, und mit dem -EFlag kompiliert . Dieses Flag gibt an, dass der Compiler nach der Vorverarbeitungsphase anhalten und den verarbeiteten Quellcode ausgeben soll (der den gesamten Inhalt von stdio.hund enthält stdlib.h).

Ausgabedatei (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);}

Ergebnis der Ausführung des Ausgabecodes

Die Ausgabedatei wird gespeichert als add.c, die kompiliert und normal ausgeführt werden kann:

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

Perl, 125 Zeichen, Score 1.630.326.497.312

Dieselbe grundlegende Vorgehensweise wie meine andere Antwort, aber diesmal zwischen -32768 und 32767 gemäß den aktualisierten Regeln, und alle unnötigen Leerzeichen wurden vollständig entfernt:

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

Das Ausgabeprogramm beginnt wie folgt:

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

und endet:

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

Das Ausgabeprogramm ist 190 GB lang. Genauer gesagt, 203790812164 Bytes. Score = 203790812164/125 = 1630326497.312

Windows-Befehlsskript: ~ 1.000.000.000 Punkte

Code: 158 Bytes

Ausgabe: ~ 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

Die Ausgabe besteht so ziemlich aus:

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