Jetzt mit BONUS zur Laufzeitplatzierung.

Schreiben Sie ein Programm, um ein Textfeld mit den in Ihrem Programm verwendeten Bezeichnern zu füllen, während Sie Ihr Programm klein halten. Füllen Sie mit allen Bezeichnern, die Sie in Ihrem Programm verwendet haben (mit Ausnahme der von Ihnen erstellten), ein 12x6-Feld mit so vielen wie möglich. Sie erhalten zusätzliche Punkte für gekreuzte Bezeichner (Kreuzworträtselstil), die sich jedoch nicht durchgängig verbinden können.

Ausgabe

Ihr Programm sollte ein 12x6-Zeichenfeld mit Ihren gepackten Kennungen und einem #Rand drucken (um es zu stdouten) . Das Feld sollte Spalten mit dem Buchstaben AL und die Zeilen 1-6 enthalten (wie im folgenden Beispiel beabstandet). Drucken Sie dann eine Zeile für jede verwendete Kennung. Jede Zeile enthält die Position des ersten Buchstabens, die Kennung selbst und die Punktzahl. Die Punktzahl entspricht der Anzahl der Buchstaben in der Kennung, wobei ein möglicher '+ Bonus' hinzugefügt wird. Die Kennung erhält einen Bonus von 5 Punkten für jeden Buchstaben, der mit einer Kreuzungskennung geteilt wird. In der letzten Zeile wird 'TOTAL:' und die Summe der Bezeichnerwerte angezeigt. Eine Beispielausgabe für ein mögliches Python-Programm würde folgendermaßen aussehen:

   ABCDEFGHIJKL
  ##############
1 #  pinsert   #
2 #  o         #
3 #  print     #
4 #    not     #
5 #            #
6 #import      #
  ##############
C1 pop 3+5
D1 insert 6
C3 print 5+10
E3 in 2+10
E4 not 3+5
A6 import 6
TOTAL: 55

Anmerkungen:

• Bezeichner können (wie importoben) nicht angehängt werden .
• Sie können nicht beitreten popund printinline gehen poprint.
• Die Zeichenfolge im inInneren insertkann nicht verwendet werden. Das Verbinden von Wörtern muss orthogonal sein.
• Bezeichner können nebeneinander platziert werden (wie popund insertdarüber).

Ihre Antwort sollte Ihre Programmausgabe mit Ihrem Quellcode und einem Titel enthalten, der aus dem Namen der Sprache und Ihrer Punktzahl besteht.

Ergebnis

Ihre Punktzahl für die Herausforderung ergibt sich aus dem Quadrat der Puzzle-Punktzahl geteilt durch die Größe Ihres Quellcodes (in Bytes). Beispiel: Das obige Puzzle mit einem 300-Byte-Programm würde punkten 55*55/300 = 10.08. Die höchste Punktzahl gewinnt.

Regeln

• Sie können jeden Bezeichner in Ihrem Programm verwenden, der nicht von Ihnen definiert wurde. Schlüsselwörter, Klassennamen, Methodennamen, Bibliotheksnamen und integrierte Funktionsnamen sind Beispiele für geeignete Bezeichner.
• BEARBEITET: Sie dürfen nur Standardbibliotheken verwenden, die in der Mindestversion der Sprache enthalten sind. Erweiterte Sprachpakete und die Verwendung externer Bibliotheken sind (jetzt) ​​verboten. Die große Auswahl an Bibliotheken mit umfangreichen Listen von Kennungen würde diese Herausforderung aus dem Gleichgewicht bringen. Wenn Sie sich nicht sicher sind, wie dies mit Ihrer Sprache funktioniert, hinterlassen Sie bitte eine Frage in den Kommentaren.
• Bezeichner dürfen nur aus [a-zA-Z_] Zeichen bestehen und mindestens 2 Zeichen enthalten.
• Sie dürfen jede Kennung nur einmal im Puzzle verwenden.
• Bezeichner können nur von links nach rechts oder nach unten verwendet werden.

Dynamischer Bonus!

Wenn Ihr Code bestimmt, wo zur Laufzeit Kennungen platziert werden sollen, beträgt der Bonus für gemeinsam genutzte Buchstaben 20 statt 5. Sie können angeben, welche Kennungen verwendet werden sollen, aber Ihr Code muss entscheiden, wo in der Box sie platziert werden sollen. Ihr Code muss auch die Score-Liste berechnen und ausdrucken. Wenn Ihre Platzierungen von der Reihenfolge der Identifikatorliste, fest codierten Paarungen oder anderen nicht dynamischen Platzierungsverknüpfungen abhängen , haben Sie keinen Anspruch auf den dynamischen Bonus.

In der obigen Beispielausgabe würde die Puzzle-Punktzahl für ein Laufzeit-Platzierungsprogramm 145 werden. Wenn der Code dann 800 Bytes wäre, wäre die Punktzahl 145*145/800 = 26.28.

Der dynamische Bonus wurde entwickelt, um clevere Algorithmen anstelle von statischen fest codierten Lösungszeichenfolgen zu belohnen und die größere resultierende Quellcodegröße zu kompensieren.

EDITS:

• Geänderte Bibliotheken, die nur in der Mindestversion verwendet werden.
• Die dynamische Bonusoption wurde hinzugefügt.

STATA, 387 ^ 2/677 = 221,2

Ich wurde faul und wollte nur etwas ausgeben, das funktioniert, bevor ich versuchte, es mit optimaler Punktzahl zu bekommen. Ich werde es wahrscheinlich später aktualisieren, wenn ich mehr Wörter einfüge, und ich bin offen für Vorschläge von allen, die STATA verwenden (was bei CodeGolf nicht sehr beliebt zu sein scheint). STATA ist wirklich gut darin, viele Befehle / Parameter mit zwei Buchstaben zu haben. Außerdem können die meisten normalerweise gekürzt werden, um Zeichen zu speichern / besser anzupassen (dh Anzeige kann Anzeige, Anzeige, Anzeige, Anzeige, Anzeige oder Anzeige sein). Die Erfassung bedeutet auch, dass Ausgabe- und Fehlermeldungen unterdrückt werden. Die gesamte while-Schleife hat also 0 Ausgang.

cap infile using a,us(b)
cap while _rc>0{
ls
cap ge c=1 if 0<1
so c
egen d=rownonmiss(c),str
regres c d
notes
clist,noh no
li,compress
dec c,g(f)
do a
}
gl e=";;;ABCDEFGHIJKL ;;############## 1;#rownonmissdo# 2;#e;hd;o;notes# 3;#geii;hif_rc;# 4;#r;ls;clist;;# 5;#egen;ailu;;;# 6;#slcompress;;# ;;############## A1;rownonmiss;10+30 K1;do;2+5 H2;notes;5+20 A3;ge;2+5 G3;if;2+5 I3;_rc;3+15 C4;ls;2+10 F4;clist;5+20 A5;egen;4+20 C6;compress;8+20 A1;regres;6+15 C1;while;5+15 F1;noh;3+5 H1;infile;6+25 I1;so;2+10 J1;str;3+15 K1;dec;3+15 D2;dis;3+5 I3;_s;2+10 F4;cap;3+10 G4;li;2+5 B5;gl;2+5 D5;no;2+10 I5;us;2+5 TOTAL:;387"
token $e
forv x=1/34{
dis subinstr(``x'',";"," ",.)_s(0)
}

erzeugt

   ABCDEFGHIJKL
  ##############
1 #rownonmissdo#
2 #e hd o notes#
3 #geii hif_rc #
4 #r ls clist  #
5 #egen ailu   #
6 #slcompress  #
  ##############
A1 rownonmiss 10+30
K1 do 2+5
H2 notes 5+20
A3 ge 2+5
G3 if 2+5
I3 _rc 3+15
C4 ls 2+10
F4 clist 5+20
A5 egen 4+20
C6 compress 8+20
A1 regres 6+15
C1 while 5+15
F1 noh 3+5
H1 infile 6+25
I1 so 2+10
J1 str 3+15
K1 dec 3+15
D2 dis 3+5
I3 _s 2+10
F4 cap 3+10
G4 li 2+5
B5 gl 2+5
D5 no 2+10
I5 us 2+5
TOTAL: 387

Python, 134 ² /349 = 50,02

Wenn ich die Regeln richtig verstanden habe, sollte dies eine gültige Einreichung sein.

from sys import *
stdout.write("""   ABCDEFGHIJKL
  ##############
1 #from   f  i #
2 #  r   not t #
3 #      write #
4 #  s   import#
5 #  y   False #
6 #  stdout    #
  ##############
A1 from 4+5
C1 or 2+5
H1 format 6+25
K1 iter 4+10
G2 not 3+5
G3 write 5+10
C4 sys 3+5
G4 import 6+10
G5 False 5+5
C6 stdout 6+10
TOTAL 134
""".format(not False or iter([])))

Sie können Ihre Punktzahl wirklich einfach weiter erhöhen, indem Sie weitere Bezeichner hinzufügen: Die Größe des Programms nimmt linear zu (um etwa das Doppelte der Bezeichnerlänge), während sich die Punktzahl ungefähr um das Quadrat der Bezeichnerlänge erhöht. Dann wird die Herausforderung mehr darin bestehen, die meisten Schlüsselwörter in das Quadrat zu packen, als ein kurzes Programm dafür zu schreiben .

Perl, 728 ² /639 = 829,4

Na ja, das ist nicht gültig, verpasst, dass ich die Bezeichner in meinem Code haben muss.

#!perl -l
use B::Keywords'@Symbols','@Barewords';
use List::Util shuffle;
srand 45502;
@b=@a=shuffle map{push@{+length},$_;$_}grep/^[a-z]{2,}$/,@Symbols,@Barewords;
$z=$"x12 .$/;$z x=6;
$s=length,$z=~s/ {$s}/$_/&&($_=0)for@a;
$_=$z;$"='|';
sub f{join'',/(.)(?=@_.*(\n))/sg}$_=f".{12}(.)"x5;
s/@a/$v=length$&;$tot+=$v*21;$r.=(map{m!.!;map{$&.$_}1..7}A..L)[@-]." $& $v+".($v*20)."\n";uc$&/ge;
$_=f".{6}(.)"x11;
s/@b/$v=length$&;$b=$&=~y!A-Z!!;$tot+=$v+$b*20;$c=lc$&;$r.=(map{m!.!;map{$_.$&}A..M}1..6)[@-]." $c $v+".($b*20)."\n";uc$&/ige;
$_=$z;
s/
/#
/mg;
s/^/++$l.' #'/mge;
print'   ',A..L,'
  ','#'x14,'
',$_,'  ','#'x14,"
${r}TOTAL: $tot"

Dies erfordert ein Perl-Reflexionsmodul ( B::Keywords). Kann auf Ubuntu mit installiert werden sudo apt-get install libb-keywords-perl. Mit dem im obigen Code angegebenen Startwert wird die 728-Antwort generiert:

   ABCDEFGHIJKL
  ##############
1 #dumplogforqr#
2 #lcfirstbreak#
3 #socketshmctl#
4 #requiregiven#
5 #lengthgmtime#
6 #getserventdo#
  ##############
B1 uc 2+40
C2 fc 2+40
F3 tr 2+40
G1 gt 2+40
I1 or 2+40
J1 recv 4+80
L4 ne 2+40
A1 dump 4+20
E1 log 3+20
H1 for 3+40
K1 qr 2+0
A2 lcfirst 7+60
H2 break 5+40
A3 socket 6+40
G3 shmctl 6+20
A4 require 7+20
H4 given 5+40
A5 length 6+0
G5 gmtime 6+20
A6 getservent 10+0
K6 do 2+0
TOTAL: 728

Beachten Sie, dass verschiedene Perl-Versionen möglicherweise unterschiedliche RNG- und Keyword-Listen haben. Es sollte jedoch einfach sein, einen Startwert mit einem vergleichbaren Ergebnis zu finden.