Cho đầu vào n, tạo ra một lưới từ có kích thước n, càng ít byte càng tốt.

Chi tiết

Số lượng được cung cấp sẽ luôn là số lẻ. Hình vuông trung tâm của lưới phải luôn trống (ký tự khoảng trắng). Các chữ cái điền vào lưới phải được chọn ngẫu nhiên từ phân phối chữ cái Scrabble của tiếng Anh . Nghĩa là, mỗi ô phải được chọn ngẫu nhiên, với xác suất đồng nhất, từ 100 ký tự sau:

??EEEEEEEEEEEEAAAAAAAAAIIIIIIIIIOOOOOOOONNNNNNRRRRRRTTTTTTLLLLSSSSUUUUDDDDGGGBBCCMMPPFFHHVVWWYYKJXQZ

nơi ?biểu thị gạch trống.

Như với một bảng Scrabble, một số ô trong bảng này cũng sẽ là các ô thưởng cho điểm cao hơn. Những gạch này chỉ được nhìn thấy trên một bảng với kích thước từ 9 trở lên. và nên được nhìn thấy mỗi 3 hàng từ hình vuông trung tâm trong một mẫu phát ra bên ngoài, nhưng không bao giờ xuất hiện trên các chữ cái ngoài cùng. Các ô vuông thưởng được biểu thị bằng các chữ cái viết thường, với các ô trống được xác định là !thay vì ?. Xin vui lòng xem trình diễn trực quan này hoặc thực hiện tham khảo để biết thêm ví dụ về cách phân phối chính xác các ô thưởng.

Ví dụ

Đầu vào: 5

Đầu ra:

VNZNT
IFOSN
UD VD
ZIOO?
KTLED

Đầu vào: 9

Đầu ra:

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

Thực hiện tham khảo .

Quy tắc

Đây là mã golf, vì vậy mã ngắn nhất tính bằng byte sẽ thắng.

• Bất kỳ định dạng hợp lý nào cũng có thể được sử dụng cho I / O, giả sử nó phù hợp.
• Bạn sẽ có thể xử lý lưới ít nhất lên tới 999.
• Tất cả các sơ hở tiêu chuẩn đều bị cấm.

Jelly ,  67 65 64 66 64  63 byte

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

Một liên kết đơn âm lấy một số và trả về một danh sách các ký tự hoặc một chương trình đầy đủ in kết quả.

Hãy thử trực tuyến! (Tôi thích nó sử dụngGhơn làYvì nó vuông hơn )

Làm sao?

”?;Ø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

cảm ơn @cole cho -1 byte, sắp xếp lại ?để thu gọn 2 thànhrep(2,10)

-10 byte nhận ra rằng row(m) == t(col(m))

-41 byte nhờ người dùng2390246 để cấu hình lại các trọng số, đánh gôn xuống chỉ mục và một số mẹo R thông thường hơn

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}

Hãy thử trực tuyến!

Trả về một ma trận. Thực hiện khá đơn giản; mẫu n ^ 2 giá trị với phân phối thích hợp, lưu trữ dưới dạng nxnma trận.

K là chỉ số của trung tâm.

L=col(m)là một ma trận chỉ ra số cột của mỗi phần tử trong ma trận. Do đó, chúng tôi tính toán !(L-K)%%3để có được các cột có thể (bao gồm cả các cạnh), tức là các cột có 3 cách xa cột trung tâm. Để loại bỏ các cạnh, chúng tôi xem xét L-1và L-n. L-1là 0(sai) cho cột đầu tiên và L-nlà 0cho cột cuối cùng. Áp dụng &(boolean phần tử khôn ngoan AND) cho ba điều này tạo ra một ma trận với TRUEtrong các cột đó là bội số của ba từ trung tâm, không bao gồm các cạnh. Chúng tôi lưu trữ kết quả này làx .

Nếu chúng ta chuyển vị trí của x, t(x)chúng ta sẽ có cùng một ma trận, nhưng đối với các hàng, do đó, x&t(x)là một ma trận chúng ta lưu dưới dạng icó chứa: TRUEcác chỉ số cho các ô bắt buộc và FALSEở mọi nơi khác.

Sau đó, chúng tôi sử dụng chartrđể thực hiện chuyển đổi cần thiết trên m[i]và lưu kết quả dưới dạng m[i], thay đổi ô trung tâm thành khoảng trắng và trả về ma trận.

Điều quan trọng như user2390246 đã chỉ ra , chúng tôi không cần kiểm tra n>=9vì vì n<7, không có bất kỳ ô nào cách xa trung tâm 3 (ngoài trung tâm được thay đổi thành khoảng trắng) và cho n==7các ô duy nhất bội số của 3 từ tâm nằm ở rìa nên chúng bị loại trừ. Khéo léo!

JavaScript (ES6), 247 242 byte

-5 byte với sự trợ giúp từ @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``

Kiểm tra đoạn trích

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

Hãy thử trực tuyến!

Lấy (n-3) / 2 làm đầu vào, trả về danh sách các danh sách các chữ cái.

Giải trình:

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

Hãy thử trực tuyến!

[C64 cơ bản v2, 210 209 byte]

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

Một đầu vào n5 có thể được chỉ định như

0dA5

Rằng "5" đến cuối nên được đổi thành bất kỳ số lẻ nào. Đừng cho hơn 25, sau đó chương trình sẽ ghi đè lên chính nó.

Cách dùng thử: google cho "trình giả lập phó c64", cài đặt nó và sao chép-dán mã cơ bản này vào nó. Để bắt đầu chương trình, gõ : RUN. Để xóa màn hình, nhấn shift / home.

Và kết quả:

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"

Hãy thử trực tuyến!

Tính đa bội của mỗi nhân vật được thể hiện dưới dạng tổng lũy ​​thừa của hai, ví dụ 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) có lẽ có thể được chơi golf