Thử thách

Viết chương trình hoặc hàm trả về hoặc in ma trận đối xứng vuông ngẫu nhiên.

Đầu vào

N : Kích thước của ma trận tức là6 x 6

Đầu ra

Ma trận. Bạn có thể in nó, trả về dưới dạng chuỗi (với dòng mới) hoặc dưới dạng danh sách / mảng danh sách / mảng.

Quy tắc

1. Bạn cần sử dụng ít nhất Ncác ký tự khác nhau, Nkích thước của ma trận vuông (đầu vào) là bao nhiêu. Kể từ khi chúng tôi 'tái sử dụng chỉ thư [a, z] [A, Z] và chữ số [0, 9] (và chỉ có 1 chữ số vào thời điểm đó), bạn có thể giả định rằng N < 27và N > 2, đó là bởi vì tại N <= 2bạn không thể có cả chữ và chữ số. Cuối cùng nhưng không kém phần quan trọng, mỗi chữ cái / chữ số phải có xác suất xảy ra khác không (phân phối đồng đều không phải là một điều cần thiết). Tuy nhiên, kết quả phải có ít nhất Ncác chữ cái / chữ số khác nhau.

2. Ma trận phải đối xứng cả theo chiều ngang và chiều dọc.

3. Chính xác là 2 hàng và 2 cột phải chứa đúng một số có một chữ số (vị trí của nó cũng phải ngẫu nhiên). Phần còn lại của hàng / cols sẽ chỉ chứa các chữ cái. Hãy xem xét các chữ cái là [a, z] và [A, Z] và tất nhiên là các số có một chữ số là [0, 9].

4. Để dễ dàng hơn, bạn có thể giả sử rằng trường hợp của các chữ cái không thành vấn đề, miễn là các trường hợp đối xứng có nghĩa là : a=A, b=B, etc.

5. Mỗi đầu ra có thể phải có xác suất xảy ra khác không. Phân phối ngẫu nhiên không cần phải thống nhất.

Thí dụ

Đầu vào : 8

Đầu ra :

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

Than , 30 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Nếu nluôn luôn là chẵn thì với 23 byte:

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｎθ

Đầu vào .$n$

Ｅ⊘θ⭆⊘θ‽β

Tạo một bởi$\frac n 2$ mảng chữ cái viết thường ngẫu nhiên. Điều này in ngầm như một hình vuông.$\frac n 2$

Ｊ‽⊘θ‽⊘θ

Nhảy đến một vị trí ngẫu nhiên trong hình vuông.

Ｉ‽χ

In một chữ số ngẫu nhiên.

‖Ｃ¬

Phản ánh theo chiều ngang và chiều dọc để hoàn thành ma trận.

R , 124 118 byte

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

Hãy thử trực tuyến!

Trong R, những thứ trông giống như toán tử chỉ là các hàm được xử lý đặc biệt từ trình phân tích cú pháp.

Nếu bạn xác định lại một toán tử (như -) là một số chức năng khác, thì nó sẽ xử lý đặc biệt từ trình phân tích cú pháp. Vì -là cả tiền tố và tiền tố, và tôi cần gọi samplehàm bằng cả hai và hai đối số, tôi có thể sử dụng

`-`=sample

để có được những gì tôi muốn.

Vì vậy, mã -lettersđược dịch sang sample(letters), ngẫu nhiên xáo trộn tích lettershợp. Nhưng j-1được dịch sang sample(j,1), lấy mẫu ngẫu nhiên 1từ vector 1:j.

(Hành vi này của samplehàm tùy thuộc vào số lượng tham số và tham số đầu tiên là gì, là một nỗi đau rất lớn ở mã sản xuất, vì vậy tôi rất vui khi tìm thấy một cách sử dụng tuyệt vời bản chất đồi trụy của nó ở đây!)

Mặt khác, mã chỉ tạo góc phần tư phía trên bên trái của kết quả được yêu cầu, thay thế một phần tử ngẫu nhiên ( bit j-1, j-1bit) bằng một chữ số ngẫu nhiên ( 0:9-1bit) và gấp nó lại cho đối xứng cần thiết. Các ivà jcần thiết để giải quyết các trường hợp chẵn và lẻ.

Python3, 287 byte

Lần thử đầu tiên của tôi khi chơi golf ở đây; Tôi chắc rằng ai đó có thể làm tốt hơn nhiều:

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)

Hãy thử trực tuyến!

Nhờ HyperNeurtrino, Ourous và Heiteria đã giảm xuống còn 193 byte (xem bình luận). Tuy nhiên, TFeld đã chỉ ra một cách chính xác rằng nhiều cuộc gọi samplekhông đảm bảo ít nhất Ncác ký tự khác nhau.

Điều đó trong tâm trí, hãy thử phiên bản mới này sẽ đảm bảo ít nhất Ncác ký tự khác nhau trên mỗi lần chạy.

Python3, 265 260 byte, ít nhất là Ncác ký tự riêng biệt

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)

Hãy thử trực tuyến!

APL (Dyalog Classic) , 45 44 43 40 byte

cảm ơn @ Adám cho -1 byte

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

Hãy thử trực tuyến!

sử dụng ⌈(tối đa) ma trận với các phản xạ của nó để làm cho nó đối xứng, do đó, nó thiên về phần sau của bảng chữ cái

chữ số được chọn thống nhất từ ​​0 ... 25 mod 10, do đó, nó có độ lệch nhỏ so với các giá trị thấp hơn

Japt , 31 byte (Vị trí chữ số cố định)

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

Hãy thử trực tuyến!

Japt , 41 byte (Vị trí chữ số ngẫu nhiên)

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

Hãy thử trực tuyến!

Giải trình

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

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]

Hãy thử trực tuyến!

05AB1E , 29 40 38 byte

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

11 byte để sửa chữa các chữ số là ở một vị trí ngẫu nhiên trong khi vẫn giữ nguyên tắc 3 trong tâm trí cho các đầu vào lẻ ..
-2 byte nhờ @MagicOctopusUrn , thay đổi îïđể òvà thay đổi vị trí của các ».

Hãy thử trực tuyến để xác minh một số trường hợp thử nghiệm .

Câu trả lời cũ ( 29 27 byte ) trong đó các vị trí chữ số luôn nằm trong các góc:

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

Hãy thử trực tuyến hoặc xác minh một số trường hợp thử nghiệm .

Giải trình:

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 byte

Lưu được 2 byte nhờ trần.

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

Hãy thử trực tuyến!

Giải trình:

// 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 byte

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

Hãy thử trực tuyến!

Đã bình luận

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

Dọn dẹp , 346 312 byte

sẽ chơi golf nhiều hơn vào ngày mai

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

Hãy thử trực tuyến!

Con trăn 3 , 197 byte

Như được đề cập bởi @Emigna, không hoạt động cho các giá trị kỳ lạ của N(Tôi không hiểu đúng câu hỏi)

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

Hãy thử trực tuyến!

Tôi nghĩ rằng các cuộc gọi đến randint()+ sample()+ shuffle()là quá nhiều và việc loại bỏ xáo trộn tại chỗ sẽ rất tuyệt :)

Tôi khá chắc chắn rằng phần này (chọn các chữ cái & chữ số) có thể được đánh gôn thêm một chút.

Python 2 , 275 266 byte

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]

Hãy thử trực tuyến!

Trả về mảng dưới dạng danh sách các danh sách các ký tự. Để đáp ứng Quy tắc 1, chúng tôi thiết lập một nhóm các ký tự:

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

Bit khó khăn tiếp theo là quy tắc 3: phải có chính xác 2 cột và hàng có một chữ số; điều này có nghĩa là nlẻ, chữ số được chọn có thể không xuất hiện ở cột giữa hoặc hàng giữa. Vì chúng ta xây dựng mảng bằng cách sử dụng một mảng con vuông được phản ánh hai lần s, điều đó được thực hiện ở đây bằng cách sử dụng:

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

tức là xáo trộn ít nhất một lần; và sau đó, nếu nlà số lẻ, hãy tiếp tục lặp nếu chữ số nằm trong cột cuối cùng hoặc hàng cuối cùng củas .

Bình thường , 48 byte

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

Dùng thử trực tuyến tại đây .

Chương trình gồm 3 phần - định nghĩa hàm palindromisation, chọn vị trí của số và hàm chính.

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

Sử dụng một số bảng chữ cái được xáo trộn sẽ đảm bảo rằng số lượng ký tự duy nhất luôn nhiều hơn số đầu vào.

Python 2 / Python 3, 227 byte

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

vô ý một chút:

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

Cũ hơn, gần như phiên bản đúng dưới đây:

Python2, Python3, 161 byte

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)

Dường như N yếu tố khác nhau chỉ là gần như đảm bảo.

Python 2 / Python 3, 170 byte

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

Có vẻ như tôi đã quên quy tắc 3. Ngoài ra, bằng cách nào đó, [: n * n] trượt vào.