Di solito, si dice che "Fare X senza Y" può essere una trappola per i principianti che scrivono sfide ( fonte ). Tuttavia, sono arrogante e penso di poter sicuramente fare una X senza Y. A caso. Oh sì, questo andrà bene.

Sfida: dato un numero dispari nmaggiore o uguale a 1, genera un ex di lunghezza laterale ncostituito da caratteri ASCII stampabili casuali senza "y" e "Y", e lo spazio. Tutti i personaggi ammessi devono avere una possibilità diversa da zero, ma non necessariamente uniforme. Questo è un code-golf quindi vince il codice più breve in byte. Dovresti, comunque, randomizzare ogni carattere - cioè, i montanti di ex non dovrebbero essere uguali, se non per caso.

I caratteri per apparire

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

Costruire l'es

Lunghezza laterale 1:

x

Lunghezza laterale 3:

x x
 x
x x

Lunghezza laterale 5:

x   x
 x x
  x
 x x
x   x

eccetera.

Esempi di output

input
output
empty line

3
h 2
 ^
9 5

1
:

5
D   1
 W z
  W
 q j
W   1

Esempio di implementazione

Non è necessario gestire input non validi.

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-tQN * d
VQuXGHO-r \! \ ~ "YY", N-TQN * d

Suite di test.

Rubino, 102 byte

Array#samplenon fa ripetizioni per il campionamento dal set di caratteri, ma va bene perché la distribuzione del personaggio non deve essere perfettamente uniforme! Funzione ricorsiva, restituisce una matrice di linee.

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

In realtà, 62 byte

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

Questo è uno dei programmi più lunghi che abbia mai scritto.

Provalo online!

Spiegazione:

Parte 1 : impostazione dell'elenco dei personaggi

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

Provalo online!

Parte 2 : costruzione dell'array booleano per 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)

Provalo online!

Parte 3 : scegliere personaggi casuali

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

Provalo online!

Mathematica, 146 byte

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

Funzione anonima. Accetta un numero come input e restituisce una stringa come output.

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

Garantito per scegliere personaggi casuali con probabilità uniforme.

Provalo qui: collegamento ideone

EDIT: Grazie a Morgan Thrapp per le correzioni.

Python, 142 139 135 byte

Questa è un'implementazione semplice creare il carattere quadrato per carattere. Se il personaggio ha una diagonale : usa un carattere casuale, altrimenti : usa uno spazio. Questo utilizza anche una sostituzione regex e int casuale per generare non Ycaratteri:

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

Spiegazione [Vecchio]

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

Aggiornare

• -4 [16-07-30] Condizionale newline abbreviato
• -3 [16-07-30] Modificato in single for-loop
• -6 [16-07-29] Scambiato se istruzione per ternario op. Grazie a @RootTwo
• -11 [16-07-27] Rimosse parentesi / spazi extra e capovolto istruzione if
• -49 [16-07-27] Metodo Absorded @ squeamishossifrage creando il quadrato passo dopo passo, grazie!
• -10 [16-07-27] Accorcia i caratteri casuali lambda + matematica da @ ConorO'Brien
• -22 [16-07-26] Squeaze in un lambda + misc golfing
• -6 [16-07-26] import*- Grazie a @KevinLau

Dyalog APL , 35 byte

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

⎕richiedere il numero
⍳1 attraverso quella
∘.=⍨tabella di uguaglianza numerica (ovvero la diagonale ha 1 s)
(⊢∨⌽)stessa O la sua immagine speculare (fornisce entrambe le diagonali)
95×moltiplicare per 95
?rand int tra 1 e 95 per le diagonali, il rand fluttua tra 0 e 1 per il
⌊piano di riposo a sbarazzarsi dei float
(⊢+∊∘57 89)aggiungerne uno agli elementi che sono membri di {57,89} (Yy - 32)
32+aggiungere 32 per rendere gli 0 in spazi e altri numeri nell'intervallo corretto
⎕UCSconvertiti in testo

TryAPL !

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)

Provalo online! (Ideone)

MATL , 28 byte

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

Provalo online!

Tutti i personaggi ammessi hanno la stessa probabilità di apparire. Funziona anche per un input 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 byte (o 119 senza la piastra della caldaia)

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 byte in funzione X(h)con srand(time(0))cura altrove:

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

Abbattersi:

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
}

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

Il mio codice eseguibile, smontato:

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                     

È una funzione che riceve la dimensione della X in ecx e un puntatore al buffer di output in edx.

Riempie il buffer di output in sequenza con byte. Esistono 2 * n - 1iterazioni (pari al numero di caratteri non spaziali da emettere). Ad ogni iterazione, procede come segue:

• Genera un numero casuale
• Armeggia con il numero per adattarlo al range; se è male, torna indietro e genera di nuovo
• Stampa il personaggio casuale
• Stampa una nuova riga (ogni altra iterazione)
• Stampa il numero corretto di spazi

La conversione da un numero casuale a un personaggio casuale non è notevole:

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 interessante è il calcolo del numero di spazi. Deve generare i seguenti numeri (esempio per N = 9):

7    1
5    2
3    3
1    4

     3
1    2
3    1
5    0
7

I numeri sono presi alternativamente da due progressioni aritmetiche. Il primo scende con il passaggio -2 e il secondo sale con il passaggio 1. Quando la prima progressione arriva a -1 (al centro della X), c'è un problema tecnico (-1 viene rimosso), quindi le progressioni cambiano direzione.

Le progressioni sono memorizzate nei registri ebxe edx- le parti alte bhe dhmemorizzano il numero corrente e le parti basse ble dlmemorizzano il passo. Per alternare tra le progressioni, il codice scambia i registri con xchg.

Quando la progressione arriva a -1 (attorno mylaball'etichetta), aumenta entrambi i registri, passando da -2, 1a -1, 2. Questo cambia anche i ruoli dei registri, quindi scambia le parti alte dei registri.

Alla fine della funzione, memorizza un byte zero per indicare una fine della stringa.

Lua, 277 byte

Bene ... Lua è davvero brava a manipolare le stringhe: D. Prima volta che ho dovuto usare localin una dichiarazione! Potrei salvare alcuni byte usando Lua 5.1 anziché 5.3 perché hanno spostato la funzione globale unpacknell'oggetto tablein Lua 5.2. Ma preferisco attenermi all'ultima versione che ho :).

Definisce una funzione che deve essere chiamata con un singolo parametro (il secondo viene utilizzato a scopo di ricorsione) e restituisce una stringa.

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

Dove \nrappresenta il carattere letterale di newline. Modifica: salvato 1 byte spostando l' ' 'interno String.fromCharCodedell'espressione. Ho salvato 5 byte rendendo la mia generazione casuale di caratteri non uniforme; l'espressione r+72&95è zero per i valori che mappano Ye ye !viene generato al loro posto. Ho salvato 4 byte quando mi sono reso conto che la diffusione su String.fromCharCodeevita di doverlo fare join. Hai salvato 2 byte rubando un trucco da @ 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''}

Legge l'input dalla riga di comando.

Per ogni riga, viene creato un array di spazi, gli indici corretti vengono riempiti con caratteri estratti dalla funzione f, quindi l'array char viene unito all'output come una riga.

MATLAB, 86 byte

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

Qualche esempio:

>> 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 di codice, +1 per -lflag. Stranamente, il codice inizia con Ye termina con y...

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

Accetta input come argomento della riga di comando. Provalo online!

Spiegazione

Costruisce una griglia delle dimensioni appropriate; sostituisce gli elementi sulle diagonali con un carattere non y casuale e tutti gli altri elementi con spazio.

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

L'approccio abbastanza semplice utilizza str_pad per creare una stringa di spazi della lunghezza richiesta, sostituisce i caratteri necessari con quelli casuali, quindi sostituisce qualsiasi Y (senza distinzione tra maiuscole e minuscole) con X e riecheggia la linea.
Genera 2n + 3 avvisi ma, come al solito, va bene.

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

Non golfato e leggermente modificato:

(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

Modifica 3 byte salvati grazie a @Neil

Così ingombrante, probabilmente non è l'approccio migliore. Bonus: funziona con input pari o dispari.

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

Chiama f()con le dimensioni del xdisegno.

Matrick , 79 byte (non concorrenti)

Matricks eccelle come l'inizio della creazione della xe di tutti i valori casuali, ma al flop quando si tratta di condizionali ...

Ho contrassegnato questo come non competitivo perché ho dovuto correggere alcuni bug e far funzionare tutte le nuove funzionalità dopo che questa sfida era stata pubblicata.

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

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

Spiegazione:

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

Questo supporta anche numeri pari.

Python 2, 204 191 183 byte

Ok, la competizione con Python sta diventando feroce. Ecco il mio tentativo di radere quanti più byte possibile. Ormai sono bloccato (Ok, bloccato di nuovo).

Riconoscimenti a @NonlinearFruit per la modalità di selezione dei personaggi casuali.

183 byte versione:

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)

Provalo online! (Ideone)

La principale modifica è quella di riscrivere il condizionale

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

come

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

che consente di risparmiare 7 byte.

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

Provalo online! (Ideone)

Le principali modifiche sono il modo in cui vengono selezionati i caratteri casuali e alcuni riarrangiamenti del codice come s=input();i=s;diventare s=i=input();, rimuovere l' r=rangeassegnazione in quanto non è più necessaria e chiamare absdirettamente in quanto comporta meno byte di codice.

Battere la risposta più breve precedente in Python di 1 byte! @R. L'approccio di Kap viene utilizzato per generare i caratteri casuali. Ogni iterazione del ciclo while viene stampata una riga dell'ex.

204 byte versione :

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)

Provalo online! (Ideone)

Versione non golfata per avere un'idea di come funziona:

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

È stato difficile gestire il caso a 1 carattere!

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

Invece di dover calcolare il numero di spazi tra ciascun personaggio o qualcosa del genere, ho deciso di stampare in tutte le posizioni in cui X==Yo X+Y==Size+1.
Il generatore di caratteri casuali aggiunge solo 1 se genera yo Y, quindi, ze Zsono leggermente più comuni del solito.

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

accetta input dall'argomento della riga di comando; corri con -nr.

il circuito combinato stampa i caratteri in base alla posizione

abbattersi

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