Geralmente, diz-se que "Fazer X sem Y" pode ser uma armadilha para iniciantes que escrevem desafios ( fonte ). No entanto, sou arrogante e acho que posso definitivamente fazer um X sem Ys. Aleatoriamente. Oh sim, isso será bom.

Desafio: Dado um número inteiro ímpar nmaior ou igual a 1, produza um ex de comprimento lateral nfeito de caracteres ascii imprimíveis aleatórios sans "y" e "Y" e o espaço. Todos os caracteres permitidos devem ter uma chance diferente de zero, mas não necessariamente uniforme. Este é um código de golfe, portanto o código mais curto em bytes vence. Você deve, no entanto, escolher aleatoriamente cada caractere - ou seja, os braços do ex não devem ser iguais, a menos que por acaso.

Os caracteres a aparecer

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

Construindo o ex

Comprimento lateral 1:

x

Comprimento lateral 3:

x x
 x
x x

Comprimento lateral 5:

x   x
 x x
  x
 x x
x   x

etc.

Saídas de exemplo

input
output
empty line

3
h 2
 ^
9 5

1
:

5
D   1
 W z
  W
 q j
W   1

Implementação de exemplo

Você não precisa manipular entradas inválidas.

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>

Pitão, 28 27 26 25 bytes

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

Suíte de teste.

Ruby, 102 bytes

Array#samplenão faz repetições para amostragem do conjunto de caracteres, mas tudo bem, porque a distribuição de caracteres não precisa ser perfeitamente uniforme! Função recursiva, retorna uma matriz de linhas.

Experimente online!

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

Na verdade, 62 bytes

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

Este é um dos programas mais longos que já escrevi.

Experimente online!

Explicação:

Parte 1 : configurando a lista de caracteres

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

Experimente online!

Parte 2 : construindo a matriz booleana para um 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)

Experimente online!

Parte 3 : escolhendo caracteres aleatórios

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

Experimente online!

Mathematica, 146 bytes

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

Função anônima. Pega um número como entrada e retorna uma string como saída.

Python 2, 171 bytes

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

Garantido para escolher caracteres aleatórios com probabilidade uniforme.

Experimente aqui: link ideone

EDIT: Agradecimentos a Morgan Thrapp pelas correções.

Python, 142 139 135 bytes

Esta é uma implementação direta e cria o caractere quadrado por caractere. Se o caractere estiver na diagonal : use um caractere aleatório; else : use um espaço. Isso também usa uma substituição de regex e int aleatório para gerar não Ycaracteres:

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

Explicação [Antiga]

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

Atualizar

• -4 [16-07-30] Nova linha condicional reduzida
• -3 [16-07-30] Alterado para loop for único
• -6 [16-07-29] Trocado se declaração para op. Ternário. Obrigado a @RootTwo
• -11 [16-07-27] Removidos colchetes / espaços extras e invertidos if statement
• -49 [16-07-27] O método de @ squeamishossifrage foi alterado, criando o quadrado passo a passo, Obrigado!
• -10 [16-07-27] Encurte aleatoriamente char lambda + material matemático de @ ConorO'Brien
• -22 [16-07-26] Squeaze em um lambda + golfe variado
• -6 [16-07-26] import*- Graças a @KevinLau

Dyalog APL , 35 bytes

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

⎕solicitar o número
⍳1 através dessa
∘.=⍨tabela de igualdade de números (ou seja, a diagonal possui 1s)
(⊢∨⌽)OU sua imagem espelhada (fornece as duas diagonais)
95×multiplicar por 95
?rand int entre 1 e 95 para as diagonais, rand flutuar entre 0 e 1 para o restante
⌊andar se livrar dos carros alegóricos,
(⊢+∊∘57 89)adicione um aos elementos que são membros de {57,89} (AA - 32)
32+adicione 32 para transformar os 0s em espaços e outros números no intervalo apropriado
⎕UCSconvertam em texto

TryAPL !

Python 2.7, 205 bytes:

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)

Experimente Online! (Ideona)

MATL , 28 bytes

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

Experimente online!

Todos os caracteres permitidos têm a mesma probabilidade de aparecer. Também funciona para entrada uniforme.

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 bytes (ou 119 sem a placa da caldeira)

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

Ou 119 bytes como uma função X(h)com srand(time(0))cuidado em outro lugar:

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

Demolir:

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
}

código de máquina x86, 70 bytes

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

Meu código executável, desmontado:

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                     

É uma função que recebe o tamanho do X em ecx e um ponteiro para o buffer de saída em edx.

Ele preenche o buffer de saída sequencialmente com bytes. Existem 2 * n - 1iterações (iguais ao número de caracteres não espaciais para saída). Em cada iteração, ele faz o seguinte:

• Gere um número aleatório
• Brinque com o número para ajustá-lo ao alcance; se estiver ruim, volte e gere novamente
• Imprimir o caractere aleatório
• Imprimir uma nova linha (todas as outras iterações)
• Imprimir o número adequado de espaços

A conversão de um número aleatório para um caractere aleatório não é notável:

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

A parte interessante é o cálculo do número de espaços. Ele deve gerar os seguintes números (exemplo para N = 9):

7    1
5    2
3    3
1    4

     3
1    2
3    1
5    0
7

Os números são obtidos alternadamente de duas progressões aritméticas. O primeiro desce com o passo -2 e o segundo com o passo 1. Quando a primeira progressão chega a -1 (no meio do X), há uma falha (-1 é removida) e depois as progressões mudam de direção.

As progressões são armazenadas em registradores ebxe edx- as partes altas bhe dharmazenam o número atual, e as partes baixas ble dlarmazenam a etapa. Para alternar entre as progressões, o código troca os registros com xchg.

Quando a progressão chega a -1 (ao redor do mylabrótulo), aumenta os dois registros, alternando as etapas de -2, 1para -1, 2. Isso também muda as funções dos registros, e então troca as partes altas dos registros.

No final da função, ele armazena um byte zero para indicar o final da string.

Lua, 277 bytes

Bem ... Lua é muuuito bom em manipular strings: D. Primeira vez eu tive que usar localem uma declaração! Eu poderia salvar alguns bytes usando Lua 5.1 em vez de 5.3, porque eles moveram a função global unpackpara o objeto tableem Lua 5.2. Mas eu prefiro ficar com a versão mais recente que tenho :).

Define uma função que deve ser chamada com um único parâmetro (o segundo é usado para fins de recursão) e retorna uma string.

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

Ungolfed

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 bytes

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`

Onde \nrepresenta o caractere literal de nova linha. Editar: salvou 1 byte movendo o ' 'interior da String.fromCharCodeexpressão. Economizei 5 bytes, tornando minha geração aleatória de caracteres não uniforme; a expressão r+72&95é zero para os valores que são mapeados para Ye ye um !é gerado em seu lugar. Salvei 4 bytes quando percebi que a propagação String.fromCharCodeevita a necessidade join. Economizou 2 bytes roubando um truque de @ edc65.

PowerShell v2 +, 112 bytes

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

Lê a entrada na linha de comando.

Para cada linha, é criada uma matriz de espaços, os índices corretos são preenchidos com caracteres extraídos da função e f, em seguida, a matriz de caracteres é unida à saída como uma linha.

MATLAB, 86 bytes

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

Alguns exemplos:

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

32 bytes de código, +1 para -lsinalizador. Curiosamente, o código começa com Ye termina com y...

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

Recebe entrada como um argumento de linha de comando. Experimente online!

Explicação

Constrói uma grade do tamanho apropriado; substitui elementos nas diagonais por um caractere não y aleatório e todos os outros elementos por espaço.

                                  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 bytes

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

A abordagem bastante direta usa str_pad para criar uma série de espaços com o comprimento necessário, substitui os caracteres necessários por caracteres aleatórios, substitui qualquer Y (sem distinção entre maiúsculas e minúsculas) por X e ecoa a linha.
Gera avisos 2n + 3, mas, como sempre, tudo bem.

Emacs Lisp, 269 bytes

(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 e ligeiramente modificado:

(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

Editar 3 bytes salvos thx @Neil

Tão volumoso, provavelmente não é a melhor abordagem. Bônus - funciona com entrada ímpar ou par.

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 bytes

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

Ligue f()com o tamanho do xempate.

Matrizes , 79 bytes (não concorrentes)

Matricks se destaca como o início de fazer x e todos os valores aleatórios, mas falha quando se trata de condicionais ...

Marquei isso como não-concorrente porque tive que corrigir alguns bugs e colocar todos os novos recursos em funcionamento após o lançamento deste desafio.

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

Correr com python matricks.py x.txt [[]] <input> --asciiprint

Explicação:

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

Isso também suporta números pares.

Python 2, 204 191 183 bytes

Ok, a competição Python aqui está ficando acirrada. Aqui está minha tentativa de raspar o máximo de bytes possível. Até agora eu estou preso (Ok, preso novamente).

Créditos para @NonlinearFruit pela maneira como os caracteres aleatórios são selecionados.

Versão de 183 bytes:

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)

Experimente Online! (Ideona)

A principal mudança é reescrever a condição

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

Como

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

que economiza 7 bytes.

Versão de 191 bytes:

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)

Experimente Online! (Ideona)

As principais alterações são a maneira como os caracteres aleatórios são selecionados e alguns rearranjos de código, como s=input();i=s;tornar-se s=i=input();, remover a r=rangeatribuição, pois não é mais necessária e chamar absdiretamente, pois resulta em menos bytes de código.

Superando a resposta mais curta anterior em Python por 1 byte! @R. A abordagem de Kap é usada para gerar os caracteres aleatórios. Cada iteração do loop while é impressa uma linha do ex.

Versão de 204 bytes :

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)

Experimente Online! (Ideona)

Versão ungolfed para ter uma idéia de como funciona:

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

Era difícil lidar com o gabinete de 1 caractere!

SmileBASIC, 97 bytes

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

Em vez de ter que calcular o número de espaços entre cada caractere ou algo assim, decidi imprimir em todos os locais onde X==You X+Y==Size+1.
O gerador de caracteres aleatórios apenas adiciona 1 se gera you Y, portanto, ze Zé um pouco mais comum que o normal.

PHP, 100 bytes

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

recebe entrada do argumento da linha de comando; corra com -nr.

loop combinado imprime caracteres dependendo da posição

demolir

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