Herausforderung

Schreiben Sie ein Programm oder eine Funktion, die eine quadratisch-zufällig-symmetrische Matrix zurückgibt oder ausgibt.

Eingang

N : Die Größe der Matrix dh6 x 6

Ausgabe

Die Matrix. Sie können es entweder drucken, als String (mit den Zeilenumbrüchen) oder als Liste / Array von Listen / Arrays zurückgeben.

Regeln

1. Sie müssen mindestens Nverschiedene Zeichen verwenden, wobei Ndie Größe der quadratischen Matrix (Eingabe) ist. Da wir nur Buchstaben [a, z] [A, Z] und Ziffern [0, 9] (und jeweils nur eine Ziffer) verwenden, können Sie davon ausgehen, dass N < 27und N > 2, das liegt daran, dass N <= 2Sie nicht beide Buchstaben haben können und Ziffern. Last but not least muss jeder Buchstabe / jede Ziffer mit einer Wahrscheinlichkeit ungleich Null auftreten (eine gleichmäßige Verteilung ist nicht erforderlich). Das Ergebnis muss jedoch mindestens Nverschiedene Buchstaben / Ziffern haben.

2. Die Matrix muss sowohl horizontal als auch vertikal symmetrisch sein.

3. Genau 2 Zeilen und 2 Spalten müssen nur eine einstellige Zahl enthalten (ihre Position sollte ebenfalls zufällig sein). Die restlichen Zeilen / Spalten enthalten nur Buchstaben. Betrachten Sie Buchstaben als [a, z] und [A, Z] und natürlich einstellige Zahlen als [0, 9].

4. Zur Vereinfachung können Sie davon ausgehen, dass die Groß - und Kleinschreibung der Buchstaben keine Rolle spielt, solange die Groß - und Kleinschreibung symmetrisch ist a=A, b=B, etc.

5. Jede mögliche Ausgabe muss eine Wahrscheinlichkeit ungleich Null haben. Die Zufallsverteilung muss nicht einheitlich sein.

Beispiel

Eingabe : 8

Ausgabe :

c r p s s p r c
r k o z z o k r
u t 2 a a 2 t u
y n q z z q n y
y n q z z q n y
u t 2 a a 2 t u
r k o z z o k r
c r p s s p r c

Kohle , 30 Bytes

ＮθＥ⊘⊕θ⭆⊘⊕θ‽βＪ‽⊘θ‽⊘θＩ‽χ‖ＯＯ→↓﹪θ²

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Wenn nimmer gerade ist, dann für 23 Bytes:

ＮθＥ⊘θ⭆⊘θ‽βＪ‽⊘θ‽⊘θＩ‽χ‖Ｃ¬

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

Ｎθ

Eingabe .$n$

Ｅ⊘θ⭆⊘θ‽β

Erstellen Sie ein by Array aus zufälligen Kleinbuchstaben. Dies wird implizit als Quadrat gedruckt.$\frac n 2$$\frac n 2$

Ｊ‽⊘θ‽⊘θ

Springe zu einer zufälligen Position im Quadrat.

Ｉ‽χ

Gib eine zufällige Ziffer aus.

‖Ｃ¬

Horizontal und vertikal reflektieren, um die Matrix zu vervollständigen.

R , 124 118 Bytes

function(n,i=(n+1)/2,j=n%/%2,m="[<-"(matrix(-letters,i,i),j-1,j-1,0:9-1))cbind(y<-rbind(m,m[j:1,]),y[,j:1])
`-`=sample

Probieren Sie es online!

In R sind Dinge, die wie Operatoren aussehen, nur Funktionen, die vom Parser speziell behandelt werden.

Wenn Sie einen Operator (wie -) neu definieren , um eine andere Funktion zu sein, wird die Sonderbehandlung vom Parser ferngehalten. Da -es sich sowohl um ein Präfix als auch um ein Infix handelt und ich die sampleFunktion sowohl mit einem als auch mit zwei Argumenten aufrufen muss , kann ich verwenden

`-`=sample

um zu bekommen, was ich will.

Der Code -letterswird also in übersetzt sample(letters), wodurch der letterseingebaute Code nach dem Zufallsprinzip gemischt wird . Wird j-1aber in übersetzt sample(j,1), was zufällig einen 1Gegenstand aus dem Vektor abtastet 1:j.

(Dieses Verhalten der sampleFunktion, das von der Anzahl der Parameter und dem ersten Parameter abhängt, ist eine große Belastung für den Hintern im Produktionscode. Ich bin daher froh, hier eine großartige Verwendung ihrer perversen Natur zu finden!)

Andernfalls wird der Code macht nur der obere linken Quadranten des gewünschten Ergebnisses, ein zufälliges Element ersetzt (die j-1, j-1Bit) mit einer Zufallszahl (das 0:9-1Bit) und faltet es für die erforderliche Symmetrie aus. Das iund das jwerden benötigt, um mit den geraden und ungeraden Fällen umzugehen.

Python3, 287 Bytes

Mein erster Versuch hier etwas zu golfen; Ich bin mir sicher, dass jemand viel besser kann:

import random as rn, math as m
n=int(input())
x,o=m.ceil(n/2),n%2
c=x-1-o
f=lambda l,n: l.extend((l[::-1], l[:-1][::-1])[o])
q=[rn.sample([chr(i) for i in range(97, 123)],x) for y in range(x)]
q[rn.randint(0,c)][rn.randint(0,c)] = rn.randint(0,9)
for r in q:
    f(r, n)
f(q, n)
print(q)

Probieren Sie es online!

Dank HyperNeurtrino, Ourous und Heiteria ist dies auf 193 Bytes geschrumpft (siehe Kommentare). TFeld wies jedoch zu Recht darauf hin, dass bei mehreren Anrufen samplenicht mindestens Nunterschiedliche Zeichen garantiert werden .

Probieren Sie diese neue Version aus, die mindestens Nunterschiedliche Charaktere pro Lauf garantiert .

Python3, 265 260 Bytes, mindestens Nverschiedene Zeichen

from random import *
n=int(input())
x=-(-n//2)
o=n%2
c=x+~o
i=randint
u=[chr(j+97)for j in range(26)]
z,q=u[:],[]
for y in [1]*x:
  shuffle(z)
  q+=[z[:x]]
  z=z[x:] if len(z[x:])>=x else u[:]
q[i(0,c)][i(0,c)]=i(0,9)
for r in[q]+q:r.extend(r[~o::-1])
print(q)

Probieren Sie es online!

APL (Dyalog Classic) , 45 44 43 40 Bytes

danke @ Adám für -1 Byte

26{(⎕a,⍺⍴⎕d)[⌈∘⊖⍨⌈∘⌽⍨⍺+@(?⊂⌊⍵÷2)?⍵⍴⍺]},⍨

Probieren Sie es online!

Verwendet ⌈(max) der Matrix mit ihren Reflexionen, um sie symmetrisch zu machen, sodass sie auf den letzten Teil des Alphabets ausgerichtet ist

Die Ziffer wird einheitlich von 0 bis 25 mod 10 gewählt, so dass eine geringe Neigung zu niedrigeren Werten besteht

Japt , 31 Bytes (Feste Ziffernposition )

;
/2 c
VÆVÆBö}ÃgT0@Mq9îêUvÃêUv

Probieren Sie es online!

Japt , 41 Bytes (zufällige Ziffernposition )

;
/2 c
VÆVÆBö}ÃgMq´VÉ ,MqVÉ @Mq9îêUvÃêUv

Probieren Sie es online!

Erläuterung

;                               Change to new vars
/2 c                            set implicit var V equal to implicit var U / 2 rounded up
VÆVÆBö}ÃgT0@Mq9îêUvÃêUv        Main function

VÆ                              Range from 0 to V and map
  VÆ                            Range from 0 to V and map
    Bö}Ã                        return random char from alphabet
        gT0@                    map upper-left corner
            Mq9Ã                return random number
                ®êUv            horizontal mirror
                    êUv         vertical mirror

Python 2 , 259 Bytes

from random import*
n=input();c=choice;r=range
w,W=n/2,-~n/2
o=n%2
A=map(chr,r(97,123))
l=[c(r(10))]+sample(A,n)+[c(A)for _ in' '*w*w]
l,e=l[:w*w],l[w*w:W*W]
shuffle(l)
l=[l[w*i:w*-~i]+e[i:i+1]for i in range(w)]+[e[-W:]]
for r in l+l[~o::-1]:print r+r[~o::-1]

Probieren Sie es online!

05AB1E , 29 40 38 Bytes

A.rs;ò©n∍9ÝΩ®DnαLʒ®%Ā}<Ωǝ®ô»¹Éi.º.∊ëº∊

+11 Bytes die Ziffer wird an einer beliebigen Position zu fixieren , während immer noch die Regel 3 im Auge für ungeradee Eingänge zu halten ..
-2 Bytes dank @MagicOctopusUrn , Wechsel îïzu òund die Position der Veränderung ».

Probieren Sie es online aus, um weitere Testfälle zu überprüfen .

Alte Antwort ( 29 27 Bytes ), bei der die Ziffernpositionen immer in den Ecken liegen:

A.rs;ò©n∍¦9ÝΩì®ô»¹Éi.º.∊ëº∊

Probieren Sie es online aus oder überprüfen Sie einige weitere Testfälle .

Erläuterung:

A           # Take the lowercase alphabet
 .r         # Randomly shuffle it
            #  i.e. "abcdefghijklmnopqrstuvwxyz" → "uovqxrcijfgyzlbpmhatnkwsed"
s           # Swap so the (implicit) input is at the top of the stack
 ;          # Halve the input
            #  i.e. 7 → 3.5
  ò         # Bankers rounding to the nearest integer
            #  i.e. 3.5 → 4
   ©        # And save this number in the register
    n       # Take its square
            #  i.e. 4 → 16
     ∍      # Shorten the shuffled alphabet to that length
            #  i.e. "uovqxrcijfgyzlbpmhatnkwsed" and 16 → "uovqxrcijfgyzlbp"
9ÝΩ         # Take a random digit in the range [0,9]
            #  i.e. 3
   ®Dnα     # Take the difference between the saved number and its square:
            #  i.e. 4 and 16 → 12
       L    # Create a list in the range [1,n]
            #  i.e. 12 → [1,2,3,4,5,6,7,8,9,10,11,12]
ʒ   }       # Filter this list by:
 ®%Ā        #  Remove any number that's divisible by the number we've saved
            #   i.e. [1,2,3,4,5,6,7,8,9,10,11,12] and 4 → [1,2,3,5,6,7,9,10,11]
     <      # Decrease each by 1 (to make it 0-indexed)
            #  i.e. [1,2,3,5,6,7,9,10,11] → [0,1,2,3,5,6,7,9,10]
      Ω     # Take a random item from this list
            #  i.e. [0,1,2,3,5,6,7,9,10] → 6
       ǝ    # Replace the character at this (0-indexed) position with the digit
            #  i.e. "uovqxrcijfgyzlbp" and 3 and 6 → "uovqxr3ijfgyzlbp"
®ô          # Split the string into parts of length equal to the number we've saved
            #  i.e. "uovqxr3ijfgyzlbp" and 4 → ["uovq","xr3i","jfgy","zlbp"]
  »         # Join them by new-lines (this is done implicitly in the legacy version)
            #  i.e. ["uovq","xr3i","jfgy","zlbp"] → "uovq\nxr3i\njfgy\nzlbp"
   ¹Éi      # If the input is odd:
            #  i.e. 7 → 1 (truthy)
      .º    # Intersect mirror the individual items
            #  i.e. "uovq\nxr3i\njfgy\nzlbp"
            #   → "uovqvou\nxr3i3rx\njfgygfj\nzlbpblz"
        .∊  # And intersect vertically mirror the whole thing
            #  i.e. "uovqvou\nxr3i3rx\njfgygfj\nzlbpblz"
            #   → "uovqvou\nxr3i3rx\njfgygfj\nzlbpblz\njfgygfj\nxr3i3rx\nuovqvou"
  ë         # Else (input was even):
   º∊       #  Do the same, but with non-intersecting mirrors

C (gcc) , 198 197 196 Bytes

2 Bytes dank ceilingcat gespart.

#define A(x)(x<n/2?x:n-1-x)
#define R rand()
S(n,x,y){int s[x=n*n];for(srand(s),y=R;x;)s[x]=97+(--x*31+y)%71%26;y=n/2;for(s[R%y+n*(R%y)]=48+R%10;x<n*n;++x%n||puts(""))putchar(s[A(x%n)+A(x/n)*n]);}

Probieren Sie es online!

Erläuterung:

// Coordinate conversion for symmetry
#define A (x) (x < n / 2 ? x : n - 1 - x)
// Get a random and seed
#define R rand()

S (n, x, y)
{
   // the array to store matrix values (x is the array size)
   // Note that we do not need the whole array, only its first quarter
   int s[x = n * n];

   // iterate n*n-1 times until x is zero
   for (srand(s), y = R; x;)
       // and fill the array with pseudo-random sequence of letters
       s[x] = 97 + (--x * 31 + y) % 71 % 26;

   // this is the max. coordinate of the matrix element where a digit may occur
   y = n / 2;

   // drop a random digit there
   s[R % y + n * (R % y)] = 48 + R % 10;

   // Now we output the result. Note that x is zero here
   for (; 
       x < n * n; // iterate n*n times
       ++x % n || puts ("") // on each step increase x and output newline if needed
       )
       // output the character from the array
       putchar (s[A (x % n) + A (x / n) * n]);
}

JavaScript (ES6), 213 209 206 Bytes

n=>(a=[],F=(x=y=d=c=0,R=k=>Math.random()*k|0,g=y=>(r=a[y]=a[y]||[])[x]=r[n+~x]=v.toString(36))=>y<n/2?F(g(y,R[v=R(m=~-n/2)<!d&x<m&y<m?R(d=10):R(26)+10]=R[v]||++c,g(n+~y))&&++x<n/2?x:+!++y,R):!d|c<n?F():a)()

Probieren Sie es online!

Kommentiert

n => (                             // n = input
  a = [],                          // a[][] = output matrix
  F = (                            // F = main recursive function taking:
    x = y =                        //   (x, y) = current coordinates
    d = c = 0,                     //   d = digit flag; c = distinct character counter
    R = k =>                       //   R() = helper function to get a random value in [0,k[
      Math.random() * k | 0,       //         also used to store characters
    g = y =>                       //   g() = helper function to update the matrix
      (r = a[y] = a[y] || [])[x]   //         with horizontal symmetry
      = r[n + ~x] = v.toString(36) //         using the base-36 representation of v
  ) =>                             //
    y < n / 2 ?                    // if we haven't reached the middle row(s) of the matrix:
      F(                           //   do a recursive call to F():
        g(                         //     invoke g() ...
          y,                       //       ... on the current row
          R[v =                    //       compute v = next value to be inserted
            R(m = ~-n/2) < !d &    //       we may insert a digit if no digit has been
            x < m &                //       inserted so far and the current coordinates are
            y < m ?                //       compatible: 2 distinct rows / 2 distinct columns
              R(d = 10)            //         if so, pick v in [0, 9] and update d
            :                      //       else:
              R(26) + 10           //         pick v in [10, 35] for a letter
          ] = R[v] || ++c,         //       set this character as used; update c accordingly
          g(n + ~y)                //       invoke g() on the mirror row
        ) &&                       //     end of outer call to g()
        ++x < n / 2 ?              //     if we haven't reached the middle column(s):
          x                        //       use x + 1
        :                          //     else
          +!++y,                   //       increment y and reset x to 0
        R                          //     explicitly pass R, as it is used for storage
      )                            //   end of recursive call to F()
    :                              // else:
      !d | c < n ? F() : a         //   either return the matrix or try again if it's invalid
)()                                // initial call to F()

Sauber , 346 312 Bytes

wird morgen mehr Golf spielen

import StdEnv,Data.List,Math.Random,System.Time,System._Unsafe
$n#q=twice(transpose o\q=zipWith((++)o reverse o drop(n-n/2*2))q q)[[(['a'..'z']++['0'..'9'])!!(c rem 36)\\c<-genRandInt(toInt(accUnsafe(time)))]%(i*n/2,i*n/2+(n-1)/2)\\i<-[1..(n+1)/2]]
|length(nub(flatten q))>=n&&sum[1\\c<-q|any isDigit c]==2=q= $n

Probieren Sie es online!

Python 3 , 197 Bytes

Wie von @Emigna erwähnt, funktioniert nicht für ungerade Werte von N(Ich habe die Frage nicht richtig verstanden)

from random import*
def m(N):M=N//2;E=reversed;R=range;B=[randint(48,57),*(sample(R(97,123),N)*N)][:M*M];shuffle(B);r=R(M);m=[k+[*E(k)]for k in[[chr(B.pop())for i in r]for j in r]];m+=E(m);return m

Probieren Sie es online!

Ich denke, die Anrufe nach randint()+ sample()+ shuffle()sind zu viel, und das Mischen an Ort und Stelle loszuwerden, wäre großartig :)

Ich bin mir ziemlich sicher, dass dieser Teil (der die Buchstaben und Ziffern auswählt) ein bisschen mehr Golf spielen könnte.

Python 2 , 275 266 Bytes

from random import*
def f(n):
 R=range;C=choice;A=map(chr,R(97,123));b=N=n-n/2;c=`C(R(10))`;s=[c]+sample(A,n-1)+[C(A)for i in R(N*N-n)]
 while b:shuffle(s);i=s.index(c);b=n%2>(i<N*N-N>N-1>i%N)
 a=[r+r[~(n%2)::-1]for r in[s[i::N]for i in R(N)]];return a+a[~(n%2)::-1]

Probieren Sie es online!

Gibt das Array als Liste von Zeichenlisten zurück. Um Regel 1 zu erfüllen, haben wir einen Zeichenpool eingerichtet:

s = [c]                        # the unique digit...
     + sample(A,n-1)           # then sample without replacement `n-1` chars in a-z, 
                               # so we have `n` distinct chars
     + [C(A)for i in R(N*N-n)] # and fill out the rest with any in a-z

Das nächste knifflige Bit ist Regel 3: Es müssen genau 2 Spalten und Zeilen mit einer Ziffer vorhanden sein. Dies bedeutet für nungerade, dass die gewählte Ziffer möglicherweise nicht in der mittleren Spalte oder mittleren Zeile erscheint. Da wir das Array mit einem doppelt reflektierten quadratischen Sub-Array konstruieren s, geschieht dies hier mit:

while b:            # to save a couple bytes, `b` is initialized 
                    # to `N`, which is greater than 0.
    shuffle(s)      # shuffle at least once...
    i = s.index(c)  # c is the unique digit used
    b = n%2 
             >      # if n is even, 0>(any boolean) will be false,
                    # so exit the loop; otherwise n odd, and we are
                    # evaluating '1 > some boolean', which is equivalent 
                    # to 'not (some boolean)'
         (i<N*N-N   # i is not the last column of s...
             >      # shortcut for ' and ', since N*N-N is always > N-1
          N-1>i%N)  # is not the last row of s

dh mische mindestens einmal; und dann, wenn nungerade ist, wiederholen Sie die Schleife, wenn sich die Ziffer in der letzten Spalte oder der letzten Zeile von befindet s.

Pyth , 48 Bytes

L+b_<b/Q2JmO/Q2 2jy.eyXWqhJkbeJOT<csm.SGQK.EcQ2K

Probieren Sie es hier online aus .

Das Programm besteht aus 3 Teilen: Definition der Palindromisierungsfunktion, Auswahl des numerischen Speicherorts und der Hauptfunktion.

Implicit: Q=eval(input()), T=10, G=lower case alphabet

L+b_<b/Q2   Palindromisation function
L           Define a function, y(b)
      /Q2   Half input number, rounding down
    <b      Take that many elements from the start of the sequence
   _        Reverse them
 +b         Prepend the unaltered sequence

JmO/Q2 2   Choose numeric location
  O/Q2     Choose a random number between 0 and half input number
 m     2   Do the above twice, wrap in array
J          Assign to variable J

jy.eyXWqhJkbeJOT<csm.SGQK.EcQ2K   Main function
                           cQ2    Divide input number by 2
                         .E       Round up
                        K         Assign the above to K
                    .SG           Shuffle the alphabet
                  sm   Q          Do the above Q times, concatenate
                 c      K         Chop the above into segments of length K
                <             K   Take the first K of the above
  .e                              Map (element, index) as (b,k) using:
       qhJk                         Does k equal first element of J?
      W                             If so...
     X     b                          Replace in b...
            eJ                        ...at position <last element of J>...
              OT                      ...a random int less than 10
                                    Otherwise, b without replacement
    y                               Apply palindromisation to the result of the above
 y                                Palindromise the set of lines
j                                 Join on newlines, implicit print

Die Verwendung mehrerer gemischter Alphabete sollte sicherstellen, dass die Anzahl der eindeutigen Zeichen immer größer ist als die eingegebene Anzahl.

Python 2 / Python 3, 227 Bytes

from random import*
def m(N):n=N-N//2;r=range;C=choice;c=n*[chr(i+97)for i in r(26)];shuffle(c);c[C([i for i in r(n*(N-n))if(i+1)%n+1-N%2])]=`C(r(10))`;R=[c[i*n:i*n+n]+c[i*n:i*n+n-N%2][::-1]for i in r(n)];return R+R[::-1][N%2:]

ein bisschen ungolfing:

from random import * # get 'choice' and 'shuffle'
def matrix(N):
    n = ceil(N/2) # get the size of the base block
    # get a shuffleable lowercase alphabet
    c = [chr(i+97)for i in range(26)]
    c = n*c # make it large enough to fill the base-block
    shuffle(c) # randomize it
    digit = choice('1234567890') # get random digit string
    ## this is only needed as to prevent uneven side-length matrices
    #  from having centerline digits.
    allowed_indices = [i for i in range( # get all allowed indices
        n*(N-n)) # skip those, that are in an unmirrored center-line
        if(i+1)%n  # only use those that are not in the center column
                 +1-N%2] # exept if there is no center column
    index = choice(allowed_indices) # get random index
    c[index]=digit # replace one field at random with a random digit
    ## 
    R=[]
    for i in range(n):
        r = c[i*n:i*n+n] # chop to chunks sized fit for the base block
        R.append(r+r[::-1][N%2:]) # mirror skipping the center line
    return R+R[::-1][N%2:] # mirror skipping the center line and return

Ältere, fast korrekte Versionen unten:

Python2, Python3, 161 Bytes

from random import *
N=26
n=N-N//2
c=[chr(i+97)for i in range(26)]
R=[ r+r[::-1][N%2:]for r in[(shuffle(c),c[:n])[1]for i in range(n)]]
R+=R[::-1][N%2:]
print(R)

Es scheint, dass N unterschiedliche Elemente nur fast garantiert sind.

Python 2 / Python 3, 170 Bytes

from random import*
def m(N):n=N-N//2;r=range;c=n*[chr(i+97)for i in r(26)][:n*n];shuffle(c);R=[_+_[::-1][N%2:]for _ in[c[i*n:i*n+n]for i in r(n)]];return R+R[::-1][N%2:]

Es scheint, als hätte ich Regel 3 vergessen. Auch irgendwie hat sich das [: n * n] eingeschlichen.