Desafío

Escriba un programa o una función que devuelva o imprima una matriz simétrica aleatoria cuadrada.

Entrada

N : el tamaño de la matriz, es decir6 x 6

Salida

La matriz. Puede imprimirlo, devolverlo como una cadena (con las nuevas líneas) o como una lista / matriz de listas / matrices.

Reglas

1. Debe usar al menos Ncaracteres diferentes, donde Nes el tamaño de la matriz cuadrada (entrada). Como estamos usando solo la letra [a, z] [A, Z] y los dígitos [0, 9] (y solo 1 dígito a la vez), puede suponer eso N < 27y N > 2, eso es porque N <= 2no puede tener ambas letras y dígitos. Por último, pero no menos importante, cada letra / dígito debe tener una probabilidad distinta de cero (la distribución uniforme no es una necesidad). Sin embargo, el resultado debe tener al menos Nletras / dígitos diferentes.

2. La matriz tiene que ser simétrica tanto horizontal como verticalmente.

3. Exactamente 2 filas y 2 columnas deben contener estrictamente un número de un solo dígito (su posición también debe ser aleatoria). El resto de filas / columnas contendrá solo letras. Considere letras como [a, z] y [A, Z] y, por supuesto, números de un solo dígito como [0, 9].

4. Para que quede más fácil, se puede asumir que el caso de las letras no importa, siempre y cuando los casos son simétricas cuyos medios: a=A, b=B, etc.

5. Cada salida posible debe tener una probabilidad distinta de cero. La distribución aleatoria no necesita ser uniforme.

Ejemplo

Entrada : 8

Salida :

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

Carbón , 30 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Si nsiempre es par, entonces para 23 bytes:

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｎθ

Entrada .$n$

Ｅ⊘θ⭆⊘θ‽β

Crea una por$\frac n 2$$\frac n 2$ matriz de letras minúsculas al azar. Esto se imprime implícitamente como un cuadrado.

Ｊ‽⊘θ‽⊘θ

Salta a una posición aleatoria en el cuadrado.

Ｉ‽χ

Imprime un dígito al azar.

‖Ｃ¬

Refleje horizontal y verticalmente para completar la matriz.

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

Pruébalo en línea!

En R, las cosas que parecen operadores son solo funciones que reciben un tratamiento especial del analizador.

Si redefine a un operador (como -) para que sea otra función, mantiene el tratamiento especial del analizador. Como -es a la vez prefijo e infijo, y necesito llamar a la samplefunción con uno y dos argumentos, puedo usar

`-`=sample

para conseguir lo que quiero

Entonces el código -lettersse traduce asample(letters) , lo que aleatoriamente baraja el lettersincorporado. Pero j-1se traduce en sample(j,1), que muestra aleatoriamente un 1elemento del vector 1:j.

(Este comportamiento de la sample función, dependiendo de la cantidad de parámetros y cuál es el primer parámetro, es una gran molestia en el código de producción, ¡así que estoy feliz de encontrar un gran uso de su naturaleza perversa aquí!)

De lo contrario, el código sólo hace que el cuadrante superior izquierdo del resultado requerido, reemplaza un elemento aleatorio (el j-1, j-1bits) con un dígito al azar (el 0:9-1bit), y se pliega hacia fuera para la simetría requerida. El iy elj son necesarios para tratar los casos pares e impares.

Python3, 287 bytes

Mi primer intento de jugar al golf aquí; Estoy seguro de que alguien puede hacerlo mucho mejor:

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)

Pruébalo en línea!

Gracias a HyperNeurtrino, Ourous y Heiteria, esto se redujo a 193 bytes (ver comentarios). Sin embargo, TFeld señaló correctamente que varias llamadas a sampleno garantizan al menos Ncaracteres diferentes.

Con eso en mente, pruebe esta nueva versión que debería garantizar al menos Ndiferentes caracteres por ejecución.

Python3, 265 260 bytes, al menos Ncaracteres distintos

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)

Pruébalo en línea!

APL (Dyalog Classic) , 45 44 43 40 bytes

gracias @ Adám por -1 byte

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

Pruébalo en línea!

usa ⌈(max) de la matriz con sus reflejos para hacerla simétrica, por lo que está sesgada hacia la última parte del alfabeto

el dígito se elige uniformemente entre 0 ... 25 mod 10, por lo que tiene un pequeño sesgo para valores más bajos

Japt , 31 bytes (posición de dígito fijo)

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

Pruébalo en línea!

Japt , 41 bytes (posición de dígitos aleatorios)

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

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

05AB1E , 29 40 38 bytes

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

+11 bytes para fijar el dígito estar en una posición al azar mientras que todavía mantiene la regla de 3 en cuenta para las entradas impares ..
-2 bytes gracias a @MagicOctopusUrn , cambiando îïa òy el cambio de la posición de la ».

Pruébelo en línea de verificar algunos casos más de prueba .

La respuesta anterior ( 29 27 bytes ) donde las posiciones de los dígitos siempre estaban en las esquinas:

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

Pruébelo en línea o verifique algunos casos de prueba más .

Explicación:

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

Guardado 2 bytes gracias a ceilingcat.

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

Pruébalo en línea!

Explicación:

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

Pruébalo en línea!

Comentado

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

Limpio , 346 312 bytes

jugará más golf mañana

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

Pruébalo en línea!

Python 3 , 197 bytes

Como mencionó @Emigna, no funciona para valores impares de N(no entendí la pregunta correctamente)

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

Pruébalo en línea!

Creo que las llamadas a randint()+ sample()+shuffle() son demasiado, y deshacerse de la mezcla en el lugar sería genial :)

Estoy bastante seguro de que esta parte (que selecciona las letras y los dígitos) podría jugar un poco más.

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]

Pruébalo en línea!

Devuelve la matriz como una lista de listas de caracteres. Para satisfacer la Regla 1, configuramos un grupo de caracteres:

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

El siguiente bit complicado es la regla 3: debe haber exactamente 2 columnas y filas que tengan un dígito; Esto significa, para nimpar, que el dígito elegido puede no aparecer en la columna central o en la fila central. Como construimos la matriz usando una submatriz cuadrada reflejada dos veces s, eso se logra aquí usando:

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

es decir, barajar al menos una vez; y luego, si nes impar, siga repitiendo si el dígito está en la última columna o la última fila de s.

Pyth , 48 bytes

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

Pruébelo en línea aquí .

El programa consta de 3 partes: definición de la función de palindromización, elección de la ubicación de la función numérica y principal.

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

El uso de varios alfabetos barajados debería garantizar que el número de caracteres únicos sea siempre mayor que el número de entrada.

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

ungolfing un poco:

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

Mayor, Versiones más casi correctas a continuación:

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)

Parece que N elementos diferentes son solo casi garantizados.

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

Parece que olvidé la regla 3. También de alguna manera se deslizó [: n * n]