Genellikle, "Y olmadan X Türü" ana zorluğu (yazma başlayanlar için bir tuzak olabilir söylenir kaynağı ). Ancak, ukalayım ve kesinlikle herhangi bir Ys olmadan bir X yapabilirim diye düşünüyorum . Rastgele. Ah evet, bu iyi olacak.

Zorluk:n 1 veya daha büyük bir tam sayı verildiğinde n, rastgele yazdırılabilir ascii karakterlerinden "y" ve "Y" ve boşluktan oluşan rasgele yazdırılabilir ascii karakterlerinden oluşan bir yan uzunluk çıktısı alın . İzin verilen tüm karakterlerin sıfırdan oluşma şansı olması gerekir, ancak tekdüze olması gerekmez. Bu bir kod golfüdür, yani bayttaki en kısa kod kazanır. Bununla birlikte, her bir karakteri rastgele seçmelisin - yani, eskilerin dikmeleri şans eseri olmadıkça eşit olmamalıdır.

Görünecek karakterler

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

Eski inşa

Yan uzunluğu 1:

x

Yan uzunluğu 3:

x x
 x
x x

Yan uzunluğu 5:

x   x
 x x
  x
 x x
x   x

vb.

Örnek çıktılar

input
output
empty line

3
h 2
 ^
9 5

1
:

5
D   1
 W z
  W
 q j
W   1

Örnek uygulama

Geçersiz girişleri işlemenize gerek yoktur.

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 bayt

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

Test odası.

Ruby, 102 bayt

Array#samplekarakter kümesinden örnekleme için tekrarlama yapmaz, ancak bu tamam çünkü karakter dağılımının mükemmel bir şekilde aynı olması gerekmez! Özyinelemeli işlevi, bir satır dizisi döndürür.

Çevrimiçi deneyin!

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

Aslında, 62 bayt

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

Bu şimdiye kadar yazdığım en uzun programlardan biri.

Çevrimiçi deneyin!

Açıklama:

Bölüm 1 : karakter listesini ayarlama

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

Çevrimiçi deneyin!

Bölüm 2 : bir X için boolean dizisinin oluşturulması

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

Çevrimiçi deneyin!

Bölüm 3 : rastgele karakterler seçmek

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

Çevrimiçi deneyin!

Mathematica, 146 bayt

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

Anonim işlev Girdi olarak bir sayı alır ve çıktı olarak bir dize döndürür.

Python 2,171 bayt

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

Tek tip olasılık ile rastgele karakterleri seçmek için garanti edilir.

Burada deneyin: ideone link

EDIT: Morgan Thrapp'a düzeltmeler için teşekkürler.

Python, 142 139 135 bayt

Bu yalındır ileri uygulama kare karakter karakter yaratır. Karakter köşegen üzerinde ise : rasgele bir karakter kullanın , başka : boşluk kullanın. Bu ayrıca Ykarakter olmayan karakterleri oluşturmak için bir regex ikamesi ve rastgele int kullanır :

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

Açıklama [Eski]

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

Güncelleme

• -4 [16-07-30] Koşullu kısaltılmış newline
• -3 [16-07-30] Tek döngü için değiştirildi
• -6 [16-07-29] Üçlü ifadenin ifadesi değişmedi. @RootTwo 'a teşekkürler
• -11 [16-07-27] Ekstra parantez / boşluk kaldırıldı ve if ifadesi çevrilmiş
• -49 [16-07-27] Adım adım karesi oluşturarak squeamishossifrage yöntemini absorbe etti, Teşekkürler!
• -10 [16-07-27] @ ConorO'Brien'den rastgele char lambda + matematiğini kısalttı
• -22 [16-07-26] Bir lambdada squeaze + misc golf
• -6 [16-07-26] import*- @KevinLau'ya teşekkürler

Dyalog APL , 35 bayt

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

⎕
⍳bu sayı
∘.=⍨eşitlik tablosundan 1 numara için bilgi istemi (yani, köşegenin 1s'si vardır)
(⊢∨⌽)VEYA ayna görüntüsü (her iki köşegen verir) köşegenler için 1 ve 95 arasında
95×95
?rand int ile çarpar , ve dinlenme
⌊katları için 0 ile 1 arasında yüzer şamandıralardan kurtulmak,
(⊢+∊∘57 89){57,89} (Yy - 32) üyesi olan öğelere bir tane ekler ve 0'ları
32+boşluklara yerleştirmek için 32 ekler ve diğer sayıların
⎕UCSmetne dönüştürülmesini sağlar.

TryAPL !

Python 2.7, 205 bayt:

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)

Çevrimiçi Deneyin! (Ideone)

MATL , 28 bayt

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

Çevrimiçi deneyin!

İzin verilen tüm karakterlerin görünme olasılığı aynıdır. Hatta giriş için bile çalışır.

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 bayt (veya kazan tabağı olmadan 119)

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

Bir fonksiyonu olarak veya 119 byte X(h)ile srand(time(0))başka yerde halledilir:

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

Yıkmak:

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 makine kodu, 70 bayt

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

Çalıştırılabilir kodum demonte edildi:

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                     

Bu, ecx'teki X'in boyutunu alan ve edx'teki çıktı tamponuna bir işaretçi getiren bir fonksiyondur.

Çıkış arabelleğini sırayla baytlarla doldurur. Vardır 2 * n - 1(çıkışına boşluk olmayan karakterlerin sayısına eşittir) yineleme. Her yinelemede, aşağıdakileri yapar:

• Rasgele bir sayı üret
• Menzile sığdırmak için sayıyı tuşlayın; eğer kötüyse, geri dön ve yeniden oluştur
• Rasgele karakteri yazdır
• Yeni bir satır yazdır (diğer her yineleme)
• Uygun sayıda boşluk yazdırın

Rasgele bir sayıdan rasgele bir karaktere dönüşüm dikkat çekici değildir:

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

İlginç olan kısım, boşluk sayısının hesaplanmasıdır. Aşağıdaki sayıları oluşturmalıdır (N = 9 için örnek):

7    1
5    2
3    3
1    4

     3
1    2
3    1
5    0
7

Sayılar, iki aritmetik ilerlemeden dönüşümlü olarak alınır. Birincisi adım -2 ile aşağı iner, ikincisi adım 1 ile yukarı çıkar. İlk ilerleme -1'e (X'in ortasında) ulaştığında, bir aksaklık (-1 kaldırılır) ve sonra ilerlemeler yön değiştirir.

İlerlemeler kayıt saklanır ebxve edx- yüksek parça bhve dhmevcut sayısını, ve düşük parçalar depolamak blve dladım saklayın. İlerlemeler arasında geçiş yapmak için kod, kayıtları değiştirir xchg.

İlerleme -1'e ulaştığında ( mylabetiketin etrafında ), her iki kaydediciyi de artırarak adımlar arasında geçiş -2, 1yapar -1, 2. Bu aynı zamanda kayıtların rollerini de değiştirir, böylece kayıtların yüksek kısımlarını değiştirir.

İşlevin sonunda, dizenin sonunu belirtmek için sıfır bayt depolar.

Lua, 277 Bayt

Şey ... Lua sooooo dizeleri işlemek için iyi: D. İlk kez localbir ifadede kullanmak zorunda kaldım ! Genel işlevi Lua 5.2'deki unpacknesneye taşıdıkları için 5.3 yerine Lua 5.1 kullanarak bazı baytları kaydedebilirim table. Ama sahip olduğum en son versiyona bağlı kalmayı tercih ederim :).

Tek bir parametreyle çağrılması gereken bir işlev tanımlar (ikincisi özyineleme amacıyla kullanılır) ve bir dize döndürür.

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 bayt

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`

Nerede \nliteral satır karakteri temsil eder. Düzenleme: İfadenin ' 'içini hareket ettirerek 1 bayt kaydedildi String.fromCharCode. Rasgele karakter üretimimi tek tip yapmadan 5 bayt kurtardım; ifadesi r+72&95eşleme değerler için sıfırdır Yve ybir !onların yerine oluşturulur. Üzerine yayıldığını String.fromCharCodeanlamak zorunda kaldığımda 4 byte kurtardı join. @ Edc65'den bir numara çalıp 2 byte kurtarıldı.

PowerShell v2 +, 112 bayt

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

Komut satırından girişi okur.

Her satır için, bir boşluk dizisi yaratılır, doğru indeksler fonksiyondan çekilen karakterlerle doldurulur f, ardından char dizisi çıktıya bir satır olarak eklenir.

MATLAB, 86 bayt

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

Bazı örnekler:

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

32 baytlık kod, -lbayrak için +1 . Garip bir şekilde, kod ile başlar Yve ile biter y...

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

Komut satırı argümanı olarak girdi alır. Çevrimiçi deneyin!

açıklama

Uygun büyüklükte bir ızgara oluşturur; köşegenlerin üzerindeki öğeleri rastgele y olmayan bir karakterle, diğer tüm öğeleri boşlukla değiştirir.

                                  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 bayt

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

Oldukça basit bir yaklaşım, istenen uzunlukta bir boşluk dizisi yapmak için str_pad'i kullanır, gerekli karakterleri rastgele olanlarla değiştirir, ardından Ys (büyük / küçük harfe duyarlı) X'lerle değiştirir ve çizgiyi eko yapar.
2n + 3 bildirimleri oluşturur, ancak her zamanki gibi sorun değil.

Emacs Lisp, 269 bayt

(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 ve biraz değiştirilmiş:

(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

3 bayt düzenle thx @Neil kaydetti

Çok hantal, muhtemelen en iyi yaklaşım değil. Bonus - tek veya çift girdiyle çalışır.

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 bayt

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

Çizmek f()için boyutu ile arayın x.

Matricks , 79 bayt ( yarışmaz )

Matricks , x'i ve tüm rasgele değerleri yaratmanın başlangıcı olarak öne çıkıyor, ancak şartlara gelince floplar ...

Bunu rakipsiz olarak işaretledim çünkü birkaç hata düzeltmek zorunda kaldım ve bu zorluğun yayınlanmasından sonra çalışan tüm yeni özellikleri almak zorunda kaldım.

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

İle koş python matricks.py x.txt [[]] <input> --asciiprint

Açıklama:

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

Bu aynı zamanda çift sayıları destekler.

Python 2, 204 191 183 bayt

Tamam, buradaki Python yarışması sertleşiyor. İşte benim mümkün olduğunca çok bayt tıraş benim girişimi. Artık sıkışıp kaldım (Tamam, tekrar sıkışmış).

@NonlinearFruit kredileri rastgele karakterlerin seçilme şekli için.

183 bayt sürümü:

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)

Çevrimiçi Deneyin! (Ideone)

Ana değişiklik koşullu yeniden yazmaktır

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

gibi

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

7 bayt kaydeder.

191 bayt sürümü:

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)

Çevrimiçi Deneyin! (Ideone)

Ana değişiklikler rastgele karakterler seçilir yolu ve gibi bazı kod düzenleme bulunmaktadır s=input();i=s;olma s=i=input();, çıkarmadan r=rangeartık ihtiyaç olarak atama ve arama abskodun daha az bayt sonuçlanır doğrudan.

Python'daki önceki en kısa cevabı 1 byte atarak! @R. Rastgele karakterleri üretmek için Kap'ın yaklaşımı kullanılır. While döngüsünün her yinelemesi, ex dosyasının bir satırı yazdırılır.

204 bayt sürümü :

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)

Çevrimiçi Deneyin! (Ideone)

Ungolfed versiyonu nasıl çalıştığı hakkında bir fikir edinmek için:

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

1 karakterlik vakayı ele almak zordu!

SmileBASIC, 97 bayt

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

Her karakter ya da bir şey arasındaki boşluk sayısını hesaplamak yerine, sadece X==Yya da olan tüm konumlara yazdırmaya karar verdim X+Y==Size+1.
Rastgele karakter üreteci , ürettiği yya da ürettiği takdirde sadece 1 ekler ve normalden biraz daha yaygındır.YzZ

PHP, 100 bayt

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

komut satırı argümanından girdi alır; ile koş -nr.

birleşik döngü pozisyona bağlı olarak karakter yazdırır

Yıkmak

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