일반적으로 "Y없이 X를하는 것"은 초보자가 과제를 작성하는 데 걸림돌이 될 수 있다고합니다 ( source ). 그러나 나는 건방진이며 Y없이 X를 확실히 만들 수 있다고 생각합니다 . 무작위로. 아, 그래요

도전 과제 : 홀수 정수 n가 1보다 크거나 같으면 n임의의 인쇄 가능한 ASCII 문자 ( "y"및 "Y"및 공백)로 만들어진 변의 길이의 ex를 출력 하십시오. 허용되는 모든 문자는 반드시 0이 아닌 반드시 발생해야하지만 반드시 균일하지는 않습니다. 이것은 코드 골프 이므로 바이트 단위의 가장 짧은 코드가 이깁니다. 그러나 각 문자를 무작위로 추출해야합니다. 즉, 우연히 그렇지 않으면 ex의 스트럿이 같지 않아야합니다.

등장 할 문자

!#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXZ[\]^_`abcdefghijklmnopqrstuvwxz{|}~"

전 건축

측면 길이 1 :

x

측면 길이 3 :

x x
 x
x x

측면 길이 5 :

x   x
 x x
  x
 x x
x   x

기타

출력 예

input
output
empty line

3
h 2
 ^
9 5

1
:

5
D   1
 W z
  W
 q j
W   1

구현 예

유효하지 않은 입력을 처리 할 필요는 없습니다.

function generate(sideLength){
    var result = "";
    var INNER = "@"
    for(var i = 0; i < sideLength; i++){
        var p = i < sideLength / 2 ? i : sideLength - i - 1;
        result += " ".repeat(p) + ((sideLength / 2 | 0) == p ? "" : INNER) + " ".repeat(Math.max(sideLength - p * 2 - 2, 0)) + INNER + "\n";
    }
    
    return result.replace(RegExp(INNER, "g"), function(e){
        let c = "y";
        while(c === "y" || c === "Y"){
            c = String.fromCharCode((Math.random() * 94) + 33 | 0);
        }
        return c;
    });
}

function print(v){
    output.innerHTML = "";
    output.appendChild(document.createTextNode(v));
}

function update(){
    var n = Number(input.value);
    if(n !== Math.floor(n)) print("error: " + n + " is not an integer.");
    else if(n % 2 === 0)    print("error: " + n + " is not odd.");
    else if(n < 1)          print("error: " + n + "is less than one.");
    else                    print(generate(n));
}

input.onchange = update;

update();

* {
  font-family: Consolas, monospace;
}

#output {
  white-space: pre;
}

<input id="input" min=1 value=1 type=Number>
<div id="output"></div>

Pyth, 28 27 26 25 바이트

jmuXGHO-rF "! ~" "Yy"{, d-tQd *; Q 
VQuXGHO-rF "! ~" "Yy"{, N-tQN * d 
VQuXGHO-r \! \ ~ "Yy"{, N-tQN *디
VQuXGHO-r \! \ ~ "Yy", N-tQN * d

테스트 스위트.

루비, 102 바이트

Array#sample문자 세트에서 샘플링을 반복하지는 않지만 문자 분포가 완벽하게 균일 할 필요는 없으므로 괜찮습니다! 재귀 함수는 라인 배열을 반환합니다.

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

f=->l{w,x,y,z=([*?!..?~]-%w"y Y").sample 4
l<2?[w]:[w+(s=' '*(l-2))+x,*f[l-2].map{|e|" #{e} "},y+s+z]}

실제로 62 바이트

"!⌂"♂┘ix♂c"Yy"@-╗½≈u;r2@∙`i=`M╪k`;dXR@+`M;dXR@+`"╜J' aI"£MΣ`Mi

이것은 내가 작성한 가장 긴 실제로 프로그램 중 하나입니다.

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

설명:

1 부 : 캐릭터리스트 설정

"!⌂"♂┘ix♂c"Yy"@-
"!⌂"              push the string "!⌂"
    ♂┘            CP437 ordinal of each character ([21, 127])
      ix          range(21, 127)
        ♂c        character at each ordinal (list of printable ASCII characters)
          "Yy"@-  set difference with ["Y", "y"] (printable ASCII except "Y" and "y")

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

Part 2 : X에 대한 부울 배열 구성

½≈u;r2@∙`i=`M╪k`;dXR@+`M;dXR@+
½≈u;                            two copies of int(input/2)+1
    r                           range
     2@∙                        Cartesian product with itself
        `i=`M                   for each sublist: push 1 if both elements are equal, else 0
             ╪k                 split into int(input/2)+1-length chunks
                                (at this point, we have one quarter of the X)
               `;dXR@+`M        mirror each sublist (one half of the X)
                        ;dXR@+  mirror the entire list (the whole X)

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

제 3 부 : 임의의 문자를 따기

`"╜J' aI"£MΣ`Mi
`"╜J' aI"£MΣ`M   for each row:
 "╜J' aI"£M        for each column:
  ╜J                 push a random value from the character list
    '                push a space
      a              invert the stack
       I             take the character if the value is 1, else take the space
           Σ       concatenate the strings
              i  flatten the list and let implicit output take care of the rest

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

Mathematica, 146 바이트

a:=RandomChoice[33~CharacterRange~126~Complement~{"Y","y"}];StringRiffle[Normal@SparseArray[{{b_, b_}:>a,{b_,c_}/;c-1==#-b:>a},{#,#}," "],"
",""]&

익명의 기능. 숫자를 입력으로 받아서 문자열을 출력으로 반환합니다.

파이썬 2, 171 바이트

from random import*
def x(n):
 w=range(-n/2+1,n/2+1)
 for i in w:
  o=''
  for j in w:c=randint(33,124);c+=(c>88)+(c>119);c=[c,32][bool(i^j and i^-j)];o+=chr(c)
  print o

확률이 균일 한 임의의 문자를 선택할 수 있습니다.

여기에서 사용해보십시오 : ideone link

편집 : 수정에 대한 Morgan Thrapp에게 감사드립니다.

파이썬 142 139 135 바이트

이것은 문자별로 사각형 문자를 만드는 간단한 구현입니다. 문자가 대각선에 있다면 : 임의의 문자를 사용하고, 그렇지 않으면 : 공백을 사용하십시오. 또한 정규식 대체와 임의의 int를 사용하여 Y문자가 아닌 문자 를 생성 합니다.

import re,random
lambda x:''.join('\n'*(i%x<1)+re.sub("y|Y","t",chr(random.randint(33,126))+' ')[i%x!=i/x!=x-i%x-1]for i in range(x*x))

설명 [Old]

"\n".join( ... for i in range(x)) # Create 'x' lines 
''.join( ... for j in range(x))   # Create 'x' chars on each line
(...)[j!=i!=x-j-1]                # Not on diagonals? 2nd char in "? "; Else, choose the 1st
j!=i                              # Not on downward diagonal
i!=x-j-1                          # Not on upward diagonal
re.sub("y|Y","t", ... )           # Replace y or Y for t
chr(random.randint(33,126))+' '   # Random char + a space

최신 정보

• -4 [16-07-30] 줄 바꿈 조건부 단축
• -3 [16-07-30] 단일 for-loop로 변경
• -6 [16-07-29] 3 진 op에 대한 if 문을 교환했습니다. @RootTwo 감사합니다
• -11 [16-07-27] 추가 괄호 / 공간을 제거하고 if 문을 뒤집 었습니다.
• -49 [16-07-27] 사각형을 단계별로 생성하여 @squeamishossifrage의 방법을 어겼습니다. 감사합니다!
• -10 [16-07-27] @ ConorO'Brien에서 임의의 문자 람다 + 수학 항목 단축
• -22 [16-07-26] 람다 + 기타 골프에서 짜기
• -6 [16-07-26] import*-@KevinLau 감사합니다

Dyalog APL , 35 바이트

⎕UCS 32+(⊢+∊∘57 89)⌊?95×(⊢∨⌽)∘.=⍨⍳⎕

⎕
⍳그 수
∘.=⍨평등 표 (즉, 대각선이 1을 가짐)
(⊢∨⌽)자체 또는 거울 이미지 (두 대각선을 제공함 )를 통해 숫자 1을 프롬프트 하여 대각선의 경우 1에서 95 사이의 rand int
95×에 95와
?rand int를 곱하고 나머지
⌊바닥의 경우 0에서 1 사이의 란이 표시 됩니다. float 제거
(⊢+∊∘57 89)하기 {57,89} (Yy – 32)의 멤버 인 요소에 1을 더하고
32+0을 공백으로 만들고 32를 다른 범위
⎕UCS로 옮기고 적절한 범위에있는 숫자 를 텍스트로 변환

TryAPL !

파이썬 2.7, 205 바이트 :

from random import*;C=input()/2;S=' ';R=range;Z=lambda:chr(choice(R(33,89)+R(90,121)+R(122,128)));T=lambda*G:''.join([S*i+Z()+S*(2*(~-C-i)+1)+Z()+S*i+'\n'for i in R(*G)]);print T(C)+S*C+Z()+'\n'+T(~-C,-1,-1)

온라인으로 사용해보십시오! (아이디어)

MATL , 28 바이트

6Y2'Yy 'X-iZr1MZrXdwXdP2$X>c

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

허용되는 모든 문자는 같은 확률로 나타납니다. 입력조차도 가능합니다.

6Y2     % Predefined literal of ASCII chars from 32 to 126
'Yy '   % Not allowed chars
X-      % Set difference. Produces the set of allowed chars
i       % Input number, n
Zr      % Random sample without replacement. Gives a string with n chars taken from 
        % the allowed set
1MZr    % Do the same
Xd      % Diagonal matrix. Zeros will be displayed as spaces
wXd     % Diagonal matrix with the other string
P       % Flip vertically
2$X>    % Maximum of the two matrices
c       % Convert to char. Implicitly display

C, 154 바이트 (또는 보일러 플레이트가없는 119)

o(w,c){c=rand()%94+33;printf("%*c",w,w?c+!(c&95^89):10);}main(h){scanf("%d",&h);srand(time(0));for(int n=h,p;n--;)p=abs(h/2-n),o(h/2-p+1),p&&o(p*2),o(0);}

함수 또는 119 바이트 X(h)와 srand(time(0))다른 곳에서 알아서 :

o(w,c){c=rand()%94+33;printf("%*c",w,w?c+!(c&95^89):10);}X(h,n,p){for(n=h;n--;)p=abs(h/2-n),o(h/2-p+1),p&&o(p*2),o(0);}

고장:

o(w,c){                         // "Output" function, for all printing
    c=rand()%94+33;             // Generate random char, whether we need it or not
    printf("%*c",               // Print a char with some number of leading spaces
           w,                   // Use "w" (width) - 1 leading spaces
           w?                   // Either print the random char...
             c+!(c&95^89)       // (exclude "y" and "Y" by incrementing to "z"/"Z")
                         :10    // ...or print a newline if called with w = 0
    );
}
main(h){                        // Main function; repurpose argc to store grid size
    scanf("%d",&h);             // Get grid size from stdin
    srand(time(0));             // Boiler-plate for random number seeding
    for(int n=h,p;n--;)         // Loop over all lines (count down to save chars)
        p=abs(h/2-n),           // Calculate half-distance between "X" bars
        o(h/2-p+1),             // Output the first half of the "X" (">")
        p&&                     // If we are not in the centre:
           o(p*2),              //   output the second half of the "X" ("<")
        o(0);                   // Output a newline
}

x86 기계 코드, 70 바이트

60 89 d7 31 db 43 88 ce b2 fe 49 d1 e1 87 da 0f
c7 f0 24 7f 3c 22 72 f7 48 3c 79 74 f2 3c 59 74
ee aa 49 7c 1c 00 df 79 06 86 f7 42 43 eb f6 f6
c3 01 74 03 b0 0a aa 51 88 f9 b0 20 f3 aa 59 eb
cc c6 07 00 61 c3

내 실행 코드가 분해되었습니다.

0000003d <myheh>:                                       
  3d:   60                      pusha                   
  3e:   89 d7                   mov    %edx,%edi        
  40:   31 db                   xor    %ebx,%ebx        
  42:   43                      inc    %ebx             
  43:   88 ce                   mov    %cl,%dh          
  45:   b2 fe                   mov    $0xfe,%dl        
  47:   49                      dec    %ecx             
  48:   d1 e1                   shl    %ecx             

0000004a <myloop>:                                      
  4a:   87 da                   xchg   %ebx,%edx        

0000004c <myrand>:                                      
  4c:   0f c7 f0                rdrand %eax             
  4f:   24 7f                   and    $0x7f,%al        
  51:   3c 22                   cmp    $0x22,%al        
  53:   72 f7                   jb     4c <myrand>      
  55:   48                      dec    %eax             
  56:   3c 79                   cmp    $0x79,%al        
  58:   74 f2                   je     4c <myrand>      
  5a:   3c 59                   cmp    $0x59,%al        
  5c:   74 ee                   je     4c <myrand>      
  5e:   aa                      stos   %al,%es:(%edi)   
  5f:   49                      dec    %ecx             
  60:   7c 1c                   jl     7e <mydone>      

00000062 <mylab>:                                       
  62:   00 df                   add    %bl,%bh          
  64:   79 06                   jns    6c <myprint>     
  66:   86 f7                   xchg   %dh,%bh          
  68:   42                      inc    %edx             
  69:   43                      inc    %ebx             
  6a:   eb f6                   jmp    62 <mylab>       

0000006c <myprint>:                                     
  6c:   f6 c3 01                test   $0x1,%bl         
  6f:   74 03                   je     74 <myprint1>    
  71:   b0 0a                   mov    $0xa,%al         
  73:   aa                      stos   %al,%es:(%edi)   

00000074 <myprint1>:                                    
  74:   51                      push   %ecx             
  75:   88 f9                   mov    %bh,%cl          
  77:   b0 20                   mov    $0x20,%al        
  79:   f3 aa                   rep stos %al,%es:(%edi) 
  7b:   59                      pop    %ecx             
  7c:   eb cc                   jmp    4a <myloop>      

0000007e <mydone>:                                      
  7e:   c6 07 00                movb   $0x0,(%edi)      
  81:   61                      popa                    
  82:   c3                      ret                     

ecx에서 X의 크기와 edx의 출력 버퍼에 대한 포인터를받는 함수입니다.

출력 버퍼를 바이트로 순차적으로 채 웁니다. 2 * n - 1반복 이 있습니다 (출력 할 공백이 아닌 문자 수와 동일). 각 반복에서 다음을 수행합니다.

• 난수 생성
• 범위에 맞도록 숫자로 바이올린을 칠하십시오. 나쁘면 돌아가서 새로 생성하십시오.
• 임의의 문자를 인쇄
• 줄 바꿈 인쇄 (다른 모든 반복)
• 적절한 수의 공백을 인쇄하십시오

임의의 숫자에서 임의의 문자로의 변환은 눈에 띄지 않습니다.

myrand:
    rdrand eax;
    and al, 7fh;
    cmp al, 22h;
    jb myrand;
    dec eax;
    cmp al, 'y';
    je myrand;
    cmp al, 'Y';
    je myrand;

흥미로운 부분은 공간 수의 계산입니다. 다음 숫자를 생성해야합니다 (예 : N = 9).

7    1
5    2
3    3
1    4

     3
1    2
3    1
5    0
7

숫자는 두 개의 산술 진행에서 교대로 가져옵니다. 첫 번째 단계는 -2 단계로 내려 가고 두 번째 단계는 1 단계로 올라갑니다. 첫 번째 진행이 -1에 도달하면 (X 중간) 글리치가 발생하고 (-1이 제거됨) 진행 방향이 바뀝니다.

진행률은 레지스터 ebx와 edx-높은 부분 bh에 dh저장되고 현재 번호와 낮은 부분 bl을 dl저장하고 단계를 저장합니다. 진행을 번갈아 가려면 코드에서 레지스터를로 바꿉니다 xchg.

진행률이 -1 ( mylab라벨 주위)에 도달하면 두 레지스터가 증가하여 단계가에서로 변경 -2, 1됩니다 -1, 2. 이것은 또한 레지스터의 역할을 변경하므로 레지스터의 높은 부분을 교체합니다.

함수의 끝에 문자열의 끝을 나타내는 0 바이트를 저장합니다.

루아, 277 바이트

글쎄 ... 루아는 문자열 조작에 능숙하다 : D. local성명서에서 처음 사용해야 했습니다! 전역 함수 unpack를 tableLua 5.2에서 객체로 옮겼 기 때문에 5.3 대신 Lua 5.1을 사용하여 바이트를 절약 할 수 있습니다. 그러나 나는 최신 버전을 고수하는 것을 선호합니다 :).

단일 매개 변수로 호출해야하는 함수를 정의하고 (두 번째 매개 변수는 재귀 목적으로 사용됨) 문자열을 리턴합니다.

function f(n,N)N=N or n e=" "p="\n"r=math.random C=e.char
R={}for i=1,4 do x=r(33,126)R[i]=x~=89 and x~=121 and x or r(33,88)end
local s,S,a,b,c,d=e:rep((N-n)/2),e:rep(n-2),table.unpack(R)return
n<2 and s..C(a)..p or s..C(a)..S..C(b)..s..p..f(n-2,N)..s..C(c)..S..C(d)..s..p
end

언 골프

function f(n,N)                       
  N=N or n                          -- N is equal to the n we had on the first call
  e=" "                             -- shorthand for the space
  p="\n"                            -- shorthand for the newline
  r=math.random                     -- shorthand for math.random
  C=e.char                          -- uses the string e to obtain the function string.char
  R={}                              -- define an array for our random values
  for i=1,4                         -- iterate 4 times (for the random characters)
  do
    x=r(33,126)                     -- random between ASCII "!" and "~"
    R[i]=x~=89 and x~=121           -- if we didn't pick y or Y
           and x                    -- keep this number
         or r(33,88)                -- or roll for a character between "!" and "X"
  end
  local s,S                         -- these variables have to be local
          ,a,b,c,d                  -- or the recursion would change them
         =e:rep((N-n)/2),e:rep(n-2) -- s and S are the number of spaces for the X
           ,table.unpack(R)         -- a,b,c and d are the 4 random characters
  return n<2                        -- if n==1 
           and s..C(a)..p           -- we're at the center of the X, time to end recursion
         or                         -- else
           s..C(a)..S..C(b)..s..p   -- concatenate the topmost line for n
           ..f(n-2,N)               -- with the inner X
           ..s..C(c)..S..C(d)..s..p -- and the bottom line
end

자바 스크립트 (ES6) 137 131 125 바이트

n=>[...Array(n)].map((_,i,a)=>String.fromCharCode(...a.map((r=Math.random()*94,j)=>i-j&&i+j+1-n?32:(r+72&95&&r)+33))).join`\n`

어디 \n리터럴 개행 문자를 나타냅니다. 편집 : 식 ' '내부 를 이동하여 1 바이트를 저장했습니다 String.fromCharCode. 무작위 문자 생성을 불균일하게하여 5 바이트를 절약했습니다. 식이 r+72&95에 매핑 값 제로 Y및 y및은 !그 자리에서 생성된다. 확산이 필요 String.fromCharCode하지 않다는 것을 깨달았을 때 4 바이트를 절약 했습니다 join. @ edc65에서 트릭을 훔쳐서 2 바이트를 절약했습니다.

PowerShell v2 +, 112 바이트

Param($i)function f{Random(33..126-ne121-ne89|%{[char]$_})};1..$i|%{$a=,' '*$i;$a[$_-1]=f;$a[$i-$_]=f;$a-join''}

명령 행에서 입력을 읽습니다.

각 행에 대해 공백 배열이 작성되고 function f에서 가져온 문자로 채워진 올바른 색인이 작성된 다음 char 배열이 결합되어 한 행으로 출력됩니다.

MATLAB, 86 바이트

a=@(n)(char(changem(randi(92,n),33+[0:55 57:87 89:93],1:92).*(eye(n)|fliplr(eye(n)))))

몇 가지 예 :

>> a(1)

ans =

i


>> a(3)

ans =

~ {
 Z 
* ^


>>a(5)

ans =

k   E
 | M 
  }  
 ] s 
b   t


>> a(10)

ans =

Q        k
 +      a 
  j    w  
   X  [   
    rO    
    %3    
   P  d   
  K    q  
 r      & 
?        v

핍 , 33 바이트

32 바이트 코드, -l플래그는 +1 이상하게도 코드는 ...로 시작 Y하고 끝나고 y...

Ya{$=a|$+a=y-1?RCPARM-`y`s}MMCGy

입력을 명령 행 인수로 사용합니다. 온라인으로 사용해보십시오!

설명

적절한 크기의 그리드를 구성합니다. 대각선의 요소를 y가 아닌 임의의 문자로 바꾸고 다른 모든 요소는 공백으로 바꿉니다.

                                  a is 1st cmdline arg; PA is printable ASCII characters;
                                  s is space (implicit)
Ya                                Yank a into y (global var, accessible within functions)
                             CGy  y by y coordinate grid
  {                       }MM     To each coordinate pair, map this function:
   $=a                             Fold on equality (true if both elements are equal)
      |                            Logical OR
       $+a                         Fold on +
          =y-1                     and test if equal to size - 1
              ?                    If the preceding expression is true, then:
                 PARM               From printable ASCII chars, remove         
                     -`y`           regex matching y, case-insensitive
               RC                   Take a random choice from the resulting string
                         s         Else, space
                                  The whole expression returns a nested list, which is
                                  autoprinted as lines of concatenated items (-l flag)

PHP, 135 바이트

<?php for(;$i<$n=$argv[1];){$s=str_pad('',$n);$s[$i?:0]=chr(rand(33,126));$s[$n-++$i]=chr(rand(33,126));echo str_ireplace(Y,X,"$s
");}

상당히 간단한 접근 방식은 str_pad를 사용하여 필요한 길이의 공백 문자열을 만들고 필요한 문자를 임의의 문자로 바꾸고 Y를 대소 문자를 구분하지 않고 X로 바꾼 다음 줄을 에코합니다.
2n + 3 통지를 생성하지만 평소와 같이 괜찮습니다.

이맥스 리스프, 269 바이트

(defalias'n'number-sequence)(set'c(mapcar'string(delq 89(delq 121(n 33 126)))))(defun c()(nth(random(length c))c))(defun s(x)" ")(defun x(l)(let((s(mapcar's(n 1 l))))(dotimes(i l)(set'x(copy-seq s))(setf(nth i x)(c)(nth(-(length x)i 1)x)(c))(message(apply'concat x)))))

언 골프 및 약간 수정 :

(defvar c (mapcar 'string (delq 89 (delq 121 (number-sequence 33 126)))))
(defun c() (nth (random (length c)) c))
(defun s(x)" ")
(defun x(l)
  (let ((s(mapcar's(n 1 l)))
        x)
    (dotimes (i l)
      (set 'x (copy-seq s))
      (setf (nth i x) (c)
            (nth (- (length x) i 1) x) (c))
      (message (apply 'concat x)))))

자바 스크립트 (ES6) 128 131

thx @Neil으로 저장된 3 바이트 편집

부피가 크지 만 아마도 최선의 방법은 아닙니다. 보너스-홀수 또는 짝수 입력으로 작동합니다.

n=>[...Array(n)].map((_,i,z)=>String.fromCharCode(...z.map((r=1+Math.random()*94,j)=>32+(j==i|j==n+~i&&(r+7&31?r:25))))).join`
`

F=n=>[...Array(n)].map((_,i,z)=>String.fromCharCode(...z.map((r=1+Math.random()*94,j)=>32+(j==i|j==n+~i&&(r+7&31?r:25))))).join`\n`

Z=_=>{
    o=F(+S.value),O.textContent=o,/y/i.test(o)||setTimeout(Z,100)
}
setTimeout(Z,100)

<input id=S value=15 type=number>
<pre id=O></pre>

C, 268 바이트

V(c){for(c=89;c==89||c==121;c=rand()%95+33);return c;}p(n,s){n^1?s-n?printf("%*.c",s-n,32):0,printf("%c%*.c%c\n",V(),n*2-3,32,V()),p(n-1,s),s-n?printf("%*.c",s-n,32):0,printf("%c%*.c%c\n",V(),2*n-3,32,V()):printf("%*.c%c\n",s-n,32,V());}f(n){srand(time(NULL));p(n,n);}

그릴 f()크기로 전화 하십시오 x.

Matricks , 79 바이트 (비경쟁)

Matricks 는 x와 모든 임의의 값을 만들기 시작하는 데 탁월 하지만 조건부와 관련하여 퍼집니다 ...

몇 가지 버그를 수정하고이 챌린지가 게시 된 후 모든 새로운 기능을 작동시켜야했기 때문에 이것을 비경쟁으로 표시했습니다.

m:n;:1;mr=c:L:L;k({}|{X;})*{m_?33:126;;:L:l;miC<121,89>:gr:c;;:49:gr:c;;:L:l;};

로 실행 python matricks.py x.txt [[]] <input> --asciiprint

설명:

m:n;:1;mr=c:L:L;                   #Initialize matrix to be a square with
                                   #a diagonal of 1s
k...;                              #Set the output to...
({}|{X;})*                         #The boolean x matrix multiplied by...
{m_?33:126;;:L:l;                  #A bunch of random characters
miC<121,89>:gr:c;;:49:gr:c;;:L:l;} #But make sure they are not y or Y

이것은 짝수도 지원합니다.

파이썬 2 204 191 183 바이트

자, 여기 파이썬 경쟁이 치열 해지고 있습니다. 다음은 가능한 한 많은 바이트를 면도하려는 시도입니다. 지금까지 나는 붙어 있습니다 (Ok, 다시 붙어).

임의의 문자를 선택하는 방법에 대한 @NonlinearFruit의 크레딧.

183 바이트 버전 :

import re,random
s=i=input();t=lambda:re.sub("y|Y","t",chr(random.randint(33,126)))
while i>-s:i-=2;u=abs(i);z=(s-u)/2-1;print('',' '*-~z+t()+'\n')[-1==i]+(' '*z+t()+' '*u+t())*(i>-s)

온라인으로 사용해보십시오! (아이디어)

주요 변경 사항은 조건부를 다시 작성하는 것입니다

(" "*(z+1)+t()+"\n"if -1==i else"") 

같이

(""," "*-~z+t()+'\n')[-1==i]

7 바이트를 절약합니다.

191 바이트 버전 :

import re,random
s=i=input();t=lambda:re.sub("y|Y","t",chr(random.randint(33,126)))
while i>-s:
 i-=2;u=abs(i);z=(s-u)/2-1;print(' '*(z+1)+t()+'\n'if -1==i else'')+(' '*z+t()+' '*u+t())*(i>-s)

온라인으로 사용해보십시오! (아이디어)

주요 변경 사항은 임의의 문자를 선택하는 방법과 같은 몇 가지 코드를 재 배열되어 s=input();i=s;지고 s=i=input();는 제거되지 r=range가 더 이상 필요로 할당 및 호출 abs이 코드의 바이트 이하의 결과로 직접.

파이썬에서 이전의 가장 짧은 답변을 1 바이트 뛰었습니다! @아르 자형. Kap의 접근법은 임의의 문자를 생성하는 데 사용됩니다. while 루프의 각 반복은 ex의 행을 인쇄합니다.

204 바이트 버전 :

from random import*
s=input();i=s;a=abs;r=range;t=lambda:chr(choice(r(33,89)+r(90,121)+r(122,128)))
while i>-s:
 i-=2;z=(s-a(i))/2-1;print(' '*(z+1)+t()+'\n'if -1==i else'')+(' '*z+t()+' '*a(i)+t())*(i>-s)

온라인으로 사용해보십시오! (아이디어)

작동 방식에 대한 아이디어를 얻는 Ungolfed 버전 :

from random import *
random_character = lambda : chr(choice(range(33,89)+range(90,121)+range(122,128)))

size = input()
current_row = size

while current_row > -size:
    current_row-=2
    n_leading_spaces = (size-abs(current_row)/2)-1 
    row_to_print = ''
    if current_row == -1:
        row_to_print = ' ' * (n_leading_spaces+1) + random_chr() + '\n'
    if current_row > -size:
        row_to_print += ' ' * n_leading_spaces + random_chr()+' '*abs(current_row)+random_chr()
    print row_to_print

1 자 케이스를 다루기가 어려웠습니다!

SmileBASIC, 97 바이트

INPUT S
FOR X=1TO S
FOR Y=1TO S
Q=RND(93)+33?CHR$((Q+!(Q-121&&Q-89))*(X==Y||X+Y==S+1));
NEXT?NEXT

대신 각 문자 또는 뭔가 사이의 공간의 수를 계산 할 필요없이, 그냥 모든 위치에 인쇄하기로 결정 X==Y나 X+Y==Size+1.
이 생성하는 경우 임의 문자 발생기는 1을 추가 y하거나 Y, 그렇게 z하고 Z약간 평소보다 더 일반적이다.

PHP, 100 바이트

for(;($x%=$n=$argv[1])?:$y++<$n&print"\n";)echo strtr(chr($y+$x++-$n&&$x-$y?32:rand(33,126)),yY,zZ);

명령 행 인수에서 입력을받습니다. 로 실행하십시오 -nr.

결합 루프는 위치에 따라 문자를 인쇄합니다

고장

for(;
    ($x%=$n=$argv[1])       // inner loop
        ?
        :$y++<$n&print"\n"  // outer loop; print newline
;)
    echo strtr(chr(             // 2. replace Y with Z; print
        $y+$x++-$n&&$x-$y       // 1: if position is not on diagonals
            ?32                 // then space
            :rand(33,126)       // else random printable
    ),yY,zZ);