Dada a entrada n, produza uma grade de palavras de tamanho n, no menor número possível de bytes.

Detalhes

O número fornecido sempre será ímpar. O quadrado central da grade sempre deve estar vazio (um caractere de espaço). As letras que preenchem a grade devem ser escolhidas aleatoriamente na distribuição das letras em inglês Scrabble . Ou seja, cada bloco deve ser escolhido aleatoriamente, com probabilidade uniforme, dos 100 caracteres a seguir:

??EEEEEEEEEEEEAAAAAAAAAIIIIIIIIIOOOOOOOONNNNNNRRRRRRTTTTTTLLLLSSSSUUUUDDDDGGGBBCCMMPPFFHHVVWWYYKJXQZ

onde ?indica peças em branco.

Assim como em um tabuleiro de Scrabble, algumas peças deste tabuleiro também serão peças de bônus para uma pontuação mais alta. Esses blocos são visíveis apenas em um tabuleiro com um tamanho de 9 ou mais. e deve estar visível a cada 3 linhas do quadrado central em um padrão que emana para fora, mas nunca deve aparecer nas letras mais externas. Quadrados de bônus são indicados usando letras minúsculas, com blocos em branco identificados como em !vez de ?. Consulte esta demonstração visual ou a implementação de referência para obter mais exemplos de como distribuir corretamente os blocos de bônus.

Exemplos

Entrada: 5

Resultado:

VNZNT
IFOSN
UD VD
ZIOO?
KTLED

Entrada: 9

Resultado:

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

Implementação de referência .

Regras

Isso é código-golfe, portanto o código mais curto em bytes vence.

• Qualquer formato razoável pode ser usado para E / S, assumindo que seja consistente.
• Você deve ser capaz de lidar com grades de pelo menos até 999.
• Todas as brechas padrão são proibidas.

Geléia ,  67 65 64 66 64  63 bytes

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

Um link monádico que pega um número e retorna uma lista de caracteres ou um programa completo que imprime o resultado.

Experimente online! (Eu prefiro usarG, em vez deYuma vez que é mais quadrado )

Quão?

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

graças a @cole por -1 byte, reordenando o ?para recolher o 2 emrep(2,10)

-10 bytes percebendo que row(m) == t(col(m))

-41 bytes, graças ao user2390246 por reconfigurar os pesos, reduzir a indexação e algumas dicas R mais comuns

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}

Experimente online!

Retorna uma matriz. Implementação bastante simples; amostras n ^ 2 valores com a distribuição adequada, armazena como uma nxnmatriz.

K é o índice do centro.

L=col(m)é uma matriz que indica o número da coluna de cada elemento na matriz. Portanto, calculamos !(L-K)%%3para obter as possíveis colunas (incluindo as arestas), ou seja, aquelas com um múltiplo de 3 de distância da coluna central. Para remover as arestas, consideramos L-1e L-n. L-1é 0(falso) para a primeira coluna e L-né 0para a última coluna. A aplicação &(booleano por elementos AND) a esses três produz uma matriz com TRUEnessas colunas um múltiplo de três distante do centro, excluindo as arestas. Armazenamos esse resultado como x.

Se tomarmos a transposição de x, t(x)obteremos a mesma matriz, mas, para as linhas, x&t(x)é uma matriz que salvamos como icontendo: TRUEíndices para as células necessárias e em FALSEqualquer outro lugar.

Em seguida, usamos chartra execução da transformação necessária m[i]e salvamos o resultado m[i], alteramos a célula central para um espaço e retornamos a matriz.

É importante ressaltar que user2390246 apontou que não precisamos testar n>=9porque n<7, para , não há nenhuma célula a um número múltiplo de 3 distante do centro (além do centro que é alterado para um espaço de qualquer maneira) e n==7, para , as únicas células um múltiplo de 3 do centro está na aresta e é excluído. Arrumado!

JavaScript (ES6), 247 242 bytes

-5 bytes com a ajuda de @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``

Snippet de teste

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 153 bytes

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

Experimente online!

Pega (n-3) / 2 como entrada, retorna uma lista de listas de letras.

Explicação:

-> $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 , 246244 + 1 ( -n) = 247245 bytes

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

Experimente online!

[C64 básico 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

Uma entrada n5 pode ser especificada como

0dA5

Esse "5" até o final deve ser alterado para qualquer número ímpar. Não dê mais de 25, o programa substituirá a si próprio.

Como experimentá-lo: pesquise no google por "vice c64 emulator", instale-o e copie e cole esse código básico nele. Para iniciar o programa, digite: RUN. Para limpar a tela, pressione Shift / Página inicial.

E o resultado:

Python 3 , 214 236 240 bytes

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"

Experimente online!

A multiplicidade de cada caractere é expressa como soma de potências de dois, por exemplo 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) provavelmente pode ser jogado golfe.