Виклик

Написати програму або функцію, яка повертає або друкує квадратно-випадкову симетричну матрицю.

Вхідні дані

N : Розмір матриці, тобто6 x 6

Вихід

Матриця. Ви можете її надрукувати, повернути як рядок (з новими рядками) або як список / масив списків / масивів.

Правила

1. Вам потрібно використовувати хоча б Nрізні символи, де Nрозмір квадратної матриці (вхід). Так як ми «повторно використовувати тільки букви [а, г] [A, Z] і цифри [0, 9] (і тільки одна цифра в той час) можна припустити , що N < 27і N > 2, це тому , що у N <= 2вас не може бути як букви і цифри. І останнє, але не менш важливе, кожна літера / цифра повинна мати нульову ймовірність виникнення (рівномірний розподіл не є необхідністю). Однак результат повинен мати хоча б Nрізні літери / цифри.

2. Матриця повинна бути як горизонтальною, так і вертикально симетричною.

3. Рівно 2 рядки та 2 стовпці повинні містити строго одне одноцифрове число (його позиція також повинна бути випадковою). Решта рядків / знаків містять лише літери. Розгляньте літери як [a, z] і [A, Z] і, звичайно, одноцифрові числа як [0, 9].

4. Просто бути простіше, то можна припустити , що в разі букв не має значення, до тих пір , як випадки симетричні , що означає: a=A, b=B, etc.

5. Кожен можливий вихід повинен мати ненульову ймовірність виникнення. Випадкове розподіл не повинно бути рівномірним.

Приклад

Вхід : 8

Вихід :

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

Вугілля деревне , 30 байт

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

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Якщо nзавжди рівне, то для 23 байт:

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

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Пояснення:

Ｎθ

Введення .$n$

Ｅ⊘θ⭆⊘θ‽β

Створіть за$\frac n 2$ масив випадкових малих літер. Це друкується неявно як квадрат.$\frac n 2$

Ｊ‽⊘θ‽⊘θ

Перейти до випадкової позиції на квадраті.

Ｉ‽χ

Вивести випадкову цифру.

‖Ｃ¬

Відбийте горизонтально та вертикально, щоб завершити матрицю.

R , 124 118 байт

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

Спробуйте в Інтернеті!

У R речі, схожі на операторів, - це лише функції, які отримують спеціальну обробку від аналізатора.

Якщо ви повторно визначите оператора (як -), який-небудь інший функції, він зберігає спеціальний режим від аналізатора. Оскільки -це і префікс, і інфікс, і мені потрібно викликати sampleфункцію з одним і двома аргументами, я можу використовувати

`-`=sample

щоб отримати те, що я хочу.

Тож код -lettersперекладається на sample(letters), який випадковим чином переміщує lettersвбудований. Але j-1перекладається на те sample(j,1), що випадковим чином відбирає 1елемент з вектора 1:j.

(Така поведінка sampleфункції залежно від кількості параметрів і того, що є першим параметром, - це величезний біль у прикладі у виробничому коді, тому я радий знайти тут велике використання його збоченої природи!)

В іншому випадку код просто робить верхній лівий квадрант необхідного результату, замінює випадковий елемент ( j-1, j-1біт) з випадковою цифрою ( 0:9-1біт), і складає його на необхідну симетрію. The iі the jнеобхідні для вирішення парних і непарних випадків.

Python3, 287 байт

Моя перша спроба в гольфі щось тут; Я впевнений, що хтось може зробити набагато краще:

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)

Спробуйте в Інтернеті!

Завдяки HyperNeurtrino, Ourous та Heiteria зменшилися до 193 байт (див. Коментарі). Однак TFeld правильно вказав, що кілька дзвінків sampleне гарантують принаймні Nрізних символів.

Майте це на увазі, спробуйте цю нову версію, яка повинна гарантувати принаймні Nрізні символи на пробіг.

Python3, 265 260 байт, принаймні Nчіткі символи

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)

Спробуйте в Інтернеті!

APL (Dyalog Classic) , 45 44 43 40 байт

дякую @ Adám за -1 байт

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

Спробуйте в Інтернеті!

використовує ⌈(max) матрицю з її відображеннями, щоб зробити її симетричною, тому вона упереджена до останньої частини алфавіту

цифра вибирається рівномірно від 0 ... 25 мод 10, тому вона має невеликий ухил до нижчих значень

Japt , 31 байт (позиція з фіксованою цифрою)

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

Спробуйте в Інтернеті!

Japt , 41 байт (Random цифра позиція)

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

Спробуйте в Інтернеті!

Пояснення

;                               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 байт

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]

Спробуйте в Інтернеті!

05AB1E , 29 40 38 байт

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

+11 байт зафіксувати цифру будучи у випадковому положенні , зберігаючи правило 3 на увазі , для непарних входів ..
-2 байт завдяки @MagicOctopusUrn , змінюючи îïдо òі змінюючи положення з ».

Спробуйте в Інтернеті, щоб перевірити ще кілька тестових випадків .

Старі ( 29 27 байт ) відповідають, де розміщується цифра, де завжди в кутах:

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

Спробуйте в Інтернеті або перевірте ще кілька тестових випадків .

Пояснення:

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 байт

Збережено 2 байти завдяки стельовій коті.

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

Спробуйте в Інтернеті!

Пояснення:

// 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 байт

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

Спробуйте в Інтернеті!

Прокоментував

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

Чисто , 346 312 байт

буде завтра більше гольфу

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

Спробуйте в Інтернеті!

Пітон 3 , 197 байт

Як згадував @Emigna, він не працює для непарних значень N(я неправильно не зрозумів питання)

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

Спробуйте в Інтернеті!

Я думаю, що дзвінків до randint()+ sample()+ shuffle()занадто багато, і позбавлення від переміщення на місці було б чудово :)

Я майже впевнений, що ця частина (яка вибирає букви та цифри) могла б трохи більше пограти в гольф.

Python 2 , 275 266 байт

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]

Спробуйте в Інтернеті!

Повертає масив у вигляді списку списків символів. Щоб задовольнити правило 1, ми створили пул символів:

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

Наступний складний біт - правило 3: повинно бути рівно 2 стовпці та рядки, що мають цифру; це означає для nнепарного, що обрана цифра може не відображатися в середньому стовпчику чи середньому рядку. Оскільки ми побудуємо масив за допомогою подвійного відбитого квадратного масиву s, це досягається за допомогою:

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

тобто перемішуйте принаймні один раз; а потім, якщо nце непарно, продовжуйте циклічно, якщо цифра знаходиться в останньому стовпчику чи в останньому рядку s.

Pyth , 48 байт

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

Спробуйте його онлайн тут .

Програма складається з 3 частин - визначення функції паліндромізації, вибір місця числення та основної функції.

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

Використання декількох перетасованих алфавітів повинно забезпечити, щоб кількість унікальних символів завжди перевищувала кількість введення.

Python 2 / Python 3, 227 байт

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

небагато гольфування:

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

Старі, майже правильні версії нижче:

Python2, Python3, 161 байт

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)

Здається, що N різних елементів лише майже гарантовано.

Python 2 / Python 3, 170 байт

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

Здається, я забув правило 3. Також якось увійшов [: n * n].