Por lo general, se dice que "Hacer X sin Y" puede ser una trampa para los principiantes que escriben desafíos ( fuente ). Sin embargo, soy arrogante y creo que definitivamente puedo hacer una X sin ninguna Y. Al azar Oh sí, esto será bueno.

Desafío: dado un número entero impar nmayor o igual a 1, genera un ex de longitud lateral nhecha de caracteres ascii imprimibles al azar sin "y" e "Y", y el espacio. Todos los caracteres permitidos deben tener una probabilidad distinta de cero, pero no necesariamente uniformes. Este es un código de golf, por lo que gana el código más corto en bytes. Sin embargo, debes aleatorizar cada carácter, es decir, los puntales del ex no deberían ser iguales, a menos que sea por casualidad.

Los caracteres que aparecerán

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

Construyendo el ex

Longitud lateral 1:

x

Longitud lateral 3:

x x
 x
x x

Longitud lateral 5:

x   x
 x x
  x
 x x
x   x

etc.

Salidas de ejemplo

input
output
empty line

3
h 2
 ^
9 5

1
:

5
D   1
 W z
  W
 q j
W   1

Implementación de ejemplo

No necesita manejar 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>

Pyth, 28 27 26 25 bytes

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

Banco de pruebas.

Ruby, 102 bytes

Array#sampleno hace repeticiones para el muestreo del conjunto de caracteres, pero está bien porque la distribución de caracteres no tiene que ser perfectamente uniforme. Función recursiva, devuelve una matriz de líneas.

Pruébalo en línea!

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

En realidad, 62 bytes

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

Este es uno de los programas más largos que he escrito.

Pruébalo en línea!

Explicación:

Parte 1 : configurar la lista de personajes

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

Pruébalo en línea!

Parte 2 : construir la matriz booleana para una 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)

Pruébalo en línea!

Parte 3 : elegir personajes aleatorios

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

Pruébalo en línea!

Mathematica, 146 bytes

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

Función anónima. Toma un número como entrada y devuelve una cadena como salida.

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

Garantizado para elegir personajes aleatorios con probabilidad uniforme.

Pruébelo aquí: enlace ideone

EDITAR: Gracias a Morgan Thrapp por las correcciones.

Python, 142 139 135 bytes

Esta es una implementación sencilla de crear el carácter cuadrado por carácter. Si el personaje está en diagonal : usa un carácter aleatorio, de lo contrario : usa un espacio. Esto también utiliza una sustitución de expresiones regulares y un int aleatorio para generar no 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))

Explicación [Antiguo]

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

Actualizar

• -4 [16-07-30] Nueva línea acortada condicional
• -3 [16-07-30] Cambiado a solo for-loop
• -6 [16-07-29] Se intercambió la declaración if para ternary op. Gracias a @RootTwo
• -11 [16-07-27] Se eliminaron los corchetes / espacios adicionales y se volteó si la declaración
• -49 [16-07-27] Absorbió el método de @ squeamishossifrage al crear el cuadrado paso a paso, ¡Gracias!
• -10 [16-07-27] Acortar char lambda + material matemático aleatorio de @ ConorO'Brien
• -22 [16-07-26] Squeaze en un lambda + golf misceláneo
• -6 [16-07-26] import*- Gracias a @KevinLau

Dyalog APL , 35 bytes

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

⎕solicite el número
⍳1 a través de esa
∘.=⍨tabla de igualdad de números (es decir, la diagonal tiene 1s)
(⊢∨⌽)O su imagen especular (da ambas diagonales) se
95×multiplica por 95
?rand int entre 1 y 95 para las diagonales, y flota entre 0 y 1 para el
⌊piso de descanso deshacerse de los flotadores
(⊢+∊∘57 89)agregue uno a los elementos que son miembros de {57,89} (Yy - 32)
32+agregue 32 para convertir los 0 en espacios, y otros números en el rango adecuado se
⎕UCSconvierten en 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)

¡Pruébelo en línea! (Ideona)

MATL , 28 bytes

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

Pruébalo en línea!

Todos los personajes permitidos tienen la misma probabilidad de aparecer. Funciona incluso para entrada también.

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 (o 119 sin la placa de caldera)

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

O 119 bytes como una función X(h)con srand(time(0))cuidado en otro 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);}

Descompostura:

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

Mi código ejecutable, 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                     

Es una función que recibe el tamaño de la X en ecx, y un puntero al búfer de salida en edx.

Llena el búfer de salida secuencialmente con bytes. Hay 2 * n - 1iteraciones (igual al número de caracteres que no son espaciales para generar). En cada iteración, hace lo siguiente:

• Generar un número aleatorio
• Juega con el número para ajustarlo al rango; si es malo, regrese y genere nuevamente
• Imprime el caracter aleatorio
• Imprima una nueva línea (cada dos iteraciones)
• Imprima la cantidad adecuada de espacios

La conversión de un número aleatorio a un carácter aleatorio no es notable:

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

La parte interesante es el cálculo del número de espacios. Debe generar los siguientes números (ejemplo para N = 9):

7    1
5    2
3    3
1    4

     3
1    2
3    1
5    0
7

Los números se toman alternativamente de dos progresiones aritméticas. El primero baja con el paso -2, y el segundo sube con el paso 1. Cuando la primera progresión llega a -1 (en el medio de la X), hay una falla (se elimina -1), y luego Las progresiones cambian de dirección.

Las progresiones se almacenan en registros ebxy edx- las partes altas bhy dhalmacenan el número actual, y las partes bajas bly dlalmacenan el paso. Para alternar entre las progresiones, el código intercambia los registros con xchg.

Cuando la progresión llega a -1 (alrededor de la mylabetiqueta), aumenta ambos registros, cambiando los pasos de -2, 1a -1, 2. Esto también cambia las funciones de los registros, por lo que intercambia las partes altas de los registros.

Al final de la función, almacena un byte cero para indicar el final de la cadena.

Lua, 277 bytes

Bueno ... Lua es muuuy buena manipulando cuerdas: D. Primera vez que tuve que usar localen una declaración! Podría guardar algunos bytes usando Lua 5.1 en lugar de 5.3 porque movieron la función global unpackal objeto tableen Lua 5.2. Pero prefiero seguir con la última versión que tengo :).

Define una función que debería llamarse con un único parámetro (el segundo se usa para fines de recursividad) y devuelve una cadena.

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

Sin golf

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`

Donde \nrepresenta el carácter literal de nueva línea. Editar: guardado 1 byte moviendo el ' 'interior de la String.fromCharCodeexpresión. Ahorré 5 bytes haciendo que mi generación aleatoria de caracteres no sea uniforme; la expresión r+72&95es cero para los valores que se asignan a Yy yy !se genera un en su lugar. Guarde 4 bytes cuando me di cuenta de que la propagación String.fromCharCodeevita tener que hacerlo join. Ahorró 2 bytes al robar un truco 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''}

Lee la entrada de la línea de comando.

Para cada línea, se crea una matriz de espacios, los índices correctos se completan con caracteres extraídos de la función f, luego la matriz de caracteres se une a la salida como una línea.

MATLAB, 86 bytes

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

Algunos ejemplos:

>> 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 -lbandera. Por extraño que parezca, el código comienza Yy termina con y...

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

Toma entrada como un argumento de línea de comando. Pruébalo en línea!

Explicación

Construye una cuadrícula del tamaño apropiado; reemplaza elementos en las diagonales con un carácter aleatorio que no sea y, y todos los demás elementos con espacio.

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

El enfoque bastante sencillo usa str_pad para hacer una cadena de espacios de la longitud requerida, reemplaza los caracteres necesarios con caracteres aleatorios y luego reemplaza cualquier Ys (insensible a mayúsculas y minúsculas) con Xs y repite la línea.
Genera avisos 2n + 3 pero, como de costumbre, está bien.

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

Sin golf y ligeramente 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), 128131

Editar 3 bytes guardados gracias a @Neil

Muy voluminoso, probablemente no sea el mejor enfoque. Bonificación: funciona con entradas pares o impares.

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

Llame f()con el tamaño del xpara dibujar.

Matrices , 79 bytes (no competidoras)

Matricks sobresale como el comienzo de hacer la xy todos los valores aleatorios, pero fracasa cuando se trata de condicionales ...

Marqué esto como no competitivo porque tuve que corregir algunos errores y hacer que todas las nuevas funciones funcionen después de que se publicó este desafío.

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

Corre con python matricks.py x.txt [[]] <input> --asciiprint

Explicación:

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

Esto también admite números pares.

Python 2, 204 191 183 bytes

De acuerdo, la competencia de Python aquí se está volviendo feroz. Aquí está mi intento de reducir tantos bytes como sea posible. Por ahora estoy atascado (Ok, atascado de nuevo).

Créditos a @NonlinearFruit por la forma en que se seleccionan los caracteres aleatorios.

Versión 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)

¡Pruébelo en línea! (Ideona)

El cambio principal es reescribir el condicional

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

como

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

que ahorra 7 bytes.

Versión 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)

¡Pruébelo en línea! (Ideona)

Los cambios principales son la forma en que se seleccionan los caracteres aleatorios y algunos reordenamientos de código, como el s=input();i=s;devenir s=i=input();, eliminar la r=rangeasignación ya que ya no es necesaria y llamar absdirectamente, ya que da como resultado menos bytes de código.

¡Superando la respuesta más corta anterior en Python por 1 byte! @R. El enfoque de Kap se usa para generar los caracteres aleatorios. Cada iteración del ciclo while se imprime una fila del ex.

Versión 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)

¡Pruébelo en línea! (Ideona)

Versión sin golf para tener una idea de cómo 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

¡Fue difícil manejar el caso de 1 personaje!

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

En lugar de tener que calcular el número de espacios entre cada personaje o algo, decidí imprimir en todas las ubicaciones donde X==Yo X+Y==Size+1.
El generador de caracteres aleatorios solo agrega 1 si genera yo Y, por lo tanto, zy Zson un poco más comunes de lo habitual.

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

toma datos del argumento de la línea de comando; correr con -nr.

bucle combinado imprime caracteres dependiendo de la posición

Descompostura

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