Tu idioma en una caja

8

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.
Caballero Lógico
fuente
Para ser claros, mejor puntuación es mejor, ¿verdad?
Trauma digital
1
Correcto. Inserte tantos identificadores únicos en la caja mientras mantiene su programa lo más pequeño posible -> mejor puntaje.
Caballero lógico
¿Este desafío realmente implica programación?
Feersum
Quizás debería dejar esto más claro. Debe escribir y ejecutar un programa que genere el requisito de texto. El texto en la salida depende de los identificadores utilizados en el programa que escribe.
Logic Knight
1
Para su información, algunas bibliotecas que involucran SIMD o Shader definen todas las combinaciones de xyzw/ rgba/ stpq:)
kennytm

Respuestas:

2

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
comentarios
fuente
Esta respuesta parece válida. Actualmente el líder.
Logic Knight
3

Python, 134 2 /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.

Frxstrem
fuente
Tu respuesta parece válida. Había planeado motivar a los programadores para que escribieran un solucionador dinámico con cierto nivel de introspección, pero espero que este enfoque de incrustar la respuesta en una cadena sea más fácil. Suspiro.
Logic Knight
Su punto de vista de que el desafío es más rompecabezas que programación está bien entendido. He agregado una bonificación por las respuestas que utilizan la colocación en tiempo de ejecución en sus programas. El estilo de impresión de cadenas sigue siendo válido, pero espero ver más soluciones de programación que hagan uso de la bonificación. Gracias por su respuesta y sus puntos de vista +1.
Logic Knight,
Tal vez solo me estoy perdiendo algo, pero ¿por qué en stdout.writelugar de eso printy qué pasa con format(not False or iter([]))el final? También podría agregar fácilmente como "está" al lado del "sys" y un "para" debajo "de" ...
aquavitae
@aquavitae Solo puede usar identificadores que se usan en su programa en una sintaxis válida, por lo que Frxstrem incluye los identificadores que se usarán en el rompecabezas. El programa no tiene que tener sentido o ser eficiente.
Logic Knight
Ah, lo siento, aparentemente no leí el problema correctamente. En ese caso, podría cambiar la formatlecturaiter([i for i in [not False is sys]])
aquavitae
0

Perl, 728 2 /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.

nutki
fuente
Ha detectado uno de los problemas: los identificadores deben aparecer al menos una vez en su código. Hay otro problema No debe usar bibliotecas que no se proporcionan en el paquete de idioma básico. Esta es una regla necesaria para detener el uso de bibliotecas que proporcionarían ventajas injustas en este desafío. Espero que puedas cambiar tu enfoque y crear una buena respuesta de Perl para el desafío.
Logic Knight