Défi

Écrivez un programme ou une fonction qui renvoie ou imprime une matrice symétrique aléatoire carrée.

Contribution

N : La taille de la matrice ie6 x 6

Production

La matrice. Vous pouvez l'imprimer, le renvoyer sous forme de chaîne (avec les sauts de ligne) ou sous forme de liste / tableau de listes / tableaux.

Règles

1. Vous devez utiliser au moins Ndes caractères différents, où Nest la taille de la matrice carrée (entrée). Puisque nous n'utilisons que la lettre [a, z] [A, Z] et les chiffres [0, 9] (et seulement 1 chiffre à la fois), vous pouvez supposer cela N < 27et N > 2, c'est parce que N <= 2vous ne pouvez pas avoir les deux lettres et chiffres. Enfin, chaque lettre / chiffre doit avoir une probabilité non nulle de se produire (une distribution uniforme n'est pas une nécessité). Cependant, le résultat doit avoir au moins Nune lettre / chiffres différents.

2. La matrice doit être à la fois horizontalement et verticalement symétrique.

3. Exactement 2 lignes et 2 colonnes doivent contenir strictement un seul numéro (sa position doit également être aléatoire). Le reste des lignes / colonnes ne contiendra que des lettres. Considérez les lettres comme [a, z] et [A, Z] et bien sûr les nombres à un chiffre comme [0, 9].

4. Pour être plus facile, vous pouvez supposer que le cas des lettres n'a pas d' importance, tant que les cas sont symétriques qui signifie: a=A, b=B, etc.

5. Chaque sortie possible doit avoir une probabilité non nulle de se produire. La distribution aléatoire n'a pas besoin d'être uniforme.

Exemple

Entrée : 8

Sortie :

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

Fusain , 30 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Si nest toujours pair, alors pour 23 octets:

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ｎθ

Entrée .$n$

Ｅ⊘θ⭆⊘θ‽β

Créer un par$\frac n 2$ tableau de lettres minuscules aléatoires. Cela s'imprime implicitement comme un carré.$\frac n 2$

Ｊ‽⊘θ‽⊘θ

Sautez à une position aléatoire dans le carré.

Ｉ‽χ

Imprimez un chiffre aléatoire.

‖Ｃ¬

Réfléchissez horizontalement et verticalement pour compléter la matrice.

R , 124 118 octets

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

Essayez-le en ligne!

Dans R, les choses qui ressemblent à des opérateurs ne sont que des fonctions qui reçoivent un traitement spécial de l'analyseur.

Si vous redéfinissez un opérateur (comme -) pour être une autre fonction, il conserve le traitement spécial de l'analyseur. Puisque -est à la fois préfixe et infixe, et que je dois appeler la samplefonction avec un et deux arguments, je peux utiliser

`-`=sample

pour obtenir ce que je veux.

Ainsi, le code -lettersest traduit en sample(letters), qui mélange de manière aléatoire le lettersintégré. Mais j-1est traduit en sample(j,1), qui échantillonne au hasard l' 1élément du vecteur 1:j.

(Ce comportement de la samplefonction en fonction du nombre de paramètres et du premier paramètre est une énorme douleur dans le cul dans le code de production, donc je suis heureux de trouver une grande utilisation de sa nature perverse ici!)

Sinon, le code crée simplement le quadrant supérieur gauche du résultat requis, remplace un élément aléatoire (le j-1, j-1bit) par un chiffre aléatoire (le 0:9-1bit) et le déplie pour obtenir la symétrie requise. Le iet le jsont nécessaires pour traiter les cas pairs et impairs.

Python3, 287 octets

Mon premier essai de jouer au golf ici; Je suis sûr que quelqu'un peut faire beaucoup mieux:

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)

Essayez-le en ligne!

Grâce à HyperNeurtrino, Ourous et Heiteria, cela a été réduit à 193 octets (voir commentaires). Cependant, TFeld a correctement souligné que plusieurs appels à samplene garantissent pas au moins Ndes caractères différents.

Dans cet esprit, essayez cette nouvelle version qui devrait garantir au moins Ndifférents caractères par exécution.

Python3, 265 260 octets, au moins Ndes caractères distincts

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)

Essayez-le en ligne!

APL (Dyalog Classic) , 45 44 43 40 octets

merci @ Adám pour -1 octet

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

Essayez-le en ligne!

utilise ⌈(max) la matrice avec ses réflexions pour la rendre symétrique, donc elle est biaisée vers la dernière partie de l'alphabet

le chiffre est choisi uniformément de 0 à 25 mod 10, il a donc un petit biais pour abaisser les valeurs

Japt , 31 octets (position à chiffre fixe)

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

Essayez-le en ligne!

Japt , 41 octets (position de chiffre aléatoire)

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

Essayez-le en ligne!

Explication

;                               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 octets

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]

Essayez-le en ligne!

05AB1E , 29 40 38 octets

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

+11 octets pour fixer le chiffre étant à une position aléatoire tout en conservant la règle 3 à l' esprit pour les entrées impaires ..
-2 octets grâce à @MagicOctopusUrn , en changeant îïde òet en changeant la position du ».

Essayez en ligne de vérifier certains autres cas de test .

Ancien ( 29 27 octets ) répond où le chiffre se trouve toujours dans les coins:

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

Essayez-le en ligne ou vérifiez d'autres cas de test .

Explication:

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 octets

Enregistré 2 octets grâce au plafond.

#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]);}

Essayez-le en ligne!

Explication:

// 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 octets

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)()

Essayez-le en ligne!

Commenté

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()

Nettoyer , 346 312 octets

jouera plus au golf demain

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

Essayez-le en ligne!

Python 3 , 197 octets

Comme mentionné par @Emigna, ne fonctionne pas pour les valeurs impaires de N(je n'ai pas bien compris la question)

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

Essayez-le en ligne!

Je pense que les appels à randint()+ sample()+shuffle() sont trop, et se débarrasser du brassage sur place serait génial :)

Je suis sûr que cette partie (qui sélectionne les lettres et les chiffres) pourrait être un peu plus jouée.

Python 2 , 275 266 octets

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]

Essayez-le en ligne!

Renvoie le tableau sous forme de liste de listes de caractères. Pour satisfaire la règle 1, nous avons mis en place un pool de caractères:

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

Le bit le plus délicat suivant est la règle 3: il doit y avoir exactement 2 colonnes et lignes ayant un chiffre; cela signifie pour nimpair, que le chiffre choisi peut ne pas apparaître dans la colonne du milieu ou la ligne du milieu. Puisque nous construisons le tableau en utilisant un sous-tableau carré réfléchi deux fois s, cela est accompli ici en utilisant:

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

c'est-à-dire, mélangez au moins une fois; puis, si nc'est impair, continuez à boucler si le chiffre est dans la dernière colonne ou la dernière ligne de s.

Pyth , 48 octets

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

Essayez-le en ligne ici .

Le programme est en 3 parties - définition de la fonction de palindromisation, choix de l'emplacement du numérique et fonction principale.

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

L'utilisation de plusieurs alphabets mélangés doit garantir que le nombre de caractères uniques est toujours supérieur au nombre saisi.

Python 2 / Python 3, 227 octets

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:]

ungolfing un peu:

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

Versions plus anciennes, presque correctes ci-dessous:

Python2, Python3, 161 octets

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)

Il semble que N éléments différents ne soient presque garantis.

Python 2 / Python 3, 170 octets

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:]

Il semble que j'aie oublié la règle 3. De plus, le [: n * n] s'est glissé.