Ahora con BONUS para la colocación en tiempo de ejecución.

Escriba un programa para llenar un cuadro de texto con los identificadores utilizados en su programa mientras lo mantiene pequeño. Con todos los identificadores que ha utilizado (excluyendo los que creó) en su programa, llene un cuadro de 12x6 con tantos como pueda. Obtiene puntos adicionales para los identificadores que se cruzan (estilo de crucigrama), pero no se pueden unir de extremo a extremo.

Salida

Su programa debe imprimir (para stdout) un cuadro de 12x6 caracteres con sus identificadores empaquetados y un #borde. El cuadro debe tener columnas etiquetadas con la letra AL y las filas 1-6 (espaciadas como en el ejemplo a continuación). Luego imprima una línea para cada identificador utilizado. Cada línea tendrá la ubicación de la primera letra, el identificador en sí y la puntuación. El puntaje es igual al número de letras en el identificador con un posible '+ bono' agregado. El identificador obtiene una bonificación de 5 puntos por cada letra compartida con un identificador de cruce. La línea final informa 'TOTAL:' y la suma de las puntuaciones del identificador. Un resultado de ejemplo para un posible programa de Python se vería así:

   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

Notas:

• Los identificadores se pueden desacoplar (como importarriba).
• No puedes unirte popy estar en printlínea con poprint.
• La cadena indentro insertno se puede usar. Unir palabras debe ser ortogonal.
• Los identificadores se pueden colocar uno al lado del otro (como popy insertarriba).

Su respuesta debe incluir la salida de su programa con su código fuente y un título que consista en el nombre del idioma y su puntaje.

Puntuación

Su puntaje para el desafío será el puntaje del rompecabezas al cuadrado dividido por el tamaño de su código fuente (en bytes). Por ejemplo: el acertijo anterior con un programa de 300 bytes marcaría 55*55/300 = 10.08. La puntuación más alta gana.

Reglas

• Puede usar cualquier identificador en su programa que no haya definido. Las palabras clave, los nombres de clase, los nombres de métodos, los nombres de bibliotecas y los nombres de funciones integradas son ejemplos de identificadores elegibles.
• EDITADO: Solo puede usar bibliotecas estándar que se incluyen con la versión mínima de idioma. Los paquetes de idiomas extendidos y el uso de bibliotecas externas (ahora) están prohibidos. La gran variedad de bibliotecas con extensas listas de identificadores desequilibraría este desafío. Si no está seguro de cómo funciona esto con su idioma, deje una pregunta en los comentarios.
• Los identificadores deben constar solo de caracteres [a-zA-Z_] y tener al menos 2 caracteres.
• Solo puede usar cada identificador una vez en el rompecabezas.
• Los identificadores solo se pueden usar de izquierda a derecha o hacia abajo.

Bono Dinámico!

Si su código determina dónde colocar los identificadores en el tiempo de ejecución, la bonificación de letras compartidas será de 20 en lugar de 5. Puede enumerar qué identificadores se utilizarán, pero su código debe decidir dónde colocarlos en el cuadro. Su código también debe calcular e imprimir la lista de puntajes. Si sus ubicaciones dependen del orden de la lista de identificadores, emparejamientos codificados u otros atajos de ubicación no dinámicos, no es elegible para el Bono Dinámico.

En la salida de ejemplo anterior, la puntuación del rompecabezas para un programa de colocación en tiempo de ejecución sería 145. Entonces, si el código fuera de 800 bytes, la puntuación sería 145*145/800 = 26.28.

Dynamic Bonus está diseñado para recompensar algoritmos inteligentes en lugar de cadenas de solución estáticas codificadas, y compensar el mayor tamaño del código fuente resultante.

EDICIONES:

• Las bibliotecas modificadas se utilizan solo para aquellas en la versión mínima de idioma.
• Se agregó la opción de bonificación dinámica.

STATA, 387 ^ 2/677 = 221.2

Me volví flojo y solo quería generar algo que funcionara antes de intentar obtenerlo con una puntuación óptima. Probablemente lo actualizaré más tarde a medida que incluya más palabras, y estoy abierto a sugerencias de cualquiera que use STATA (que no parece muy popular en CodeGolf). STATA es realmente bueno acerca de tener muchos comandos / parámetros de dos letras. Además, por lo general, la mayoría se puede acortar para guardar caracteres / ajustar mejor (es decir, la pantalla se puede mostrar, desplazar, mostrar, mostrar, mostrar o di). Además, la captura significa que suprime los mensajes de salida y error. Entonces, el ciclo while completo tiene 0 salidas.

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

genera

   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

Si he entendido las reglas correctamente, esto debería ser una presentación válida.

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([])))

Realmente puede seguir incrementando su puntaje agregando más identificadores: el tamaño del programa aumenta linealmente (aproximadamente el doble de la longitud del identificador), mientras que el puntaje aumenta aproximadamente por el cuadrado de la longitud del identificador. Luego, el desafío es más cómo meter la mayoría de las palabras clave en el cuadrado en lugar de cómo escribir un programa corto para hacerlo.

Perl, 728 ² /639 = 829,4

Oh, bueno, esto no es válido, perdí que tengo que tener los identificadores en mi código.

#!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"

Esto requiere un módulo de reflexión perl ( B::Keywords). Se puede instalar en ubuntu con sudo apt-get install libb-keywords-perl. Con la semilla dada en el código anterior, genera la respuesta 728:

   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

Tenga en cuenta que las diferentes versiones de perl pueden tener diferentes RNG y diferentes listas de palabras clave, pero debería ser fácil encontrar una semilla con un resultado comparable.