Вызов

Напишите программу или функцию, которая возвращает или печатает квадратную случайно-симметричную матрицу.

вход

N : размер матрицы, т. Е.6 x 6

Выход

Матрица. Вы можете либо распечатать его, вернуть его в виде строки (с символами новой строки) или в виде списка / массива списков / массивов.

правила

1. Вам нужно использовать как минимум Nразные символы, где Nразмер квадратной матрицы (входной). Так как мы используем только буквы [a, z] [A, Z] и цифры [0, 9] (и только 1 цифру в то время), вы можете предположить, что 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бит), и складывает его на требуемую симметрию. iИ 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 mod 10, поэтому она имеет небольшой уклон к более низким значениям

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

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

Попробуйте онлайн!

Japt , 41 байт (позиция случайной цифры)

;
/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 байта, благодаря функциюcatcat.

#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

Попробуйте онлайн!

Python 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].