Normalerweise wird gesagt, dass "X ohne Y machen" Anfängern, die Herausforderungen schreiben, eine Falle sein kann ( Quelle ). Ich bin jedoch übermütig und denke, dass ich definitiv ein X ohne Ys machen kann. Nach dem Zufallsprinzip. Oh ja, das wird gut.

Herausforderung: Geben Sie bei einer ungeraden Ganzzahl ngrößer oder gleich 1 ein Ex der Seitenlänge naus, die aus zufälligen druckbaren ASCII-Zeichen ohne "y" und "Y" und dem Leerzeichen besteht. Alle zulässigen Zeichen müssen eine Wahrscheinlichkeit ungleich Null aufweisen, jedoch nicht unbedingt einheitlich. Dies ist ein Code-Golf, so dass der kürzeste Code in Bytes gewinnt. Sie sollten jedoch jedes Zeichen nach dem Zufallsprinzip sortieren - das heißt, die Streben des Ex sollten nicht gleich sein, es sei denn, es ist ein Zufall.

Die anzuzeigenden Zeichen

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

Aufbau des Ex

Seitenlänge 1:

x

Seitenlänge 3:

x x
 x
x x

Seitenlänge 5:

x   x
 x x
  x
 x x
x   x

usw.

Beispielausgaben

input
output
empty line

3
h 2
 ^
9 5

1
:

5
D   1
 W z
  W
 q j
W   1

Beispielimplementierung

Sie müssen keine ungültigen Eingaben verarbeiten.

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

Testsuite.

Ruby, 102 Bytes

Array#sampleEs werden keine Wiederholungen für das Abtasten aus dem Zeichensatz durchgeführt, aber das ist in Ordnung, da die Zeichenverteilung nicht perfekt gleichmäßig sein muss! Rekursive Funktion, gibt ein Array von Zeilen zurück.

Probieren Sie es 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]}

Eigentlich 62 Bytes

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

Dies ist eines der längsten Actually-Programme, die ich je geschrieben habe.

Probieren Sie es online!

Erläuterung:

Teil 1 : Einrichten der Charakterliste

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

Probieren Sie es online!

Teil 2 : Konstruieren des Booleschen Arrays für ein 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)

Probieren Sie es online!

Teil 3 : Zufällige Zeichen auswählen

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

Probieren Sie es online!

Mathematica, 146 Bytes

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

Anonyme Funktion. Nimmt eine Zahl als Eingabe und gibt eine Zeichenfolge als Ausgabe zurück.

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

Garantiert zufällige Zeichen mit einheitlicher Wahrscheinlichkeit zu wählen.

Probieren Sie es hier aus: ideone link

EDIT: Danke an Morgan Thrapp für die Korrekturen.

Python, 142 139 135 Bytes

Dies ist eine einfache Implementierung, um das Quadrat Zeichen für Zeichen zu erstellen. Befindet sich das Zeichen in einer Diagonale : Verwenden Sie ein zufälliges Zeichen , ansonsten : Verwenden Sie ein Leerzeichen. Dies verwendet auch eine Regex-Ersetzung und ein zufälliges int, um Nicht- YZeichen zu generieren :

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

Erklärung [alt]

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

Aktualisieren

• -4 [16-07-30] Verkürzte Zeilenumbruchbedingung
• -3 [16-07-30] In einzelne for-Schleife geändert
• -6 [16-07-29] Ausgetauschte if-Anweisung für ternäre op. Vielen Dank an @RootTwo
• -11 [16-07-27] Zusätzliche Klammern / Leerzeichen entfernt und if-Anweisung gekippt
• -49 [16-07-27] Absorded @ squeamishossifrage's Methode durch schrittweises Erstellen des Quadrats, Danke!
• -10 [16-07-27] Verkürzen Sie zufällige Zeichen Lambda + Mathe-Sachen von @ ConorO'Brien
• -22 [16-07-26] Squeaze in einem Lambda + verschiedene Golf
• -6 [16-07-26] import*- Danke an @KevinLau

Dyalog APL , 35 Bytes

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

⎕Eingabeaufforderung für die Zahl
⍳1 durch diese
∘.=⍨Zahlengleichheitstabelle (dh die Diagonale hat 1s)
(⊢∨⌽)selbst ODER ihr Spiegelbild (gibt beide Diagonalen an)
95×multiplizieren Sie mit 95
?Rand Int zwischen 1 und 95 für die Diagonalen, Rand Float zwischen 0 und 1 für die Restetage
⌊zu loszuwerden der Schwimmer
(⊢+∊∘57 89)fügen Sie ein zu den Elementen , die ein Mitglied von {57,89} sind (yy - 32)
32+hinzufügen , 32 , um die 0er in Räume und andere Zahlen in den richtigen Bereich zu machen
⎕UCSin Text umwandeln

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)

Probieren Sie es online! (Ideone)

MATL , 28 Bytes

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

Probieren Sie es online!

Alle zulässigen Zeichen haben die gleiche Wahrscheinlichkeit des Auftretens. Funktioniert auch für gleichmäßige Eingaben.

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 (oder 119 ohne Kesselplatte)

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

Oder 119 Bytes als eine Funktion X(h)mit srand(time(0))betreut an anderer Stelle:

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

Nervenzusammenbruch:

o(w,c){                         // "Output" function, for all printing
    c=rand()%94+33;             // Generate random char, whether we need it or not
    printf("%*c",               // Print a char with some number of leading spaces
           w,                   // Use "w" (width) - 1 leading spaces
           w?                   // Either print the random char...
             c+!(c&95^89)       // (exclude "y" and "Y" by incrementing to "z"/"Z")
                         :10    // ...or print a newline if called with w = 0
    );
}
main(h){                        // Main function; repurpose argc to store grid size
    scanf("%d",&h);             // Get grid size from stdin
    srand(time(0));             // Boiler-plate for random number seeding
    for(int n=h,p;n--;)         // Loop over all lines (count down to save chars)
        p=abs(h/2-n),           // Calculate half-distance between "X" bars
        o(h/2-p+1),             // Output the first half of the "X" (">")
        p&&                     // If we are not in the centre:
           o(p*2),              //   output the second half of the "X" ("<")
        o(0);                   // Output a newline
}

x86-Maschinencode, 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

Mein ausführbarer Code, zerlegt:

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 ist eine Funktion, die in ecx die Größe des X und in edx einen Zeiger auf den Ausgabepuffer erhält.

Es füllt den Ausgabepuffer sequentiell mit Bytes. Es gibt 2 * n - 1Iterationen (gleich der Anzahl der auszugebenden Nicht-Leerzeichen). Bei jeder Iteration wird Folgendes ausgeführt:

• Generiere eine Zufallszahl
• Spielen Sie mit der Zahl, um sie in die Reichweite zu bringen. Wenn es schlecht ist, gehen Sie zurück und generieren Sie neu
• Drucken Sie das zufällige Zeichen
• Eine neue Zeile drucken (jede zweite Iteration)
• Drucken Sie die richtige Anzahl von Leerzeichen

Die Umwandlung einer Zufallszahl in ein zufälliges Zeichen ist nicht bemerkenswert:

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

Der interessante Teil ist die Berechnung der Anzahl der Räume. Es muss die folgenden Zahlen erzeugen (Beispiel für N = 9):

7    1
5    2
3    3
1    4

     3
1    2
3    1
5    0
7

Die Zahlen werden abwechselnd von zwei arithmetischen Folgen genommen. Der erste geht mit Schritt -2 runter und der zweite geht mit Schritt 1 rauf. Wenn der erste Fortschritt bei -1 (in der Mitte des X) ankommt, gibt es einen Fehler (-1 wird entfernt), und dann Die Progressionen ändern ihre Richtung.

Die Progressionen werden in Registern ebxund edx- den oberen Teilen gespeichert bhund dhspeichern die aktuelle Nummer und die unteren Teile blund dlspeichern den Schritt. Um zwischen den Fortschritten zu wechseln, tauscht der Code die Register mit xchg.

Wenn der Fortschritt -1 (um das mylabEtikett herum ) erreicht, werden beide Register vergrößert und die Schritte von -2, 1auf umgeschaltet -1, 2. Dies ändert auch die Rollen der Register, so dass dann die oberen Teile der Register vertauscht werden.

Am Ende der Funktion wird ein Null-Byte gespeichert, um ein Ende der Zeichenfolge anzuzeigen.

Lua, 277 Bytes

Nun ... Lua ist soooo gut darin, Saiten zu manipulieren: D. Zum ersten Mal musste ich localin einer Aussage verwenden! Ich konnte mit Lua 5.1 anstelle von 5.3 einige Bytes einsparen, weil sie die globale Funktion unpackin das Objekt tablevon Lua 5.2 verschoben haben . Aber ich bleibe lieber bei der neuesten Version :).

Definiert eine Funktion, die mit einem einzelnen Parameter aufgerufen werden soll (der zweite wird für Rekursionszwecke verwendet) und gibt eine Zeichenfolge zurück.

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`

Wobei \ndas wörtliche Zeilenumbruchzeichen darstellt. Bearbeiten: 1 Byte durch Verschieben ' 'des String.fromCharCodeAusdrucks gespeichert . 5 Bytes gespart, indem ich meine zufällige Zeichengenerierung ungleichmäßig gemacht habe; Der Ausdruck r+72&95ist Null für die Werte, die zugeordnet sind, Yund yund !wird an ihrer Stelle generiert. 4 Bytes gespart, als mir klar wurde, dass es nicht nötig ist, sich über String.fromCharCodemehrere Bytes zu verbreiten join. 2 Bytes gespart, indem ein Trick von @ edc65 gestohlen wurde.

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

Liest Eingaben von der Kommandozeile.

Für jede Zeile wird ein Array von Leerzeichen erstellt, die korrekten Indizes werden mit Zeichen gefüllt, die aus der Funktion fabgerufen wurden. Anschließend wird das Zeichen- Array verbunden, um als eine Zeile ausgegeben zu werden.

MATLAB, 86 Bytes

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

Einige Beispiele:

>> 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 Byte Code, +1 für -lFlag. Seltsamerweise beginnt der Code mit Yund endet mit y...

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

Übernimmt die Eingabe als Befehlszeilenargument. Probieren Sie es online!

Erläuterung

Konstruiert ein Raster der entsprechenden Größe. Ersetzt Elemente auf den Diagonalen durch ein zufälliges Nicht-Y-Zeichen und alle anderen Elemente durch Leerzeichen.

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

Ziemlich unkomplizierter Ansatz verwendet str_pad, um eine Zeichenfolge mit der erforderlichen Länge zu erstellen, ersetzt die erforderlichen Zeichen durch zufällige und ersetzt alle Ys (ohne Berücksichtigung der Groß- und Kleinschreibung) durch Xs und gibt die Zeile als Echo aus.
Erzeugt 2n + 3 Notices, aber wie immer ist das in Ordnung.

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 und leicht modifiziert:

(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

Bearbeite 3 Bytes, die dank @Neil gespeichert wurden

So sperrig, wahrscheinlich nicht der beste Ansatz. Bonus - es funktioniert mit ungeraden oder geraden Eingaben.

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

Rufen Sie f()mit der Größe der xzu zeichnen.

Matricks , 79 Bytes (nicht konkurrierend)

Matricks zeichnet sich als der Beginn der x machen und alle Zufallswerte, aber Flops , wenn es um conditionals kommt ...

Ich habe dies als nicht konkurrierend markiert, weil ich einige Fehler beheben und alle neuen Funktionen zum Laufen bringen musste, nachdem diese Herausforderung veröffentlicht wurde.

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

Laufen Sie mit python matricks.py x.txt [[]] <input> --asciiprint

Erläuterung:

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

Dies unterstützt auch gerade Zahlen.

Python 2, 204 191 183 Bytes

Okay, der Python-Wettbewerb hier wird heftig. Hier ist mein Versuch, so viele Bytes wie möglich zu rasieren. Inzwischen stecke ich fest (Ok, stecke wieder fest).

Dank an @NonlinearFruit für die Art und Weise, wie zufällige Zeichen ausgewählt werden.

183-Byte-Version:

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)

Probieren Sie es online! (Ideone)

Hauptänderung ist, die Bedingung neu zu schreiben

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

wie

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

Das spart 7 Bytes.

191-Byte-Version:

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)

Probieren Sie es online! (Ideone)

Die wichtigsten Änderungen betreffen die Art und Weise, wie zufällige Zeichen ausgewählt werden, und einige Code-Neuanordnungen, z. B. s=input();i=s;werden s=i=input();, die r=rangeZuordnung entfernen, da sie nicht mehr benötigt wird, und absdirekt aufrufen, da dies zu weniger Code-Bytes führt.

Die kürzeste Antwort in Python um 1 Byte übertreffen! @R. Kaps Ansatz wird zur Erzeugung der Zufallszeichen verwendet. Bei jeder Iteration der while-Schleife wird eine Zeile des ex gedruckt.

204-Byte-Version :

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)

Probieren Sie es online! (Ideone)

Ungolfed-Version, um eine Vorstellung davon zu bekommen, wie es funktioniert:

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

Es war schwer, mit dem 1-Zeichen-Fall umzugehen!

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

Anstatt die Anzahl der Leerzeichen zwischen den einzelnen Zeichen oder etwas zu berechnen, habe ich mich dazu entschieden, nur an allen Stellen zu drucken, an denen X==Yoder X+Y==Size+1.
Der Zufallszeichengenerator addiert nur 1, wenn er yoder generiert Y, zund Zist etwas häufiger als üblich.

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

Nimmt Eingaben vom Kommandozeilenargument entgegen; renn mit -nr.

Kombinierte Schleife druckt Zeichen je nach Position

Nervenzusammenbruch

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