Wyzwanie

Napisz program lub funkcję, która zwraca lub drukuje macierz kwadratowo-losowo-symetryczną.

Wejście

N : Rozmiar matrycy tj6 x 6

Wynik

Macierz. Możesz go wydrukować, zwrócić jako ciąg znaków (z nowymi wierszami) lub jako listę / tablicę list / tablic.

Zasady

1. Musisz użyć co najmniej Nróżnych znaków, gdzie Njest rozmiar macierzy kwadratowej (dane wejściowe). Ponieważ używamy tylko litery [a, z] [A, Z] i cyfr [0, 9] (i tylko 1 cyfra w tym czasie), możesz założyć, że N < 27i N > 2dlatego, N <= 2że nie możesz mieć obu liter i cyfry. Wreszcie każda litera / cyfra musi mieć niezerowe prawdopodobieństwo wystąpienia (jednolity rozkład nie jest koniecznością). Jednak wynik musi mieć co najmniej Ninną literę / cyfry.

2. Matryca musi być symetryczna zarówno poziomo, jak i pionowo.

3. Dokładnie 2 wiersze i 2 kolumny muszą zawierać ściśle jedną liczbę jednocyfrową (jej pozycja powinna być również losowa). Reszta wierszy / kolumn będzie zawierać tylko litery. Rozważ litery jako [a, z] i [A, Z] oraz oczywiście cyfry jednocyfrowe jako [0, 9].

4. Wystarczy być łatwiejsze, można założyć, że w przypadku liter nie ma znaczenia, tak długo, jak przypadki są symetryczne Co oznacza: a=A, b=B, etc.

5. Każde możliwe wyjście musi mieć niezerowe prawdopodobieństwo wystąpienia. Rozkład losowy nie musi być jednolity.

Przykład

Wejście : 8

Wyjście :

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

Węgiel drzewny , 30 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Jeśli njest zawsze parzyste, to dla 23 bajtów:

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

Ｎθ

Wpisz .$n$

Ｅ⊘θ⭆⊘θ‽β

Utwórz przez$\frac n 2$ tablice losowych małych liter. Drukuje się domyślnie jako kwadrat.$\frac n 2$

Ｊ‽⊘θ‽⊘θ

Skocz do losowej pozycji na kwadracie.

Ｉ‽χ

Wydrukuj losową cyfrę.

‖Ｃ¬

Odbij poziomo i pionowo, aby ukończyć matrycę.

R , 124 118 bajtów

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

Wypróbuj online!

W R rzeczy, które wyglądają jak operatory, są po prostu funkcjami, które są specjalnie traktowane przez parser.

Jeśli redefiniujesz operatora (na przykład -), aby był jakąś inną funkcją, zachowuje on specjalne traktowanie przez analizator składni. Ponieważ -jest to zarówno przedrostek, jak i przyrostek, i muszę wywołać samplefunkcję z jednym i dwoma argumentami, mogę użyć

`-`=sample

dostać to, czego chcę.

Tak więc kod -lettersjest tłumaczony na sample(letters), który losowo tasuje letterswbudowane. Ale j-1jest tłumaczony na sample(j,1), który losowo pobiera próbki 1z wektora 1:j.

(To zachowanie samplefunkcji w zależności od liczby parametrów i tego, jaki jest pierwszy parametr, jest ogromnym bólem w tyłku kodu produkcyjnego, więc cieszę się, że mogę tutaj świetnie wykorzystać jego przewrotną naturę!)

W przeciwnym razie kod po prostu tworzy lewą górną ćwiartkę wymaganego wyniku, zastępuje losowy element (the j-1, j-1bit) losową cyfrą ( 0:9-1bit) i rozkłada go dla wymaganej symetrii. iI jsą potrzebne, aby radzić sobie z parzystych i nieparzystych przypadkach.

Python3, 287 bajtów

Moja pierwsza gra w golfa tutaj; Jestem pewien, że ktoś może zrobić znacznie lepiej:

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)

Wypróbuj online!

Dzięki HyperNeurtrino, Ourous i Heiteria zmniejszyło się to do 193 bajtów (patrz komentarze). Jednak TFeld poprawnie wskazał, że wiele wywołań samplenie gwarantuje co najmniej Nróżnych znaków.

Mając to na uwadze, wypróbuj nową wersję, która powinna gwarantować co najmniej Nróżne znaki na uruchomienie.

Python3, 265 260 bajtów, co najmniej Nróżne znaki

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)

Wypróbuj online!

APL (Dyalog Classic) , 45 44 43 40 bajtów

dzięki @ Adám za -1 bajt

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

Wypróbuj online!

używa ⌈(maks.) matrycy z jej odbiciami, aby uczynić ją symetryczną, więc jest tendencyjna w stosunku do drugiej części alfabetu

cyfra jest wybierana równomiernie od 0 ... 25 mod 10, więc ma małe odchylenie do niższych wartości

Japt , 31 bajtów (stała pozycja cyfr)

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

Wypróbuj online!

Japt , 41 bajtów (pozycja losowej cyfry)

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

Wypróbuj online!

Wyjaśnienie

;                               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 bajtów

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]

Wypróbuj online!

05AB1E , 29 40 38 bajtów

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

+11 bajtów naprawić cyfrę będąc w dowolnej pozycji zachowując zasadę 3 w umyśle dla wejść nieparzystych ..
-2 bajty dzięki @MagicOctopusUrn , zmienia îïsię òi zmienia pozycję z poniższych ».

Wypróbuj online i sprawdź kilka innych przypadków testowych .

Stara ( 29 27 bajtów ) odpowiedź, gdzie cyfra ustawia się zawsze w rogach:

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

Wypróbuj online lub sprawdź kilka innych przypadków testowych .

Wyjaśnienie:

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 bajtów

Zaoszczędzono 2 bajty dzięki pułapce cat.

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

Wypróbuj online!

Wyjaśnienie:

// 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 bajtów

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

Wypróbuj online!

Skomentował

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

Czysty , 346312 bajtów

jutro więcej golfa

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

Wypróbuj online!

Python 3 , 197 bajtów

Jak wspomniano @Emigna, nie działa dla nieparzystych wartości N(nie zrozumiałem poprawnie pytania)

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

Wypróbuj online!

Myślę, że połączenia do randint()+ sample()+ shuffle()to za dużo, a pozbycie się tasowania w miejscu byłoby świetne :)

Jestem prawie pewien, że ta część (która wybiera litery i cyfry) może być nieco bardziej golfa.

Python 2 , 275 266 bajtów

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]

Wypróbuj online!

Zwraca tablicę jako listę list znaków. Aby spełnić Regułę 1, stworzyliśmy pulę znaków:

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

Kolejnym trudnym bitem jest reguła 3: muszą być dokładnie 2 kolumny i wiersze z cyfrą; oznacza to nnieparzyste, że wybrana cyfra może nie pojawić się w środkowej kolumnie lub środkowym rzędzie. Ponieważ konstruujemy tablicę przy użyciu podwójnie odzwierciedlonej kwadratowej tablicy podrzędnej s, osiąga się to tutaj za pomocą:

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

tj. potasuj co najmniej raz; a następnie, jeśli njest nieparzysty, kontynuuj zapętlanie, jeśli cyfra znajduje się w ostatniej kolumnie lub ostatnim wierszu s.

Pyth , 48 bajtów

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

Wypróbuj online tutaj .

Program składa się z 3 części - zdefiniowanie funkcji palindromizacji, wybór położenia funkcji numerycznej i głównej.

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

Używanie kilku tasowanych alfabetów powinno zapewnić, że liczba unikalnych znaków jest zawsze większa niż liczba wejściowa.

Python 2 / Python 3, 227 bajtów

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

trochę golfa:

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

Starsze, prawie poprawne wersje poniżej:

Python2, Python3, 161 bajtów

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)

Wygląda na to, że N różnych elementów jest prawie gwarantowane.

Python 2 / Python 3, 170 bajtów

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

Wygląda na to, że zapomniałem zasady 3. Również jakoś [: n * n] wślizgnęło się.