Zwykle mówi się, że „Doing X bez Y” może być pułapką dla początkujących pisarzy ( źródło ). Jestem jednak pewny siebie i myślę, że zdecydowanie mogę zrobić X bez żadnego Y. Losowo O tak, będzie dobrze.

Wyzwanie: Biorąc pod uwagę nieparzystą liczbę całkowitą nwiększą lub równą 1, wypisz ex o długości boku nwykonanej z losowo drukowanych znaków ascii bez „y” i „Y” oraz spacji. Wszystkie dozwolone postacie muszą mieć niezerową szansę wystąpienia, ale niekoniecznie jednolite. Jest to golfowy kod, więc wygrywa najkrótszy kod w bajtach. Powinieneś jednak randomizować każdy znak - to znaczy rozpórki ex nie powinny być równe, chyba że przypadkiem.

Pojawiają się znaki

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

Konstruowanie ex

Długość boku 1:

x

Długość boku 3:

x x
 x
x x

Długość boku 5:

x   x
 x x
  x
 x x
x   x

itp.

Przykładowe dane wyjściowe

input
output
empty line

3
h 2
 ^
9 5

1
:

5
D   1
 W z
  W
 q j
W   1

Przykładowa implementacja

Nie musisz obsługiwać nieprawidłowych danych wejściowych.

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 bajtów

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

Zestaw testowy.

Rubin, 102 bajty

Array#samplenie wykonuje powtórzeń próbkowania z zestawu znaków, ale to jest OK, ponieważ rozkład znaków nie musi być idealnie jednolity! Funkcja rekurencyjna zwraca tablicę wierszy.

Wypróbuj 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]}

Właściwie 62 bajty

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

Jest to jeden z najdłuższych programów, jakie kiedykolwiek napisałem.

Wypróbuj online!

Wyjaśnienie:

Część 1 : konfigurowanie listy znaków

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

Wypróbuj online!

Część 2 : konstruowanie tablicy boolowskiej dla 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)

Wypróbuj online!

Część 3 : wybór losowych postaci

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

Wypróbuj online!

Mathematica, 146 bajtów

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

Funkcja anonimowa. Pobiera liczbę jako dane wejściowe i zwraca ciąg jako dane wyjściowe.

Python 2, 171 bajtów

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

Gwarantowany wybór losowych postaci z jednakowym prawdopodobieństwem.

Wypróbuj tutaj: link ideone

EDYCJA: Dzięki Morgan Thrapp za poprawki.

Python, 142 139 135 bajtów

Jest to prosta implementacja, która tworzy kwadrat po znaku. Jeśli znak jest na przekątnej : użyj losowy char, inny : używać spacji. To również używa podstawienia wyrażenia regularnego i losowego int do generowania Yznaków innych niż :

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

Wyjaśnienie [stary]

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

Aktualizacja

• -4 [16-07-30] Skrócona nowa linia warunkowa
• -3 [16-07-30] Zmieniono na pojedynczy dla pętli
• -6 [16-07-29] Wymieniono, jeśli instrukcja dla trójki op. Dzięki @RootTwo
• -11 [16-07-27] Usunięto dodatkowe nawiasy / spacje i zmieniono instrukcję if
• -49 [16-07-27] Metoda Absordeda @ squeamishossifrage'a, tworząc kwadratowy krok po kroku, Dzięki!
• -10 [16-07-27] Skróć losowe char lambda + matematyki z @ ConorO'Brien
• -22 [16-07-26] Squeaze in lambda + misc golf
• -6 [16-07-26] import*- Dzięki @KevinLau

Dyalog APL , 35 bajtów

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

⎕monit o numer
⍳1 przez tę samą
∘.=⍨tabelę równości liczb (tj. przekątna ma cyfry 1s)
(⊢∨⌽)LUB jej odbicie lustrzane (daje obie przekątne)
95×pomnożone przez 95
?rand int między 1 a 95 dla przekątnych, rand unosi się między 0 a 1 dla reszty
⌊podłogi pozbyć się
(⊢+∊∘57 89)liczb zmiennoprzecinkowych dodaj jeden do elementów należących do {57,89} (Yy - 32)
32+dodaj 32, aby zerować w spacje, a inne liczby w odpowiednim zakresie
⎕UCSzamień na tekst

TryAPL !

Python 2.7, 205 bajtów:

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)

Wypróbuj online! (Ideone)

MATL , 28 bajtów

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

Wypróbuj online!

Wszystkie dozwolone postacie mają takie samo prawdopodobieństwo pojawienia się. Działa również na równomierny wkład.

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 bajtów (lub 119 bez płyty kotła)

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

Lub 119 bajtów jako funkcja, X(h)o którą srand(time(0))zadbano gdzie indziej:

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

Awaria:

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
}

kod maszynowy x86, 70 bajtów

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

Mój kod wykonywalny, zdemontowany:

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                     

Jest to funkcja, która odbiera rozmiar X w ekxie i wskaźnik do bufora wyjściowego w edx.

Wypełnia bufor wyjściowy sekwencyjnie bajtami. Istnieją 2 * n - 1iteracje (równe liczbie znaków spacji do wydrukowania). Przy każdej iteracji wykonuje następujące czynności:

• Wygeneruj liczbę losową
• Baw się z liczbą, aby dopasować ją do zasięgu; jeśli jest źle, wróć i wygeneruj od nowa
• Wydrukuj losowy znak
• Wydrukuj nowy wiersz (co drugą iterację)
• Wydrukuj odpowiednią liczbę spacji

Konwersja liczby losowej na postać losową nie jest niezwykła:

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

Interesującą częścią jest obliczenie liczby spacji. Musi wygenerować następujące liczby (przykład dla N = 9):

7    1
5    2
3    3
1    4

     3
1    2
3    1
5    0
7

Liczby są pobierane naprzemiennie z dwóch postępów arytmetycznych. Pierwszy idzie w dół z krokiem -2, a drugi idzie w górę z krokiem 1. Gdy pierwszy postęp osiąga -1 (w środku X), pojawia się usterka (-1 jest usuwany), a następnie postępy zmieniają kierunek.

Postępy są przechowywane w rejestrach ebxi edx- wysokie części bhi dhprzechowują bieżący numer, a niskie części bli dlprzechowują krok. Aby przełączać się między progresjami, kod zamienia rejestry na xchg.

Gdy progresja osiąga wartość -1 (wokół mylabetykiety), zwiększa oba rejestry, przełączając kroki z -2, 1na -1, 2. Zmienia to także role rejestrów, a zatem zamienia wysokie części rejestrów.

Na końcu funkcji przechowuje bajt zerowy wskazujący koniec łańcucha.

Lua, 277 bajtów

Cóż ... Lua jest bardzo dobry w manipulowaniu ciągami: D. Pierwszy raz musiałem użyć localw oświadczeniu! Mógłbym zaoszczędzić trochę bajtów używając Lua 5.1 zamiast 5.3, ponieważ przenieśli funkcję globalną unpackdo obiektu tablew Lua 5.2. Ale wolę trzymać się najnowszej wersji, którą mam :).

Definiuje funkcję, która powinna zostać wywołana z jednym parametrem (drugi służy do rekurencji) i zwraca ciąg.

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

Bez golfa

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 bajtów

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`

Gdzie \nreprezentuje dosłowny znak nowej linii. Edycja: Zapisano 1 bajt, przesuwając ' 'wnętrze String.fromCharCodewyrażenia. Zaoszczędziłem 5 bajtów, powodując, że generowanie losowych postaci nie było jednolite; wyrażenie r+72&95jest zerowe dla wartości, które są odwzorowane na Yi, ya !zamiast nich jest generowane. Zaoszczędziłem 4 bajty, kiedy zdałem sobie sprawę, że rozprzestrzenianie się String.fromCharCodeunika konieczności join. Zaoszczędzono 2 bajty, kradnąc lewę z @ edc65.

PowerShell v2 +, 112 bajtów

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

Odczytuje dane wejściowe z linii poleceń.

Dla każdego wiersza tworzona jest tablica spacji, poprawne indeksy wypełniane znakami pobranymi z funkcji f, a następnie tablica char jest łączona, aby uzyskać wynik jako jeden wiersz.

MATLAB, 86 bajtów

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

Kilka przykładów:

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

32 bajty kodu, +1 dla -lflagi. O dziwo, kod zaczyna się Yi kończy na y...

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

Pobiera dane wejściowe jako argument wiersza polecenia. Wypróbuj online!

Wyjaśnienie

Konstruuje siatkę o odpowiednim rozmiarze; zastępuje elementy na przekątnych losową postacią inną niż y, a wszystkie inne elementy spacją.

                                  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 bajtów

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

Dość proste podejście wykorzystuje str_pad do utworzenia ciągu spacji o wymaganej długości, zastępuje niezbędne znaki losowymi, a następnie zastępuje dowolne Y (bez rozróżniania wielkości liter) Xs i echa linii.
Generuje powiadomienia 2n + 3, ale jak zwykle w porządku.

Emacs Lisp, 269 bajtów

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

Nieogrodzony i nieznacznie zmodyfikowany:

(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

Edytuj 3 bajty zapisane thx @Neil

Tak nieporęczne, prawdopodobnie nie najlepsze podejście. Bonus - działa z nieparzystym lub parzystym wejściem.

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 bajtów

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

Zadzwoń f()z rozmiarem xdo losowania.

Matricks , 79 bajtów (niekonkurujące)

Matricks wyróżnia się jako początek tworzenia wartości x i wszystkich wartości losowych, ale klapy, jeśli chodzi o warunki warunkowe ...

Oznacziłem to jako niekonkurujące, ponieważ musiałem naprawić kilka błędów i uruchomić wszystkie nowe funkcje po opublikowaniu tego wyzwania.

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

Biegnij z python matricks.py x.txt [[]] <input> --asciiprint

Wyjaśnienie:

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

Obsługuje to również liczby parzyste.

Python 2, 204 191 183 bajtów

Dobra, konkurencja w Pythonie staje się coraz bardziej zacięta. Oto moja próba zgolenia jak największej liczby bajtów. Teraz utknąłem (Ok, utknąłem ponownie).

Kredyty dla @NonlinearFruit za sposób wybierania losowych postaci.

Wersja 183 bajtów:

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)

Wypróbuj online! (Ideone)

Główną zmianą jest przepisanie warunkowe

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

tak jak

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

co oszczędza 7 bajtów.

Wersja 191 bajtów:

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)

Wypróbuj online! (Ideone)

Głównymi zmianami są sposób wybierania losowych znaków i zmiany układu kodu, takie jak s=input();i=s;stawanie się s=i=input();, usuwanie r=rangeprzypisania, ponieważ nie jest już potrzebne i absbezpośrednie wywoływanie, ponieważ powoduje to mniej bajtów kodu.

Pokonanie poprzedniej najkrótszej odpowiedzi w Pythonie o 1 bajt! @R. Podejście Kapa służy do generowania losowych postaci. Każda iteracja pętli while drukuje rząd ex.

Wersja 204 bajtów :

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)

Wypróbuj online! (Ideone)

Wersja bez golfa, aby dowiedzieć się, jak to działa:

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

Ciężko było poradzić sobie z przypadkiem 1-znakowym!

SmileBASIC, 97 bajtów

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

Zamiast obliczać liczbę spacji między każdą postacią lub czymś, postanowiłem po prostu wydrukować we wszystkich miejscach, gdzie X==Ylub X+Y==Size+1.
Generator losowych postaci dodaje tylko 1, jeśli generuje ylub Y, zi Zsą nieco bardziej powszechne niż zwykle.

PHP, 100 bajtów

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

pobiera dane wejściowe z argumentu wiersza poleceń; biegać z -nr.

Pętla łączona drukuje znaki w zależności od pozycji

awaria

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