도전

사각형 랜덤 대칭 행렬을 반환하거나 인쇄하는 프로그램이나 함수를 작성하십시오.

입력

N : 매트릭스의 크기 즉6 x 6

산출

매트릭스. 인쇄하거나 문자열 (줄 바꿈 포함) 또는 목록 / 배열의 목록 / 배열로 반환 할 수 있습니다.

규칙

1. 최소 N다른 문자 를 사용해야 합니다. 여기서 N정방 행렬의 크기 (입력)입니다. 우리는 문자 [a, z] [A, Z]와 숫자 [0, 9] (그리고 한 번에 1 자리 만)를 사용 N < 27하고 N > 2있기 때문에 N <= 2당신은 그것을 추정 할 수 있습니다. 그리고 숫자. 마지막으로, 모든 문자 / 숫자는 0이 아닌 확률을 가져야합니다 (균일 한 분포는 필요하지 않습니다). 그러나 결과에는 최소한 N다른 문자 / 숫자 가 있어야합니다 .

2. 매트릭스는 수평 및 수직 대칭이어야합니다.

3. 정확히 2 개의 행과 2 개의 열은 하나의 숫자 만 엄격하게 포함해야합니다 (위치도 임의적이어야 함). 나머지 행 / 콜에는 문자 만 포함됩니다. 문자를 [a, z] 및 [A, Z]로, 한 자리 숫자는 [0, 9]로 간주하십시오.

4. 더 쉽게하기 위해, 대소 문자가 대칭 인 한 글자의 대소 문자는 중요하지 않다고 가정 할 수 있습니다 a=A, b=B, etc.

5. 가능한 모든 출력에는 0이 아닌 확률이 있어야합니다. 랜덤 분포는 균일하지 않아도됩니다.

예

입력 : 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 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 경우는 n23 바이트 다음, 심지어는 항상 :

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

Ｎθ

입력 .$n$

Ｅ⊘θ⭆⊘θ‽β

n을 만듭니다 로$\frac n 2$임의의 소문자 배열 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 바이트

-1 바이트를위한 @ Adám에게 감사합니다

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

온라인으로 사용해보십시오!

⌈대칭으로 만들기 위해 반사와 함께 매트릭스의 (최대)를 사용 하므로 알파벳의 후반쪽으로 편향됩니다.

숫자는 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

파이썬 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 변경 îï에 ò상기 위치를 변경 ».

더 많은 테스트 사례 를 확인하기 위해 온라인 으로 사용해보십시오 .

Old ( 29 27 bytes )는 숫자가 항상 모퉁이에서 어디에 위치하는지 대답합니다.

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 바이트

ceilingcat 덕분에 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]);
}

자바 스크립트 (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()

깨끗한 , 346312 바이트

내일 더 골프를 할 것입니다

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() 이 너무 많다고 제자리에서 셔플 링을 제거하는 것이 좋습니다. :)

나는이 부분 (문자와 숫자를 선택하는)이 조금 더 골프를 칠 수 있다고 확신합니다.

파이썬 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 .

피스 , 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]이 빠져 들었습니다.