Seu idioma em uma caixa

8

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.
Cavaleiro Lógico
fonte
Só para ficar claro, maior pontuação é melhor, certo?
Digital Trauma
1
Corrigir. Coloque o maior número possível de identificadores únicos na caixa, mantendo o programa o menor possível -> melhor pontuação.
Logic Knight
Esse desafio realmente envolve programação?
feersum
Talvez eu deva deixar isso mais claro. Você deve escrever e executar um programa que produza o requisito de texto. O texto na saída depende dos identificadores usados ​​no programa que você escreve.
Logic Knight
1
FYI, algumas bibliotecas envolvendo SIMD ou Shader define todas as combinações de xyzw/ rgba/ stpq:)
kennytm

Respostas:

2

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
marcações
fonte
Esta resposta parece válida. Atualmente o líder.
Logic Knight
3

Pitão, 134 2 /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.

Frxstrem
fonte
Sua resposta parece válida. Planejei motivar os programadores a escrever um solucionador dinâmico com algum nível de introspecção, mas espero que essa abordagem de incorporar a resposta em uma sequência seja mais fácil. Suspiro.
Logic Knight
Você afirma que o desafio é mais enigmático do que programar é bem aceito. Eu adicionei um bônus por respostas que usam posicionamento em tempo de execução em seus programas. O estilo de impressão de string ainda é válido, mas espero ver mais soluções de programação que façam uso do bônus. Obrigado pela sua resposta e insights +1.
Logic Knight
Talvez eu esteja apenas perdendo alguma coisa, mas por stdout.writeque print, e não , e o que há format(not False or iter([]))no final? Você também pode facilmente adicionar como "é" ao lado do "sys" e um "para" abaixo "de" ...
aguardente
@aquavitae Você só pode usar identificadores usados ​​em seu programa com sintaxe válida, portanto o Frxstrem está incluindo os identificadores que serão usados ​​no quebra-cabeça. O programa não precisa fazer sentido ou ser eficiente.
Logic Knight
Ah, desculpe, aparentemente eu não li o problema corretamente. Nesse caso, você pode alterar a formatleitura paraiter([i for i in [not False is sys]])
aquavitae
0

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

nutki
fonte
Você detectou um dos problemas - os identificadores devem ocorrer pelo menos uma vez no seu código. Há outro problema. Você não deve usar bibliotecas que não são fornecidas no pacote de idiomas básico. Essa é uma regra necessária para interromper o uso de bibliotecas que proporcionariam vantagens injustas nesse desafio. Espero que você possa mudar sua abordagem e criar uma boa resposta Perl para o desafio.
Logic Knight