Desafio

Escreva um programa ou uma função que retorne ou imprima uma matriz simétrica quadrada aleatória.

Entrada

N : O tamanho da matriz, ou seja,6 x 6

Resultado

O Matrix. Você pode imprimi-lo, devolvê-lo como string (com as novas linhas) ou como uma lista / matriz de listas / matrizes.

Regras

1. Você precisa usar pelo menos Ncaracteres diferentes, onde Né o tamanho da matriz quadrada (entrada). Como estamos usando apenas as letras [a, z] [A, Z] e dígitos [0, 9] (e apenas 1 dígito de cada vez), você pode assumir isso N < 27e N > 2, isso porque N <= 2você não pode ter as duas letras e dígitos. Por último, mas não menos importante, toda letra / dígito deve ter uma probabilidade diferente de zero (a distribuição uniforme não é uma necessidade). No entanto, o resultado deve ter pelo menos Nletras / dígitos diferentes.

2. A matriz deve ser horizontal e verticalmente simétrica.

3. Exatamente 2 linhas e 2 colunas devem conter estritamente um número de um dígito (sua posição também deve ser aleatória). O restante das linhas / colunas conterá apenas letras. Considere letras como [a, z] e [A, Z] e, claro, números de um dígito como [0, 9].

4. Só para ser mais fácil, você pode assumir que o caso das cartas não importa, contanto que os casos são simétricas que significa: a=A, b=B, etc.

5. Toda saída possível deve ter uma probabilidade diferente de zero de ocorrer. A distribuição aleatória não precisa ser uniforme.

Exemplo

Entrada : 8

Saída :

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

Carvão , 30 bytes

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

Experimente online! Link é a versão detalhada do código. Se nfor sempre par, então para 23 bytes:

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

Experimente online! Link é a versão detalhada do código. Explicação:

Ｎθ

Entrada .$n$

Ｅ⊘θ⭆⊘θ‽β

Crie um por$\frac n 2$ matriz de letras minúsculas aleatórias. Isso imprime implicitamente como um quadrado.$\frac n 2$

Ｊ‽⊘θ‽⊘θ

Ir para uma posição aleatória no quadrado.

Ｉ‽χ

Imprima um dígito aleatório.

‖Ｃ¬

Reflita horizontalmente e verticalmente para completar a 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

Experimente online!

Em R, coisas que parecem operadores são apenas funções que recebem tratamento especial do analisador.

Se você redefinir um operador (como -) para ser alguma outra função, ele mantém o tratamento especial do analisador. Como -é o prefixo e o infixo, e eu preciso chamar a samplefunção com um e dois argumentos, eu posso usar

`-`=sample

para conseguir o que eu quero.

Portanto, o código -lettersé traduzido para sample(letters), que aleatoriamente embaralha o lettersbuilt-in. Mas j-1é traduzido para sample(j,1), que faz uma amostragem aleatória do 1item do vetor 1:j.

(Esse comportamento da samplefunção, dependendo do número de parâmetros e qual é o primeiro parâmetro, é um grande problema no código de produção, por isso estou feliz em encontrar um ótimo uso de sua natureza perversa aqui!)

Caso contrário, o código só faz o quadrante superior esquerdo do resultado necessário, substitui um elemento aleatório (o j-1, j-1bit) com um dígito aleatório (o 0:9-1bit), e dobra-lo para a simetria necessário. O ie o jsão necessários para lidar com os casos pares e ímpares.

Python3, 287 bytes

Minha primeira tentativa de jogar algo aqui; Tenho certeza que alguém pode fazer muito melhor:

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)

Experimente Online!

Graças ao HyperNeurtrino, Ourous e Heiteria, isso reduziu para 193 bytes (ver comentários). No entanto, TFeld apontou corretamente que várias chamadas para samplenão estão garantindo pelo menos Ncaracteres diferentes.

Com isso em mente, tente esta nova versão que deve garantir pelo menos Ncaracteres diferentes por execução.

Python3, 265 260 bytes, pelo 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)

Experimente online!

APL (Dyalog Classic) , 45 44 43 40 bytes

thanks @ Adám por -1 byte

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

Experimente online!

usa ⌈(max) da matriz com seus reflexos para torná-la simétrica; portanto, é inclinado para a última parte do alfabeto

o dígito é escolhido uniformemente de 0 a 25 mod 10, portanto, possui um pequeno viés para valores mais baixos

Japt , 31 bytes (posição de dígito fixo)

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

Experimente online!

Japt , 41 bytes (posição de dígito aleatório)

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

Experimente online!

Explicação

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

Experimente online!

05AB1E , 29 40 38 bytes

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

+11 bytes para corrigir o dígito estar em uma posição aleatória enquanto ainda mantém a regra de 3 em mente para entradas ímpares ..
-2 bytes graças a @MagicOctopusUrn , mudando îïpara òe mudando a posição do ».

Experimente on-line para verificar mais alguns casos de teste .

Resposta antiga ( 29 27 bytes ) onde o dígito está sempre nos cantos:

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

Experimente online ou verifique mais alguns casos de teste .

Explicação:

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

Economizou 2 bytes graças ao 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]);}

Experimente online!

Explicação:

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

Experimente online!

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

Limpo , 346 312 bytes

vai jogar mais amanhã

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

Experimente online!

Python 3 , 197 bytes

Conforme mencionado por @Emigna, não funciona com valores ímpares de N(não entendi a pergunta corretamente)

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

Experimente online!

Eu acho que as chamadas para o randint()+ sample()+ shuffle()são demais, e seria ótimo se livrar do embaralhamento no local :)

Tenho certeza de que essa parte (que seleciona as letras e o dígito) pode ser um pouco mais jogada.

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]

Experimente online!

Retorna a matriz como uma lista de listas de caracteres. Para satisfazer a Regra 1, montamos um conjunto 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

O próximo passo complicado é a regra 3: deve haver exatamente 2 colunas e linhas com um dígito; isso significa para nímpar, que o dígito escolhido pode não aparecer na coluna do meio ou na linha do meio. Como construímos a matriz usando uma sub-matriz quadrada refletida duas vezes s, isso é feito aqui 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

ou seja, embaralhe pelo menos uma vez; e, se nfor ímpar, continue em loop se o dígito estiver na última coluna ou na última linha de s.

Pitão , 48 bytes

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

Experimente online aqui .

O programa está dividido em 3 partes - definição da função de palindromização, escolhendo o local da função numérica e 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

O uso de vários alfabetos aleatórios deve garantir que o número de caracteres exclusivos seja sempre maior que o 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 um pouco:

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

Versões mais antigas e quase corretas abaixo:

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 são apenas quase garantidos.

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 eu esqueci a regra 3. Também de alguma forma o [: n * n] entrou.