Habituellement, il est dit que "Faire X sans Y" peut être un piège pour les débutants qui écrivent des défis ( source ). Cependant, je suis arrogant et pense que je peux certainement faire un X sans Ys. Au hasard. Oh oui, ce sera bien.

Défi: Étant donné un entier impair nsupérieur ou égal à 1, affiche un ex de côté ncomposé de caractères ascii imprimables au hasard, sans "y" et "Y", ainsi que de l’espace. Tous les personnages autorisés doivent avoir une chance non nulle de se produire, mais pas nécessairement uniforme. Ceci est un code-golf donc le code le plus court en octets gagne. Vous devez cependant randomiser chaque caractère - c'est-à-dire que les jambes de force de l'ex ne doivent pas être égales, sauf si c'est par hasard.

Les caractères à paraître

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

Construire l'ex

Longueur du côté 1:

x

Longueur du côté 3:

x x
 x
x x

Longueur du côté 5:

x   x
 x x
  x
 x x
x   x

etc.

Exemple de sorties

input
output
empty line

3
h 2
 ^
9 5

1
:

5
D   1
 W z
  W
 q j
W   1

Exemple d'implémentation

Vous n'avez pas besoin de gérer des entrées non valides.

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 octets

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

Suite de tests.

Ruby, 102 octets

Array#samplene répétez pas l'échantillonnage à partir du jeu de caractères, mais c'est correct car la répartition des caractères ne doit pas nécessairement être parfaitement uniforme! Fonction récursive, retourne un tableau de lignes.

Essayez-le en ligne!

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 fait, 62 octets

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

C'est l'un des programmes les plus longs que j'ai jamais écrit.

Essayez-le en ligne!

Explication:

Partie 1 : configurer la liste des personnages

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

Essayez-le en ligne!

Partie 2 : construction du tableau booléen pour un 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)

Essayez-le en ligne!

Partie 3 : choisir des caractères aléatoires

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

Essayez-le en ligne!

Mathematica, 146 octets

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

Fonction anonyme. Prend un nombre en entrée et retourne une chaîne en sortie.

Python 2, 171 octets

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

Garanti de choisir des caractères aléatoires avec une probabilité uniforme.

Essayez-le ici: lien ideone

EDIT: Merci à Morgan Thrapp pour les corrections.

Python, 142 139 135 octets

Ceci est une implémentation simple qui crée le carré caractère par caractère. Si le caractère est en diagonale : utilisez un caractère aléatoire, sinon : utilisez un espace. Ceci utilise également une substitution regex et random int pour générer des non Ycaractères:

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

Explication [ancien]

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

Mise à jour

• -4 [16-07-30] Nouvelle ligne conditionnelle abrégée
• -3 [16-07-30] remplacé par single for-loop
• -6 [16-07-29] Échangé si déclaration pour op. Ternaire. Merci à @RootTwo
• -11 [16-07-27] Suppression de crochets / espaces supplémentaires et inversion de l'instruction if
• -49 [16-07-27] Absorded @ la méthode de squeamishossifrage en créant le carré, étape par étape, merci!
• -10 [16-07-27] Raccourcissez le contenu aléatoire des caractères lambda + mathématiques de @ ConorO'Brien
• -22 [16-07-26] Squeaze dans un golf lambda + misc
• -6 [16-07-26] import*- Merci à @KevinLau

Dyalog APL , 35 octets

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

⎕invite pour le numéro
⍳1 à ce nombre
∘.=⍨table d'égalité ( à savoir la diagonale a 1s)
(⊢∨⌽)lui - même ou son image dans un miroir (donne deux diagonales)
95×multiplier par 95
?rand int entre 1 et 95 pour les diagonales, rand flotteur entre 0 et 1 pour le reste
⌊étage à supprime les flottants,
(⊢+∊∘57 89)ajoute un aux éléments membres de {57,89} (Yy - 32),
32+ajoute 32 pour que les 0 soient des espaces, et les autres nombres, dans la plage appropriée,
⎕UCSconvertis en texte

TryAPL !

Python 2.7, 205 octets:

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)

Essayez-le en ligne! (Idéone)

MATL , 28 octets

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

Essayez-le en ligne!

Tous les personnages autorisés ont la même probabilité d'apparaître. Fonctionne même pour l'entrée.

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 octets (ou 119 sans la plaque de la chaudière)

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 octets en fonction X(h)de srand(time(0))pris en charge ailleurs:

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

Panne:

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
}

code machine x86, 70 octets

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

Mon code exécutable, désassemblé:

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                     

C'est une fonction qui reçoit la taille du X dans ecx et un pointeur sur le tampon de sortie dans edx.

Il remplit la mémoire tampon de sortie séquentiellement d'octets. Il y a des 2 * n - 1itérations (égales au nombre de caractères sans espace à afficher). À chaque itération, il effectue les opérations suivantes:

• Générer un nombre aléatoire
• Violon avec le numéro pour l'adapter à la gamme; si c'est mauvais, retourne et génère de nouveau
• Imprimer le caractère aléatoire
• Imprimer une nouvelle ligne (chaque itération)
• Imprimer le nombre approprié d'espaces

La conversion d'un nombre aléatoire en un caractère aléatoire n'est pas remarquable:

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

La partie intéressante est le calcul du nombre d'espaces. Il doit générer les nombres suivants (exemple pour N = 9):

7    1
5    2
3    3
1    4

     3
1    2
3    1
5    0
7

Les nombres sont pris alternativement de deux progressions arithmétiques. Le premier descend à l’étape -2 et le second à l’étape 1. Lorsque la première progression arrive à -1 (au milieu du X), il y a un problème (-1 est supprimé), puis les progressions changent de direction.

Les progressions sont stockées dans des registres ebxet edx- les parties hautes bhet dhstockent le numéro actuel, et les parties basses blet dlstockent le pas. Pour alterner les progressions, le code échange les registres avec xchg.

Lorsque la progression arrive à -1 (autour de l' mylabétiquette), les deux registres sont augmentés, les étapes passant de -2, 1à -1, 2. Cela modifie également les rôles des registres, de sorte qu'il permute les parties hautes des registres.

À la fin de la fonction, il stocke un octet nul pour indiquer une fin de chaîne.

Lua, 277 octets

Eh bien ... Lua est tellement bon à manipuler des chaînes: D. La première fois que je devais utiliser localdans une déclaration! Je pourrais économiser des octets en utilisant Lua 5.1 au lieu de 5.3 car ils ont déplacé la fonction globale unpackdans l’objet tablede Lua 5.2. Mais je préfère rester avec la dernière version que j'ai :).

Définit une fonction qui doit être appelée avec un seul paramètre (le second est utilisé à des fins de récurrence) et renvoie une chaîne.

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 octets

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`

Où \nreprésente le caractère de nouvelle ligne littéral. Édition: 1 octet enregistré en déplaçant ' 'l’ String.fromCharCodeexpression. J'ai sauvegardé 5 octets en rendant ma génération de caractères aléatoires non uniforme; l'expression r+72&95est égale à zéro pour les valeurs mappées sur Yet yet un !est généré à leur place. Sauvegardé 4 octets quand j'ai réalisé que la propagation String.fromCharCodeévite d'avoir à le faire join. Sauvegardé 2 octets en volant un tour de @ edc65.

PowerShell v2 +, 112 octets

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

Lit les entrées sur la ligne de commande.

Pour chaque ligne, un tableau d'espaces est créé, les index corrects étant remplis de caractères extraits de la fonction f, puis le tableau de caractères est joint à la sortie en tant que ligne.

MATLAB, 86 octets

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

Quelques exemples:

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

32 octets de code, +1 pour le -ldrapeau. Curieusement, le code commence par Yet finit par y...

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

Prend l'entrée en tant qu'argument de ligne de commande. Essayez-le en ligne!

Explication

Construit une grille de la taille appropriée; remplace les éléments sur les diagonales par un caractère non-y aléatoire et tous les autres éléments par un espace.

                                  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 octets

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

Une approche assez simple utilise str_pad pour créer une chaîne d'espaces de la longueur requise, remplace les caractères nécessaires par des caractères aléatoires, puis remplace tout Ys (insensible à la casse) par X et echos la ligne.
Génère 2n + 3 avis mais, comme d'habitude, c'est bien.

Emacs Lisp, 269 octets

(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 et légèrement modifié:

(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

Éditez 3 octets enregistrés thx @Neil

Si volumineux, probablement pas la meilleure approche. Bonus - cela fonctionne avec des entrées impaires ou paires.

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 octets

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

Appelez f()avec la taille de xdessiner.

Matricks , 79 octets (non concurrents)

Matricks excelle comme le début de la fabrication du x et de toutes les valeurs aléatoires, mais il échoue en ce qui concerne les conditionnelles ...

J'ai marqué ceci comme non compétitif parce que je devais corriger quelques bugs et faire fonctionner toutes les nouvelles fonctionnalités après la publication de ce défi.

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

Courir avec python matricks.py x.txt [[]] <input> --asciiprint

Explication:

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

Cela prend également en charge les nombres pairs.

Python 2, 204 191 183 octets

D'accord, la concurrence de Python devient féroce ici. Voici ma tentative de supprimer autant d'octets que possible. A présent, je suis coincé (ok, encore coincé).

Crédits à @NonlinearFruit pour la façon dont les caractères aléatoires sont sélectionnés.

Version de 183 octets:

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)

Essayez-le en ligne! (Idéone)

Le principal changement consiste à réécrire le conditionnel

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

comme

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

ce qui sauve 7 octets.

Version de 191 octets:

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)

Essayez-le en ligne! (Idéone)

Les principales modifications concernent la manière dont les caractères aléatoires sont sélectionnés et certaines modifications de code, telles que le s=input();i=s;devenir s=i=input();, la suppression de l' r=rangeattribution, qui n'est plus nécessaire, et l'appel absdirect, car il en résulte moins d'octets de code.

Battre la réponse la plus courte précédente en Python de 1 octet! @R. L'approche de Kap est utilisée pour générer les caractères aléatoires. A chaque itération de la boucle while, une ligne de l'ex est imprimée.

Version de 204 octets :

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)

Essayez-le en ligne! (Idéone)

Version non-golfée pour avoir une idée de son fonctionnement:

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

Il était difficile de gérer le cas d'un caractère!

SmileBASIC, 97 octets

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

Au lieu d'avoir à calculer le nombre d'espaces entre chaque caractère ou quelque chose, j'ai décidé d'imprimer seulement dans tous les lieux où X==You X+Y==Size+1.
Le générateur de caractères aléatoires ajoute simplement 1 s'il génère you Y, ainsi zet Zsont légèrement plus communs que d'habitude.

PHP, 100 octets

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

prend en charge l'argument de la ligne de commande; courir avec -nr.

la boucle combinée imprime les caractères en fonction de la position

panne

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