nErstellen Sie bei gegebener Eingabe ein Wortraster mit einer Größe von nmöglichst wenigen Bytes.

Einzelheiten

Die angegebene Nummer ist immer ungerade. Das mittlere Quadrat des Gitters muss immer leer sein (ein Leerzeichen). Die Buchstaben, die das Raster füllen, müssen zufällig aus der englischen Scrabble-Buchstabenverteilung der Buchstaben ausgewählt werden. Das heißt, jede Kachel muss zufällig mit einheitlicher Wahrscheinlichkeit aus den folgenden 100 Zeichen ausgewählt werden:

??EEEEEEEEEEEEAAAAAAAAAIIIIIIIIIOOOOOOOONNNNNNRRRRRRTTTTTTLLLLSSSSUUUUDDDDGGGBBCCMMPPFFHHVVWWYYKJXQZ

wo ?bezeichnet leere Kacheln.

Wie bei einem Scrabble-Brett sind auch einige Kacheln in diesem Brett Bonusplättchen für eine höhere Punktzahl. Diese Kacheln sind nur auf einem Brett mit einer Größe von 9 oder mehr sichtbar. und sollte alle 3 Zeilen vom mittleren Quadrat in einem nach außen ausgehenden Muster sichtbar sein, sollte aber niemals auf den äußersten Buchstaben erscheinen. Bonusquadrate werden mit Kleinbuchstaben gekennzeichnet, wobei leere Kacheln als !anstelle von gekennzeichnet werden ?. In dieser visuellen Demonstration oder in der Referenzimplementierung finden Sie weitere Beispiele für die korrekte Verteilung von Bonusplättchen.

Beispiele

Eingang: 5

Ausgabe:

VNZNT
IFOSN
UD VD
ZIOO?
KTLED

Eingang: 9

Ausgabe:

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

Referenzimplementierung .

Regeln

Dies ist Code-Golf, also gewinnt der kürzeste Code in Bytes.

• Jedes vernünftige Format kann für E / A verwendet werden, sofern es konsistent ist.
• Sie sollten in der Lage sein, Gitter mit mindestens bis zu 999 zu verarbeiten.
• Alle Standardlücken sind verboten.

Gelee ,  67 65 64 66 64  63 Bytes

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

Ein monadischer Link, der eine Nummer nimmt und eine Liste von Zeichen zurückgibt, oder ein vollständiges Programm, das das Ergebnis druckt.

Probieren Sie es online aus! (Ich bevorzuge esGeher mit alsYweil das quadratischer ist )

Wie?

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

Dank @cole für -1 Byte, Neuordnung der, ?um die 2 in zu reduzierenrep(2,10)

-10 Bytes, die das erkennen row(m) == t(col(m))

-41 Bytes dank user2390246 für die Neukonfiguration der Gewichte, das Herunterspielen der Indizierung und einige weitere übliche R-Tipps

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}

Probieren Sie es online aus!

Gibt eine Matrix zurück. Ziemlich einfache Implementierung; tastet n ^ 2 Werte mit der richtigen Verteilung ab und speichert sie als nxnMatrix.

K ist der Index des Zentrums.

L=col(m)ist eine Matrix, die die Spaltennummer jedes Elements in der Matrix angibt. Daher berechnen wir !(L-K)%%3, um die möglichen Spalten (einschließlich der Kanten) zu erhalten, dh diejenigen, die ein Vielfaches von 3 von der mittleren Spalte entfernt sind. Um die Kanten zu entfernen, betrachten wir L-1und L-n. L-1ist 0(falsch) für die erste Spalte und L-nist 0für die letzte Spalte. Bewirbt sich& (elementweiser Boolescher Wert AND) auf diese drei ergibt eine Matrix mit TRUEin diesen Spalten ein Vielfaches von drei von der Mitte entfernt, ausgenommen die Kanten. Wir speichern dieses Ergebnis als x.

Wenn wir die Transponierte von nehmen x, erhalten t(x)wir dieselbe Matrix, jedoch für die Zeilenx&t(x) ist dies eine Matrix, die wir als ienthaltend speichern : TRUEIndizes für die erforderlichen Zellen und FALSEüberall sonst.

Dann benutzen wir chartr die erforderliche Transformation durch m[i]und speichern das Ergebnis als m[i], ändern die mittlere Zelle in ein Leerzeichen und geben die Matrix zurück.

Wie user2390246 hervorhob, müssen wir nicht testen, n>=9da für n<7keine Zellen ein Vielfaches von 3 von der Mitte entfernt ist (abgesehen von der Mitte, die ohnehin in ein Leerzeichen geändert wird) und für n==7die einzigen Zellen Ein Vielfaches von 3 von der Mitte befindet sich am Rand, sodass sie ausgeschlossen sind. Ordentlich!

JavaScript (ES6), 247 242 Byte

-5 Bytes mit Hilfe von @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``

Test-Snippet

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

Probieren Sie es online aus!

Nimmt (n-3) / 2 als Eingabe und gibt eine Liste von Buchstabenlisten zurück.

Erläuterung:

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

Probieren Sie es online aus!

[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

Ein Eingang n5 kann wie angegeben werden

0dA5

Diese "5" bis zum Ende sollte in eine ungerade Zahl geändert werden. Geben Sie nicht mehr als 25 an, dann überschreibt sich das Programm von selbst.

So probieren Sie es aus: googeln Sie nach "Vice C64 Emulator", installieren Sie es und kopieren Sie diesen Basiscode. Geben Sie zum Starten des Programms Folgendes ein : RUN. Drücken Sie Umschalt / Home, um den Bildschirm zu löschen.

Und das Ergebnis:

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"

Probieren Sie es online aus!

Die Vielzahl jedes Zeichens wird als Summe der Zweierpotenzen ausgedrückt, z 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) kann wahrscheinlich golfen.