Input yang diberikan n, menghasilkan ukuran kotak kata n, dalam sesedikit mungkin byte.

Detail

Jumlah yang diberikan akan selalu aneh. Alun-alun pusat kotak harus selalu kosong (karakter spasi). Surat-surat yang mengisi kisi-kisi harus dipilih secara acak dari distribusi surat Scrabble huruf Inggris. Artinya, setiap ubin harus dipilih secara acak, dengan probabilitas seragam, dari 100 karakter berikut:

??EEEEEEEEEEEEAAAAAAAAAIIIIIIIIIOOOOOOOONNNNNNRRRRRRTTTTTTLLLLSSSSUUUUDDDDGGGBBCCMMPPFFHHVVWWYYKJXQZ

di mana ?menunjukkan ubin kosong.

Seperti halnya papan Scrabble, beberapa ubin di papan ini juga akan menjadi ubin bonus untuk skor yang lebih tinggi. Ubin ini hanya terlihat di papan dengan ukuran 9 atau lebih. dan harus terlihat setiap 3 baris dari alun-alun dalam pola yang keluar, tetapi seharusnya tidak pernah muncul pada huruf terluar. Kotak bonus dilambangkan dengan menggunakan huruf kecil, dengan ubin kosong diidentifikasi sebagai !gantinya ?. Silakan lihat demonstrasi visual ini atau implementasi referensi untuk lebih banyak contoh tentang cara mendistribusikan ubin bonus dengan benar.

Contohnya

Memasukkan: 5

Keluaran:

VNZNT
IFOSN
UD VD
ZIOO?
KTLED

Memasukkan: 9

Keluaran:

UWDESTKPW
ItDBaDEdI
TERMDYSTR
ROANJLEFT
EkCI OOsT
IPAJPGM?Y
MZLORETVI
G!EGgPUeI
MNROYOEER

Implementasi referensi .

Aturan

Ini adalah kode-golf sehingga kode terpendek dalam byte menang.

• Setiap format yang masuk akal dapat digunakan untuk I / O, dengan asumsi itu konsisten.
• Anda harus dapat menangani kisi-kisi setidaknya hingga 999.
• Semua celah standar dilarang.

Jelly ,  67 65 64 66 64  63 byte

”?;ØAx“³Ċu~Ṿr¥rṇ⁽ȦƑ’ḃ12¤µŒl⁾?!yW,WKF€
H3ṬṚ¤ṁ‘1¦ṚŒḄ0,0j«þ`ị¢X€€Y

Tautan monadik yang mengambil nomor dan mengembalikan daftar karakter, atau program lengkap mencetak hasilnya.

Cobalah online! (Saya lebih suka menggunakanGdaripadaYkarena itu lebih persegi )

Bagaimana?

”?;ØAx“³Ċu~Ṿr¥rṇ⁽ȦƑ’ḃ12¤µŒl⁾?!yW,WKF€ - Link 1, getLetterSets: no arguments
”?                                    - literal '?'
   ØA                                 - yield uppercase alphabet
  ;                                   - concatenate
                       ¤              - nilad followed by link(s) as a nilad:
      “³Ċu~Ṿr¥rṇ⁽ȦƑ’                  -   base 250 number
                    ḃ12               -   converted to bijective base 12 (frequencies)
     x                                -   times (repeat each)
                        µ             - start a new monadic chain, call that uppers
                         Œl           - to lower-case
                           ⁾?!        - literal ['?','!']
                              y       - translate (change '?'s to '!'s)
                               W      - wrap (that) in a list
                                 W    - wrap (uppers) in a list
                                ,     - pair
                                  K   - join with a space, ' '
                                   F€ - flatten €ach (both flattens the wrapped lists
                                      -               AND makes the lone ' ' into [' '])

H3ṬṚ¤ṁ‘1¦ṚŒḄ0,0j«þ`ị¢X€€Y - Main link: number, n                 e.g. 13
H                         - halve                                     6.5
    ¤                     - nilad followed by link(s) as a nilad:
 3                        -   literal three                           3
  Ṭ                       -   untruth                                 [0,0,1]
   Ṛ                      -   reverse                                 [1,0,0]
     ṁ                    - mould like (implicit range(int(right)))   [1,0,0,1,0,0]
        ¦                 - sparse application:
       1                  - ...to indices: 1
      ‘                   - ...action: increment                      [2,0,0,1,0,0]
         Ṛ                - reverse                                   [0,0,1,0,0,2]
          ŒḄ              - bounce                          [0,0,1,0,0,2,0,0,1,0,0]
            0,0           - literal [0,0]                             [0,0]
               j          - join                          [0,0,0,1,0,0,2,0,0,1,0,0,0]
                  `       - repeat left argument as right argument with:
                 þ        -   outer product using:       [[0,0,0,0,0,0,0,0,0,0,0,0,0],
                «         -     minimum                   [0,0,0,0,0,0,0,0,0,0,0,0,0],
                          -                               [0,0,0,0,0,0,0,0,0,0,0,0,0],
                          -                               [0,0,0,1,0,0,1,0,0,1,0,0,0],
                          -                               [0,0,0,0,0,0,0,0,0,0,0,0,0],
                          -                               [0,0,0,0,0,0,0,0,0,0,0,0,0],
                          -                               [0,0,0,1,0,0,2,0,0,1,0,0,0],
                          -                               [0,0,0,0,0,0,0,0,0,0,0,0,0],
                          -                               [0,0,0,0,0,0,0,0,0,0,0,0,0],
                          -                               [0,0,0,1,0,0,1,0,0,1,0,0,0],
                          -                               [0,0,0,0,0,0,0,0,0,0,0,0,0],
                          -                               [0,0,0,0,0,0,0,0,0,0,0,0,0],
                          -                               [0,0,0,0,0,0,0,0,0,0,0,0,0]]
                    ¢     - call the last link (1) as a nilad (the letter sets)
                   ị      - index into - gets the correct letter sets for each cell
                     X€€  - random-choice for €ach cell in €ach row
                        Y - join with newlines
                          - if running as a full program: implicit print

R , 288 281 267 257 225 214 byte

terima kasih kepada @cole untuk -1 byte, menata ulang ?untuk menciutkan 2 ke dalamrep(2,10)

-10 byte menyadari itu row(m) == t(col(m))

-41 byte terima kasih kepada user2390246 untuk mengkonfigurasi ulang bobot, menurunkan indeks, dan beberapa tips R biasa

function(n){m=matrix(sample(el(strsplit("EOAINRTLSUDGBCMPFHVW?YKJXQZ","")),n^2,T,rep(c(12,8,9,6,4:1),c(1,1:4,1,10,5))),,n)
K=n/2+.5
L=col(m)
m[i]=chartr("A-Z?","a-z!",m[i<-(x=!(L-K)%%3&L-1&L-n)&t(x)])
m[K,K]=" "
m}

Cobalah online!

Mengembalikan matriks. Implementasi yang cukup sederhana; nilai sampel n ^ 2 dengan distribusi yang tepat, disimpan sebagai nxnmatriks.

K adalah indeks pusat.

L=col(m)adalah matriks yang menunjukkan jumlah kolom setiap elemen dalam matriks. Oleh karena itu kami menghitung !(L-K)%%3untuk mendapatkan kolom yang mungkin (termasuk tepi), yaitu, kelipatan 3 dari kolom tengah. Untuk menghapus tepi, kami mempertimbangkan L-1dan L-n. L-1adalah 0(palsu) untuk kolom pertama dan L-nadalah 0untuk kolom terakhir. Menerapkan &(elemen-boolean bijaksana AND) untuk tiga ini menghasilkan matriks dengan TRUEdi kolom tersebut kelipatan tiga dari pusat, tidak termasuk tepi. Kami menyimpan hasil ini sebagai x.

Jika kita mengambil transpos dari x,, t(x)kita mendapatkan matriks yang sama, tetapi untuk baris, maka x&t(x)merupakan matriks yang kita simpan sebagai imengandung: TRUEindeks untuk sel yang diperlukan, dan di FALSEtempat lain.

Kemudian kita gunakan chartruntuk melakukan transformasi yang diperlukan m[i]dan menyimpan hasilnya sebagai m[i], mengubah sel pusat ke spasi, dan mengembalikan matriks.

Yang penting seperti yang ditunjukkan oleh user2390246 , kita tidak perlu menguji n>=9karena n<7, tidak ada sel kelipatan 3 dari pusat (selain dari pusat yang diubah menjadi spasi), dan untuk n==7, satu-satunya sel kelipatan 3 dari pusat berada di tepi sehingga tidak termasuk. Rapi!

JavaScript (ES6), 247 242 byte

-5 byte dengan bantuan dari @Shaggy

n=>[...Array(p=n*n)].map((_,i)=>i==p>>1?" ":g(i/n|0)&g(i%n,c="AI9O8NRTEE6LSUD4G3BCMPFHVWY?2KJXQZ".replace(/(\D+)(\d)/g,(_,c,i)=>c.repeat(i))[Math.random()*100|0])?c<"A"?"!":c.toLowerCase():++i%n?c:c+`
`,g=x=>x&&x<n-1&((n>>1)-x)%n%3==0).join``

Cuplikan Tes

let f=
n=>[...Array(p=n*n)].map((_,i)=>i==p>>1?" ":g(i/n|0)&g(i%n,c="AI9O8NRTEE6LSUD4G3BCMPFHVWY?2KJXQZ".replace(/(\D+)(\d)/g,(_,c,i)=>c.repeat(i))[Math.random()*100|0])?c<"A"?"!":c.toLowerCase():++i%n?c:c+`
`,g=x=>x&&x<n-1&((n>>1)-x)%n%3==0).join``

;(R.onclick=L.onchange=I.oninput=function(){let n=+I.value,res=f(n);O.innerText=n+"\n"+(L.checked?res.replace(/[A-Z\?]/g,".").replace(/[a-z!]/g,"#"):res);})()

<label><input id=L type=checkbox> Layout only</label> <button id=R>Rerun</button><br><input id=I type=range min=9 max=53 step=2 value=9 style="width:100%">
<pre id=O></pre>

Perl 6 , 162 161 154 153 byte

{(my@b=0,|(-$^m..$m).map({$_%%3+!$_}),0).map:{((my$e='AIJKQXZG'~'NRTBCFHMPVWYG'x 2~'EEEAAIIOONRTUSLD'x 4)~'??',$e.lc~'!!',' ')[@b Xmin$_]».comb».roll}}

Cobalah online!

Mengambil (n-3) / 2 sebagai input, mengembalikan daftar daftar huruf.

Penjelasan:

-> $m {
    # Idea stolen from @Xcali's answer.
    my $e = 'AIJKQXZG' ~ 'NRTBCFHMPVWYG' x 2 ~ 'EEEAAIIOONRTUSLD' x 4;
    # Array containing 1 for bonus tiles, 2 for middle element, like
    #     (0,1,0,0,1,0,0,2,0,0,1,0,0,1,0)
    my @b = 0, |(-$m..$m).map({ $_ %% 3 + !$_ }), 0;
    # Map column vector.
    @b.map: {
        # Compute element-wise minimum of row vector and value from
        # column vector. Select character pools accordingly and get
        # random items.
        ($e~'??', $e.lc~'!!', ' ')[@b Xmin $_]».comb».roll
    }
}

Perl 5 , 246 244 + 1 ( -n) = 247 245 byte

$m=($n=$_-$_%2)/2;for(@a=(U x++$n)x$n){$_=(LUU,ULU,UUL)[$m%3]x($n/3).U x($n%3)if$z%@a&&$z%3==$m%3;substr$_,$m,1,$"if$m==$z++;s/L/-U/g;s/U/substr"EEAIONRT"x6 .AIJKQXZG."AIO?BCFHMPVWYGUUSSLLDD"x2,rand 100,1/ge;s/^-//;s/-\?/!/g;s/-(.)/lc$1/ge;say}

Cobalah online!

[C64 basic v2, 210 209 bytes]

1t$="2?9E3E9A9I8O6N6R6T4L4S4U4D3G2B2C2M2P2F2H2V2W2Y1K1J1X1Q1Z":rEn
3fOx=1ton:fOy=1ton:a=rN(0)*100:b=1
4c=aS(mI(t$,b,1))-48:d=aS(mI(t$,b+1,1)):b=b+2:ifc>atH6
5a=a-c:gO4
6pO983+40*y+x,c:nE:nE:pO1003.5+n*20.5,32

Input n5 dapat ditentukan seperti

0dA5

Angka "5" sampai akhir harus diubah ke angka ganjil. Jangan memberi lebih dari 25, maka program akan menimpa dirinya sendiri.

Cara mencobanya: google for "vice c64 emulator", instal, dan salin-tempel kode dasar ini ke dalamnya. Untuk menjalankan program ini, ketik: RUN. Untuk menghapus layar, tekan shift / home.

Dan hasilnya:

Python 3 , 214 236 240 byte

lambda n:[[[choice([s,[[c.lower(),'!'][c<'A']for c in s]][((i-n//2)%3+(j-n//2)%3<1)*(i*j>0)*(i<n-1)*(j<n-1)])," "][i==j==n//2]for j in range(n)]for i in range(n)]
from random import*
s=(("OIAE"*2+"SDLUNTRE")*2+"HVBMCYPWF?GNTR")*2+"ZXJQKGIA"

Cobalah online!

Multiplisitas masing-masing karakter dinyatakan sebagai jumlah kekuatan dua, misalnya 12 = 8 + 4 => "E"*12 = "E"*2*2*2 + "E"*2*2.

((i-n//2)%3+(j-n//2)%3<1)*(i*j>0)*(i<n-1)*(j<n-1) mungkin bisa bermain golf.