Thông thường, người ta nói rằng "Làm X mà không có Y" có thể là một cái bẫy cho người mới bắt đầu viết thử thách ( nguồn ). Tuy nhiên, tôi tự phụ và nghĩ rằng tôi chắc chắn có thể tạo X mà không cần bất kỳ Ys nào. Ngẫu nhiên. Ồ vâng, điều này sẽ tốt.

Thách thức: Cho một số nguyên lẻ nlớn hơn hoặc bằng 1, xuất ra một chiều dài bên nđược làm bằng các ký tự ascii có thể in ngẫu nhiên sans "y" và "Y" và khoảng trắng. Tất cả các nhân vật được phép phải có cơ hội khác không xảy ra, nhưng không nhất thiết phải đồng nhất. Đây là một môn đánh gôn để mã ngắn nhất tính bằng byte sẽ thắng. Tuy nhiên, bạn nên chọn ngẫu nhiên mỗi char - nghĩa là các thanh chống của ex không nên bằng nhau, trừ khi có cơ hội.

Các ký tự xuất hiện

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

Xây dựng ex

Chiều dài bên 1:

x

Chiều dài bên 3:

x x
 x
x x

Chiều dài bên 5:

x   x
 x x
  x
 x x
x   x

Vân vân.

Ví dụ đầu ra

input
output
empty line

3
h 2
 ^
9 5

1
:

5
D   1
 W z
  W
 q j
W   1

Ví dụ thực hiện

Bạn không cần phải xử lý các đầu vào không hợp lệ.

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 byte

jmuXGHO-rF "! ~" "Yy" {, d-tQd *; Q 
VQuXGHO-rF "! ~" "Yy" {, N-tQN * d 
VQuXGHO-r \! \ ~ "Yy" {, N-t *Cười mở miệng
VQuXGHO-r \! \ ~ "Yy", N-tQN * d

Bộ thử nghiệm.

Ruby, 102 byte

Array#samplekhông lặp lại để lấy mẫu từ bộ ký tự, nhưng điều đó không sao vì phân phối ký tự không nhất thiết phải hoàn toàn đồng nhất! Hàm đệ quy, trả về một mảng các dòng.

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

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

Trên thực tế, 62 byte

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

Đây là một trong những chương trình thực tế dài nhất tôi từng viết.

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

Giải trình:

Phần 1 : thiết lập danh sách nhân vật

"!⌂"♂┘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")

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

Phần 2 : xây dựng mảng boolean cho 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)

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

Phần 3 : chọn các ký tự ngẫu nhiên

`"╜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

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

Toán học, 146 byte

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

Chức năng ẩn danh. Lấy một số làm đầu vào và trả về một chuỗi làm đầu ra.

Python 2, 171 byte

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

Đảm bảo chọn các ký tự ngẫu nhiên với xác suất thống nhất.

Dùng thử tại đây: liên kết ideone

EDIT: Cảm ơn Morgan Thrapp vì đã sửa chữa.

Python, 142 139 135 byte

Đây là một thực hiện thẳng về phía trước tạo ra các nhân vật vuông theo nhân vật. Nếu ký tự nằm trên đường chéo : sử dụng char ngẫu nhiên, khác : sử dụng khoảng trắng. Điều này cũng sử dụng thay thế regex và int ngẫu nhiên để tạo ra các Yký tự không :

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

Giải thích [Cũ]

"\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

Cập nhật

• -4 [16-07-30] Rút ngắn điều kiện dòng mới
• -3 [16-07-30] Thay đổi thành vòng lặp đơn
• -6 [16-07-29] Trao đổi nếu câu lệnh cho ternary op. Cảm ơn @RootTwo
• -11 [16-07-27] Đã xóa dấu ngoặc / dấu cách thừa và lật nếu câu lệnh
• -49 [16-07-27] Phương pháp vắng mặt @ squeamishossifrage bằng cách tạo ra hình vuông từng bước, Cảm ơn!
• -10 [16-07-27] Rút ngắn char lambda ngẫu nhiên + công cụ toán học từ @ ConorO'Brien
• -22 [16-07-26] Siết chặt trong lambda + chơi golf linh tinh
• -6 [16-07-26] import*- Cảm ơn @KevinLau

APL Dyalog , 35 byte

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

⎕nhắc về số
⍳1 thông qua
∘.=⍨bảng cân bằng số đó (tức là đường chéo có 1s)
(⊢∨⌽)HOẶC hình ảnh phản chiếu của nó (cho cả hai đường chéo)
95×nhân với 95
?rand int từ 1 đến 95 cho các đường chéo, rand nổi giữa 0 và 1 cho
⌊sàn còn lại để loại bỏ các số float
(⊢+∊∘57 89)thêm một vào các thành phần là thành viên của {57,89} (Yy - 32)
32+thêm 32 để biến số 0 thành khoảng trắng và các số khác vào phạm vi thích hợp
⎕UCSchuyển đổi thành văn bản

Hãy thử !

Python 2.7, 205 byte:

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)

Dùng thử trực tuyến! (Ý)

MATL , 28 byte

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

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

Tất cả các nhân vật được phép có cùng xác suất xuất hiện. Hoạt động cho đầu vào thậm chí quá.

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 byte (hoặc 119 mà không có tấm nồi hơi)

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

Hoặc 119 byte là một hàm X(h)với srand(time(0))chăm sóc chụp ở những nơi khác:

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

Phá vỡ:

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
}

mã máy x86, 70 byte

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

Mã thực thi của tôi, đã được tháo rời:

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                     

Đây là một hàm nhận kích thước của X trong ecx và là một con trỏ tới bộ đệm đầu ra trong edx.

Nó lấp đầy bộ đệm đầu ra tuần tự bằng byte. Có các 2 * n - 1lần lặp (bằng số lượng ký tự không phải khoảng trắng để xuất). Ở mỗi lần lặp, nó thực hiện như sau:

• Tạo một số ngẫu nhiên
• Fiddle với số để phù hợp với nó trong phạm vi; nếu nó xấu, hãy quay lại và tạo lại
• In ký tự ngẫu nhiên
• In một dòng mới (mỗi lần lặp khác)
• In số lượng không gian thích hợp

Chuyển đổi từ một số ngẫu nhiên thành một ký tự ngẫu nhiên không đáng chú ý:

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

Phần thú vị là tính toán số lượng không gian. Nó phải tạo ra các số sau (ví dụ cho N = 9):

7    1
5    2
3    3
1    4

     3
1    2
3    1
5    0
7

Các số được lấy xen kẽ từ hai tiến trình số học. Bước đầu tiên đi xuống với bước -2 và bước thứ hai đi lên với bước 1. Khi tiến trình đầu tiên đến -1 (ở giữa X), có một trục trặc (-1 bị loại bỏ), và sau đó sự tiến triển thay đổi hướng.

Các tiến trình được lưu trữ trong các thanh ghi ebxvà edx- các phần cao bhvà dhlưu trữ số hiện tại, và các phần thấp blvà dllưu trữ các bước. Để xen kẽ giữa các tiến trình, mã hoán đổi các thanh ghi với xchg.

Khi tiến trình đến -1 (xung quanh mylabnhãn), nó sẽ tăng cả hai thanh ghi, chuyển các bước từ -2, 1sang -1, 2. Điều này cũng thay đổi vai trò của các thanh ghi, do đó nó hoán đổi các phần cao của các thanh ghi.

Ở cuối hàm, nó lưu một byte bằng 0 để chỉ ra phần cuối của chuỗi.

Lua, 277 byte

Chà ... Lua rất giỏi trong việc điều khiển các chuỗi: D. Lần đầu tiên tôi phải sử dụng localtrong một tuyên bố! Tôi có thể lưu một số byte bằng cách sử dụng Lua 5.1 thay vì 5.3 vì chúng đã di chuyển hàm toàn cục unpackvào đối tượng tabletại Lua 5.2. Nhưng tôi thích gắn bó với phiên bản mới nhất mà tôi có :).

Xác định một hàm nên được gọi với một tham số duy nhất (hàm thứ hai được sử dụng cho mục đích đệ quy) và trả về một chuỗi.

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

Ung dung

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

JavaScript (ES6), 137 131 125 byte

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`

Trường hợp \nđại diện cho nhân vật dòng chữ mới. Chỉnh sửa: Đã lưu 1 byte bằng cách di chuyển ' 'bên trong String.fromCharCodebiểu thức. Đã lưu 5 byte bằng cách làm cho thế hệ ký tự ngẫu nhiên của tôi không đồng nhất; biểu thức r+72&95bằng 0 đối với các giá trị ánh xạ tới Yvà yvà !được tạo ở vị trí của chúng. Đã lưu 4 byte khi tôi nhận ra rằng trải đều String.fromCharCodeđể tránh phải join. Đã lưu 2 byte bằng cách đánh cắp một mẹo từ @ edc65.

PowerShell v2 +, 112 byte

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

Đọc đầu vào tắt dòng lệnh.

Đối với mỗi dòng, một mảng khoảng trắng được tạo, các chỉ mục chính xác được điền vào các ký tự được kéo từ hàm f, sau đó mảng char được nối để xuất thành một dòng.

MATLAB, 86 byte

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

Vài ví dụ:

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

Pip , 33 byte

32 byte mã, +1 cho -lcờ. Thật kỳ lạ, mã bắt đầu bằng Yvà kết thúc bằng y...

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

Đưa đầu vào làm đối số dòng lệnh. Hãy thử trực tuyến!

Giải trình

Xây dựng một lưới có kích thước phù hợp; thay thế các phần tử trên các đường chéo bằng một ký tự không phải là y ngẫu nhiên và tất cả các phần tử khác bằng khoảng trắng.

                                  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 byte

<?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
");}

Cách tiếp cận khá đơn giản sử dụng str_pad để tạo một chuỗi các khoảng trống có độ dài cần thiết, thay thế các ký tự cần thiết bằng các ký tự ngẫu nhiên sau đó thay thế bất kỳ Ys nào (không phân biệt chữ hoa chữ thường) bằng Xs và lặp lại dòng.
Tạo 2n + 3 thông báo nhưng, như thường lệ, điều đó tốt.

Emacs Lisp, 269 byte

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

Ungolfed và sửa đổi một chút:

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

JavaScript (ES6), 128 131

Chỉnh sửa 3 byte đã lưu thx @Neil

Vì vậy, cồng kềnh, có lẽ không phải là cách tiếp cận tốt nhất. Tiền thưởng - nó hoạt động với đầu vào lẻ ​​hoặc thậm chí.

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 byte

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

Gọi f()với kích thước của xđể vẽ.

Matricks , 79 byte (không cạnh tranh)

Matricks vượt trội khi bắt đầu tạo x và tất cả các giá trị ngẫu nhiên, nhưng sẽ thất bại khi nói đến điều kiện ...

Tôi đã đánh dấu điều này là không soạn thảo vì tôi phải sửa một vài lỗi và làm cho tất cả các tính năng mới hoạt động sau khi thử thách này được đăng.

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

Chạy với python matricks.py x.txt [[]] <input> --asciiprint

Giải trình:

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

Điều này cũng hỗ trợ số chẵn.

Python 2, 204 191 183 byte

Được rồi, cạnh tranh Python ở đây đang trở nên khốc liệt. Đây là nỗ lực của tôi để cạo càng nhiều byte càng tốt. Đến bây giờ tôi bị kẹt (Ok, lại bị kẹt).

Tín dụng cho @NonlinearFnut cho cách chọn các ký tự ngẫu nhiên.

Phiên bản 183 byte:

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)

Dùng thử trực tuyến! (Ý)

Thay đổi chính là viết lại điều kiện

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

như

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

giúp tiết kiệm 7 byte.

Phiên bản 191 byte:

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)

Dùng thử trực tuyến! (Ý)

Những thay đổi chính là cách các ký tự ngẫu nhiên được chọn và một số sắp xếp lại mã như s=input();i=s;trở thành s=i=input();, loại bỏ r=rangephép gán vì nó không còn cần thiết và gọi abstrực tiếp vì nó dẫn đến ít byte mã hơn.

Đánh bại câu trả lời ngắn nhất trước đó trong Python 1 byte! @R. Cách tiếp cận của Kap được sử dụng để tạo các ký tự ngẫu nhiên. Mỗi lần lặp của vòng lặp while, một hàng của ex được in.

Phiên bản 204 byte :

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)

Dùng thử trực tuyến! (Ý)

Phiên bản Ungolfed để có ý tưởng về cách thức hoạt động của nó:

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

Thật khó để xử lý trường hợp 1 ký tự!

SmileBASIC, 97 byte

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

Thay vì phải tính toán số lượng khoảng cách giữa mỗi ký tự hoặc thứ gì đó, tôi quyết định chỉ in ở tất cả các vị trí X==Yhoặc X+Y==Size+1.
Trình tạo ký tự ngẫu nhiên chỉ thêm 1 nếu nó tạo yhoặc Y, vì vậy zvà Zphổ biến hơn một chút so với thông thường.

PHP, 100 byte

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

lấy đầu vào từ đối số dòng lệnh; chạy với -nr.

vòng lặp kết hợp in các ký tự tùy theo vị trí

phá vỡ

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