Sekarang dengan BONUS untuk penempatan run-time.

Tulis program untuk mengisi kotak teks dengan pengidentifikasi yang digunakan dalam program Anda sambil menjaga program Anda kecil. Dengan semua pengidentifikasi yang Anda gunakan (tidak termasuk yang Anda buat) dalam program Anda, isi kotak 12x6 dengan sebanyak yang Anda bisa. Anda mendapatkan poin tambahan untuk pengidentifikasi yang menyeberang (gaya teka-teki silang), tetapi mereka tidak dapat bergabung ujung ke ujung.

Keluaran

Program Anda harus mencetak (untuk stdout) kotak karakter 12x6 dengan pengidentifikasi dikemas dan #perbatasan. Kotak harus memiliki kolom berlabel huruf AL dan baris 1-6 (diberi spasi seperti contoh di bawah). Kemudian cetak garis untuk setiap pengenal yang digunakan. Setiap baris akan memiliki lokasi huruf pertama, pengenal itu sendiri, dan skor. Skor sama dengan jumlah huruf dalam pengidentifikasi dengan kemungkinan '+ bonus' ditambahkan. Pengidentifikasi mendapat bonus 5 poin untuk setiap surat yang dibagikan dengan pengenal persimpangan. Baris terakhir melaporkan 'TOTAL:' dan jumlah skor pengidentifikasi. Contoh output untuk program Python yang mungkin akan terlihat seperti ini:

   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

Catatan:

• Pengidentifikasi dapat dilepaskan (seperti di importatas).
• Anda tidak dapat bergabung popdan printsegaris dengan poprint.
• String indi dalamnya inserttidak dapat digunakan. Kata-kata yang bergabung harus ortogonal.
• Pengidentifikasi dapat ditempatkan di sebelah satu sama lain (seperti popdan di insertatas).

Jawaban Anda harus mencakup keluaran program Anda dengan kode sumber Anda dan judul yang terdiri dari nama bahasa dan skor Anda.

Skor

Skor Anda untuk tantangan akan skor puzzle kuadrat dibagi dengan ukuran kode sumber Anda (dalam byte). Contoh: Teka-teki di atas dengan program 300 byte akan menghasilkan skor 55*55/300 = 10.08. Kemenangan skor tertinggi.

Aturan

• Anda dapat menggunakan pengidentifikasi apa pun di program Anda yang tidak ditentukan oleh Anda. Kata kunci, nama kelas, nama metode, nama pustaka, dan nama fungsi bawaan adalah contoh pengidentifikasi yang memenuhi syarat.
• Diedit: Anda hanya dapat menggunakan perpustakaan standar yang disertakan dengan rilis bahasa minimum. Paket bahasa yang diperluas dan penggunaan perpustakaan eksternal (sekarang) dilarang. Sejumlah besar perpustakaan dengan daftar pengidentifikasi yang luas akan mengacaukan tantangan ini. Jika Anda tidak yakin bagaimana ini bekerja dengan bahasa Anda, silakan tinggalkan pertanyaan di komentar.
• Pengidentifikasi hanya terdiri dari karakter [a-zA-Z_] dan memiliki setidaknya 2 karakter.
• Anda hanya dapat menggunakan setiap pengidentifikasi satu kali dalam puzzle.
• Pengidentifikasi hanya dapat digunakan dari kiri ke kanan atau ke bawah.

Bonus Dinamis!

Jika kode Anda menentukan di mana harus menempatkan pengidentifikasi pada waktu berjalan, bonus surat bersama akan menjadi 20 dan bukan 5. Anda dapat mendaftar pengidentifikasi mana yang akan digunakan, tetapi kode Anda harus memutuskan di mana dalam kotak untuk menempatkannya. Kode Anda juga harus menghitung dan mencetak daftar skor. Jika penempatan Anda bergantung pada urutan daftar pengidentifikasi, pasangan kode-keras, atau jalan pintas penempatan non-dinamis lainnya, Anda tidak memenuhi syarat untuk Bonus Dinamis.

Pada contoh output di atas, skor puzzle untuk program penempatan run-time akan menjadi 145. Kemudian jika kodenya 800 byte, skornya adalah 145*145/800 = 26.28.

Bonus Dinamis dirancang untuk menghargai algoritma yang cerdas daripada string solusi hard-kode statis, dan mengimbangi ukuran kode sumber yang dihasilkan lebih besar.

EDIT:

• Pustaka yang diubah hanya digunakan untuk pustaka yang memiliki bahasa minimum.
• Menambahkan opsi bonus dinamis.

STATA, 387 ^ 2/677 = 221.2

Saya menjadi malas dan hanya ingin menampilkan sesuatu yang berhasil sebelum mencoba untuk mendapatkannya dengan skor optimal. Saya mungkin akan memperbaruinya nanti karena saya memasukkan lebih banyak kata, dan saya terbuka untuk saran dari siapa pun yang menggunakan STATA (yang sepertinya tidak terlalu populer di CodeGolf). STATA sangat bagus memiliki banyak perintah / parameter dua huruf. Juga, biasanya sebagian besar dapat dipersingkat untuk menyimpan karakter / lebih cocok (yaitu tampilan dapat ditampilkan, displa, displ, disp, dis, atau di). Selain itu, tangkapan berarti menahan pesan keluaran dan kesalahan. Jadi seluruh loop sementara memiliki 0 output.

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

menghasilkan

   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

Jika saya telah memahami aturan dengan benar, ini harus merupakan kiriman yang valid.

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

Anda benar-benar dapat terus meningkatkan skor Anda dengan menambahkan lebih banyak pengidentifikasi: ukuran program meningkat secara linear (sekitar dua kali panjang pengidentifikasi), sementara skor meningkat sekitar kuadrat dari panjang pengidentifikasi. Maka tantangannya menjadi lebih bagaimana menjejalkan sebagian besar kata kunci ke dalam kotak daripada bagaimana menulis program pendek untuk melakukannya.

Perl, 728 ² /639 = 829,4

Oh well, ini tidak valid, saya harus memiliki pengidentifikasi dalam kode saya.

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

Ini membutuhkan modul perl refleksi ( B::Keywords). Dapat diinstal di ubuntu dengan sudo apt-get install libb-keywords-perl. Dengan seed yang diberikan pada kode di atas, ia menghasilkan jawaban 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

Perhatikan bahwa versi perl yang berbeda mungkin memiliki RNG yang berbeda dan daftar kata kunci yang berbeda, tetapi juga harus mudah menemukan seed dengan hasil yang sebanding.