Meydan okuma

Kare-rastgele-simetrik bir matris döndüren veya yazdıran bir program veya işlev yazın.

Giriş

N : Matrisin boyutu yani6 x 6

Çıktı

Matris. Yazdırabilir, dize (satırsonu ile birlikte) veya liste / liste / dizi dizisi olarak döndürebilirsiniz.

kurallar

1. Kare matrisin (giriş) boyutu olan en az Nfarklı karakterler kullanmanız gerekir N. Yalnızca [a, z] [A, Z] harflerini ve [0, 9] rakamlarını (ve aynı anda yalnızca 1 basamak) kullandığımızdan bunu kabul edebilirsiniz N < 27ve N > 2bunun nedeni, N <= 2her iki harfin de bulunamamasıdır. ve rakamlar. Son olarak, her harf / rakam sıfırdan farklı olma olasılığına sahip olmalıdır (tekdüze dağılım bir zorunluluk değildir). Ancak, sonuçta en az Nfarklı harf / rakam olmalıdır.

2. Matris hem yatay hem de dikey olarak simetrik olmalıdır.

3. Tam olarak 2 satır ve 2 sütun kesinlikle tek basamaklı bir sayı içermelidir (konumu da rastgele olmalıdır). Diğer satır / sütunlarda yalnızca harfler bulunur. Harfleri [a, z] ve [A, Z] ve elbette tek basamaklı sayıları [0, 9] olarak düşünün.

4. Daha kolay olmak için, harfler simetrik olduğu sürece, harflerin durumunun önemli olmadığını varsayabilirsiniz: yani a=A, b=B, etc.

5. Her olası çıkışın sıfır olmayan bir gerçekleşme olasılığı olmalıdır. Rastgele dağılımın tek tip olması gerekmez.

Misal

Giriş : 8

Çıktı :

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

Odun kömürü , 30 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Her nzaman eşitse, 23 bayt için:

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama:

Ｎθ

Giriş .$n$

Ｅ⊘θ⭆⊘θ‽β

Bir n oluşturun ile$\frac n 2$ rastgele küçük harf. Bu, dolaylı olarak bir kare olarak yazdırılır.$\frac n 2$

Ｊ‽⊘θ‽⊘θ

Karede rastgele bir konuma atlayın.

Ｉ‽χ

Rasgele bir rakam yazdırın.

‖Ｃ¬

Matrisi tamamlamak için yatay ve dikey olarak yansıtın.

R , 124 118 bayt

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

Çevrimiçi deneyin!

R'de, operatörlere benzeyen şeyler, ayrıştırıcıdan özel muamele gören işlevlerdir.

Bir operatörü (gibi -) başka bir işlev olarak yeniden tanımlarsanız , özel işlemi ayrıştırıcıdan korur. Yana -hem önek ve infix, ve ben aramam lazım samplekullanabileceğim, bir ve iki argüman hem işlevi

`-`=sample

istediğimi elde etmek için.

Böylece kod -letters, yerleşik sample(letters)olanı rastgele karıştırır letters. Ancak j-1, vektörden öğeyi sample(j,1)rastgele örnekleyen çevrilir .11:j

( sampleFonksiyonun parametrelerin sayısına ve ilk parametrenin ne olduğuna bağlı olarak bu davranışı, üretim kodundaki popoda büyük bir acıdır, bu yüzden burada sapkın doğasının büyük bir kullanımını bulduğum için mutluyum!)

Aksi takdirde, kod yalnızca gerekli sonucu sol üst çeyrek, rastgele bir eleman (yerine yapar j-1, j-1rastgele rakam (bit) 0:9-1bit) ve gerekli simetri için katlanır. Ve ive jçift ​​ve tek vakalarla başa çıkmak için gereklidir.

Python3, 287 bayt

Burada bir şey golf ilk deneyin; Eminim birisi daha iyisini yapabilir:

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)

Çevrimiçi deneyin!

HyperNeurtrino, Ourous ve Heiteria sayesinde bu rakam 193 bayta düştü (yorumlara bakın). Ancak TFeld, birden fazla çağrının sampleen az Nfarklı karakterleri garanti etmediğini doğru bir şekilde belirtti .

Bunları aklınızda tutarak, Nçalışma başına en az farklı karakterleri garanti etmesi gereken bu yeni sürümü deneyin .

Python3, 265 260 bayt, en az Nfarklı karakterler

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)

Çevrimiçi deneyin!

APL (Dyalog Klasik) , 45 44 43 40 bayt

-1 bayt için teşekkürler @ Adám

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

Çevrimiçi deneyin!

⌈matrisin simetrik olmasını sağlamak için yansımalarıyla (max) kullanır , bu yüzden alfabenin ikinci kısmına doğru eğimlidir

basamak 0 ... 25 mod 10'dan eşit olarak seçilir, bu nedenle değerleri düşürmek için küçük bir önyargıya sahiptir

Japt , 31 bayt (Sabit basamak konumu)

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

Çevrimiçi deneyin!

Japt , 41 byte (Rastgele hane konumu)

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

Çevrimiçi deneyin!

açıklama

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

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]

Çevrimiçi deneyin!

05AB1E , 29 40 38 bayt

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

+ 11 bayt yine tek girişler için göz önünde kural 3 tutarken rastgele bir konumda olmak basamağını düzeltmek için ..
-2 sayesinde bayt @MagicOctopusUrn değişen îïiçin òve konumunun değiştirilmesi ».

Online Deneyin ait biraz daha test durumları doğrulamak .

Eski ( 29 27 bayt ), rakamın her zaman köşelerde bulunduğu yere cevap verir:

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

Çevrimiçi deneyin veya daha fazla test vakası doğrulayın .

Açıklama:

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 bayt

Tavan kedisi sayesinde 2 bayt tasarruf etti.

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

Çevrimiçi deneyin!

Açıklama:

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

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

Çevrimiçi deneyin!

Yorumlananlar

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

Temiz , 346312 bayt

yarın daha fazla golf oynayacak

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

Çevrimiçi deneyin!

Python 3 , 197 bayt

@Emigna tarafından belirtildiği gibi, garip değerleri için çalışmıyor N(soruyu doğru anlamadım)

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

Çevrimiçi deneyin!

Ben randint()+ sample()+ çağrıları shuffle()çok fazla olduğunu düşünüyorum ve yerinde karıştırma kurtulmak harika olurdu :)

Eminim bu bölüm (harfleri ve rakamları seçer) biraz daha golf olabilir.

Piton 2 , 275 266 bayt

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]

Çevrimiçi deneyin!

Diziyi karakter listelerinin listesi olarak döndürür. Kural 1'i karşılamak için bir karakter havuzu oluşturduk:

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

Sonraki zor bit, kural 3'tür: tam olarak 2 sütun ve bir rakam içeren satırlar olmalıdır ; bu ntuhaftır, seçilen rakam orta sütunda veya orta sırada görünmeyebilir. Diziyi iki kez yansıtılan bir kare alt dizi skullanarak oluşturduğumuz için, burada kullanılarak gerçekleştirilir:

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

yani, en az bir kez karıştırın; ve eğer ntuhafsa, rakam son sütunda veya son satırındaysa döngüye devam edin s.

Pyth , 48 bayt

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

Burada çevrimiçi deneyin .

Program 3 bölümden oluşmaktadır - palindromizasyon fonksiyonunun tanımı, sayısal konum seçimi ve ana fonksiyon.

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

Birkaç karışık alfabe kullanmak, benzersiz karakter sayısının her zaman giriş numarasından daha fazla olmasını sağlamalıdır.

Python 2 / Python 3, 227 bayt

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

biraz ungolfing:

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

Aşağıdaki eski, neredeyse doğru sürümler:

Python2, Python3, 161 bayt

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 farklı elementin neredeyse garantili olduğu anlaşılıyor .

Python 2 / Python 3, 170 bayt

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

Kural 3'ü unuttum gibi görünüyor. Ayrıca [: n * n] bir şekilde içeri girdi.