通常，据说“不做Y就做X”可能是初学者写作挑战的陷阱（来源）。但是，我很自大，并且认为我绝对可以在没有Y的情况下做出X。随便 哦，是的，这会很好。

挑战：给定一个n大于或等于1 的奇数整数，输出n由无可打印的ascii字符（“ y”和“ Y”）组成的边长的ex ，以及空格。所有允许的字符都必须有非零的出现机会，但不一定是统一的。这是一个代码高尔夫球，因此以字节为单位的最短代码获胜。但是，您应该将每个字符随机化-也就是说，除非有偶然的机会，否则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 * d
VQuXGHO-r \！\〜“ Yy”，N-tQN * d

测试套件。

Ruby，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")

在线尝试！

第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},{#,#}," "],"
",""]&

匿名函数。以数字作为输入，并返回一个字符串作为输出。

Python 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链接

编辑：感谢摩根·塔普（Morgan Thrapp）的更正。

Python，第142个 139 135字节

这是一个直接的实现，逐个字符创建正方形。如果字符在对角线上：请使用随机字符，否则：请使用空格。这也使用正则表达式替换和random 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))

说明[旧]

"\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]更改为单循环
• -6 [16-07-29]将if语句替换为三元操作。感谢@RootTwo
• -11 [16-07-27]删除了多余的方括号/空格，并翻转了if语句
• -49 [16-07-27]逐步创建正方形，放弃了@squeamishossifrage的方法，谢谢！
• -10 [16-07-27]缩短@ ConorO'Brien中的随机char lambda +数学内容
• -22 [16-07-26]踩λ+杂项打高尔夫球
• -6 [16-07-26] import*-感谢@KevinLau

Dyalog APL，35 字节

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

⎕
⍳通过该数字
∘.=⍨相等表提示数字1 （即对角线
(⊢∨⌽)本身为1）或镜像（给出两个对角线）
95×乘以95
?rand int （对角线在1到95之间），rand浮点在0到1之间（对于其余
⌊楼层）摆脱浮点数
(⊢+∊∘57 89)，向{57,89}（Yy – 32）的成员中添加一个元素，再
32+添加32以使0变为空格，而其他数字进入适当的范围则
⎕UCS转换为文本

试试看！

Python 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。这也改变了寄存器的作用，因此它交换了寄存器的高位。

在函数的末尾，它存储一个零字节以指示字符串的结尾。

Lua，277字节

好吧，Lua非常擅长操纵字符串：D。第一次我必须local在声明中使用！我可以使用Lua 5.1而不是5.3保存一些字节，因为它们将全局函数unpack移到了tableLua 5.2 的对象中。但是我更喜欢坚持使用最新版本：)。

定义一个应使用单个参数调用的函数（第二个参数用于递归）并返回一个字符串。

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

的JavaScript（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并!在其位置生成an 。当我意识到扩展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生成所需长度的字符串，用随机字符替换必要的字符，然后用Xs替换任何Y（不区分大小写）并回显该行。
生成2n + 3条通知，但是像往常一样，可以。

Emacs Lisp，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)))))

的JavaScript（ES6），128 131

编辑保存的3个字节thx @Neil

如此庞大，可能不是最佳方法。奖金-它适用于奇数或偶数输入。

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绘制大小调用。

马特里克斯，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

这也支持偶数。

Python 2中，204个 191 183字节

好的，这里的Python竞争越来越激烈。这是我尝试剃除尽可能多的字节的尝试。现在，我被卡住了（好的，再次被卡住了）。

感谢@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个字节击败Python中先前最短的答案！@R。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)

在线尝试！（爱迪生）

非高尔夫版本以了解其工作原理：

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。
如果随机字符生成器生成y或Y，则仅将其加1 ，因此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);