Agora com BONUS para posicionamento em tempo de execução.

Escreva um programa para preencher uma caixa de texto com os identificadores usados ​​no seu programa, mantendo-o pequeno. Com todos os identificadores que você usou (excluindo os que você criou) em seu programa, preencha uma caixa de 12x6 com o maior número possível. Você ganha pontos extras por identificadores que cruzam (estilo de palavras cruzadas), mas eles não podem se unir de ponta a ponta.

Resultado

Seu programa deve imprimir (para stdout) uma caixa de 12x6 caracteres com seus identificadores compactados e uma #borda. A caixa deve ter colunas rotuladas com a letra AL e as linhas 1-6 (espaçadas como no exemplo abaixo). Em seguida, imprima uma linha para cada identificador usado. Cada linha terá a localização da primeira letra, o próprio identificador e a pontuação. A pontuação é igual ao número de letras no identificador com um possível '+ bônus' adicionado. O identificador recebe um bônus de 5 pontos por cada letra compartilhada com um identificador de cruzamento. A linha final informa 'TOTAL:' e a soma das pontuações do identificador. Um exemplo de saída para um possível programa Python seria assim:

   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:

• Os identificadores podem ser desanexados (como importacima).
• Você não pode participar pope se printalinhar com poprint.
• A string indentro insertnão pode ser usada. As palavras de junção devem ser ortogonais.
• Os identificadores podem ser colocados próximos um do outro (como pope insertacima).

Sua resposta deve incluir a saída do programa com o código-fonte e um título que consiste no nome do idioma e sua pontuação.

Ponto

Sua pontuação para o desafio será a pontuação do quebra-cabeça ao quadrado, dividida pelo tamanho do seu código-fonte (em bytes). Por exemplo: o quebra-cabeça acima com um programa de 300 bytes teria pontuação 55*55/300 = 10.08. Maior pontuação ganha.

Regras

• Você pode usar qualquer identificador no seu programa que não seja definido por você. Palavras-chave, nomes de classes, nomes de métodos, nomes de bibliotecas e nomes de funções internas são exemplos de identificadores elegíveis.
• EDITADO: Você pode usar apenas bibliotecas padrão incluídas na versão mínima do idioma. Pacotes de idiomas estendidos e o uso de bibliotecas externas (agora) são proibidos. A enorme variedade de bibliotecas com extensas listas de identificadores desequilibraria esse desafio. Se você não tiver certeza de como isso funciona com o seu idioma, deixe uma pergunta nos comentários.
• Os identificadores devem consistir apenas em [a-zA-Z_] caracteres e ter pelo menos 2 caracteres.
• Você pode usar cada identificador apenas uma vez no quebra-cabeça.
• Identificadores só podem ser usados ​​da esquerda para a direita ou para baixo.

Bônus dinâmico!

Se o seu código determinar onde colocar os identificadores em tempo de execução, o bônus de letras compartilhadas será 20 em vez de 5. Você pode listar quais identificadores serão usados, mas seu código deve decidir onde na caixa os colocará. Seu código também deve calcular e imprimir a lista de pontuação. Se seus canais dependerem da ordem da lista de identificadores, emparelhamentos codificados ou outros atalhos de canais não dinâmicos, você não estará qualificado para o bônus dinâmico.

No exemplo de saída acima, a pontuação do quebra-cabeça para um programa de posicionamento em tempo de execução se tornaria 145. Então, se o código tivesse 800 bytes, a pontuação seria 145*145/800 = 26.28.

O Dynamic Bonus foi desenvolvido para recompensar algoritmos inteligentes em vez de seqüências estáticas de solução codificada e compensar o tamanho maior do código-fonte resultante.

EDITAR% S:

• As bibliotecas alteradas costumavam ser apenas as da versão mínima do idioma.
• Adicionada a opção de bônus dinâmico.

STATA, 387 ^ 2/677 = 221,2

Fiquei preguiçoso e só queria produzir algo que funcione antes de tentar obtê-lo com a pontuação ideal. Provavelmente vou atualizá-lo mais tarde, à medida que encaixo mais palavras, e estou aberto a sugestões de qualquer pessoa que use STATA (que não parece muito popular no CodeGolf). STATA é realmente bom em ter muitos comandos / parâmetros de duas letras. Além disso, geralmente a maioria pode ser reduzida para salvar os caracteres / ajustar-se melhor (ou seja, a exibição pode ser exibida, exibida, deslocada, deslocada, deslocada, deslocada ou di). Além disso, a captura significa que ela suprime as mensagens de saída e erro. Portanto, o loop while inteiro tem 0 saídas.

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

gera

   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

Pitão, 134 ² /349 = 50,02

Se eu entendi as regras corretamente, este deve ser um envio válido.

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

Você pode realmente continuar aumentando sua pontuação adicionando mais identificadores: o tamanho do programa aumenta linearmente (aproximadamente duas vezes o comprimento do identificador), enquanto a pontuação aumenta aproximadamente pelo quadrado do comprimento do identificador. Em seguida, o desafio se torna mais como colocar a maioria das palavras-chave no quadrado, em vez de escrever um pequeno programa para fazê-lo.

Perl, 728 ² /639 = 829,4

Oh bem, isso não é válido, perdi que eu tenho que ter os identificadores no meu 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"

Isso requer um módulo de reflexão perl ( B::Keywords). Pode ser instalado no ubuntu com sudo apt-get install libb-keywords-perl. Com a semente fornecida no código acima, gera a resposta 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

Observe que versões diferentes do perl podem ter diferentes RNG e diferentes listas de palavras-chave, mas deve ser fácil encontrar uma semente com um resultado comparável.