Dada la entrada n, produzca una cuadrícula de palabras de tamaño n, en el menor número de bytes posible.

Detalles

El número proporcionado siempre será impar. El cuadrado central de la cuadrícula siempre debe estar vacío (un carácter de espacio). Las letras que llenan la cuadrícula deben elegirse al azar de la distribución de letras en inglés Scrabble . Es decir, cada ficha debe elegirse al azar, con probabilidad uniforme, de los siguientes 100 caracteres:

??EEEEEEEEEEEEAAAAAAAAAIIIIIIIIIOOOOOOOONNNNNNRRRRRRTTTTTTLLLLSSSSUUUUDDDDGGGBBCCMMPPFFHHVVWWYYKJXQZ

donde ?denota mosaicos en blanco.

Al igual que con un tablero de Scrabble, algunas fichas en este tablero también serán fichas de bonificación para una puntuación más alta. Estas fichas solo son visibles en un tablero con un tamaño de 9 o más. y debe ser visible cada 3 filas desde el cuadrado central en un patrón que emana hacia afuera, pero nunca debe aparecer en las letras más externas. Los cuadrados de bonificación se denotan con letras minúsculas, con mosaicos en blanco identificados como en !lugar de ?. Consulte esta demostración visual o la implementación de referencia para obtener más ejemplos sobre cómo distribuir correctamente los mosaicos de bonificación.

Ejemplos

Entrada: 5

Salida:

VNZNT
IFOSN
UD VD
ZIOO?
KTLED

Entrada: 9

Salida:

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

Implementación de referencia .

Reglas

Este es el código de golf, por lo que gana el código más corto en bytes.

• Se puede usar cualquier formato razonable para E / S, suponiendo que sea coherente.
• Debe poder manejar cuadrículas de al menos hasta 999.
• Todas las lagunas estándar están prohibidas.

Gelatina ,  67 65 64 66 64  63 bytes

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

Un enlace monádico que toma un número y devuelve una lista de caracteres, o un programa completo que imprime el resultado.

Pruébalo en línea! (Prefiero usarlo enGlugar de hacerlo,Yya que es más cuadrado )

¿Cómo?

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

gracias a @cole por -1 byte, reordenando el ?para colapsar el 2 enrep(2,10)

-10 bytes dándose cuenta de que row(m) == t(col(m))

-41 bytes gracias al usuario 2390246 por reconfigurar los pesos, jugar golf por la indexación y algunos consejos R más habituales

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}

Pruébalo en línea!

Devuelve una matriz. Implementación bastante simple; muestra n ^ 2 valores con la distribución adecuada, se almacena como una nxnmatriz.

K Es el índice del centro.

L=col(m)es una matriz que indica el número de columna de cada elemento en la matriz. Por lo tanto, calculamos !(L-K)%%3para obtener las posibles columnas (incluidos los bordes), es decir, aquellas a un múltiplo de 3 de la columna central. Para eliminar los bordes, consideramos L-1y L-n. L-1es 0(falso) para la primera columna y L-nes 0para la última columna. La aplicación &(elemento booleano AND) a estos tres produce una matriz con TRUEen esas columnas un múltiplo de tres fuera del centro, excluyendo los bordes. Almacenamos este resultado como x.

Si tomamos la transposición de x, t(x)obtenemos la misma matriz, pero para las filas, por x&t(x)lo tanto, es una matriz que guardamos como que icontiene: TRUEíndices para las celdas requeridas y en FALSEtodas partes.

Luego, usamos chartrpara realizar la transformación requerida m[i]y guardar el resultado como m[i], cambiar la celda central a un espacio y devolver la matriz.

Es importante destacar que, como señaló el usuario 2390246 , no necesitamos hacer una prueba n>=9porque n<7, para , no hay celdas a un múltiplo de 3 del centro (aparte del centro que se cambia a un espacio de todos modos), y para n==7, las únicas celdas un múltiplo de 3 desde el centro están en el borde, por lo que están excluidos. ¡Ordenado!

JavaScript (ES6), 247242 bytes

-5 bytes con ayuda 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``

Fragmento de prueba

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

Pruébalo en línea!

Toma (n-3) / 2 como entrada, devuelve una lista de listas de letras.

Explicación:

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

Pruébalo en línea!

[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

Una entrada n5 se puede especificar como

0dA5

Ese "5" hasta el final debe cambiarse a cualquier número impar. No dé más de 25, entonces el programa se sobrescribirá.

Cómo probarlo: google para "vice c64 emulator", instálalo y copia y pega este código básico en él. Para iniciar el programa, escriba: RUN. Para borrar la pantalla, presione shift / home.

Y el 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"

Pruébalo en línea!

La multiplicidad de cada personaje se expresa como la suma de las potencias de dos, por ejemplo 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) Probablemente pueda jugar al golf.