Зазвичай кажуть, що "Зробити X без Y" може стати пасткою для початківців, які пишуть виклики ( джерело ). Тим не менш, я зухвалий і думаю, що я точно можу зробити X без жодної Ys. Випадково. О так, це буде добре.

Завдання: Давши непарне ціле число, що nбільше або дорівнює 1, виведіть колишню бічну довжину, nзроблену з випадкових символів ascii для друку, не містить "y" і "Y", а також пробіл. Усі дозволені символи повинні мати ненульовий шанс виникнення, але не обов'язково однаковий. Це гольф з кодом, тому виграє найкоротший код у байтах. Однак ви повинні рандомізувати кожну таблицю - тобто струни колишнього не повинні бути рівними, якщо не випадково.

Характеристики, які з'являться

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

Побудова екс

Довжина сторони 1:

x

Довжина сторони 3:

x x
 x
x x

Бічна довжина 5:

x   x
 x x
  x
 x x
x   x

тощо.

Приклади виходів

input
output
empty line

3
h 2
 ^
9 5

1
:

5
D   1
 W z
  W
 q j
W   1

Приклад реалізації

Вам не потрібно обробляти недійсні введення.

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 байт

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

Тестовий набір.

Рубін, 102 байти

Array#sampleне робить повторів для вибірки з набору символів, але це нормально, оскільки розподіл символів не повинен бути ідеально рівномірним! Рекурсивна функція, повертає масив рядків.

Спробуйте в Інтернеті!

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

Власне, 62 байти

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

Це одна з найдовших програм, які насправді я писав.

Спробуйте в Інтернеті!

Пояснення:

Частина 1 : налаштування списку символів

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

Спробуйте в Інтернеті!

Частина 2 : побудова булевого масиву для 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)

Спробуйте в Інтернеті!

Частина 3 : вибір випадкових символів

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

Спробуйте в Інтернеті!

Математика, 146 байт

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

Анонімна функція. Приймає число в якості введення і повертає рядок як вихід.

Пітон 2, 171 байт

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

Гарантується вибір випадкових персонажів з однаковою ймовірністю.

Спробуйте його тут: посилання ideone

EDIT: Дякую Морган Трапп за виправлення.

Пітон, 142 139 135 байт

Це пряма реалізація створення символу квадратного символу. Якщо персонаж знаходиться по діагоналі : використовуйте випадковий знак char, в іншому випадку : використовуйте пробіл. Для цього також використовується підстановка з регулярними виразами та випадковий int для генерування не Yсимволів:

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

Пояснення [Старий]

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

Оновлення

• -4 [16-07-30] Скорочений новий рядок умовний
• -3 [16-07-30] Змінено на одинарний цикл
• -6 [16-07-29] Обміняється, якщо заява для потрійних оп. Завдяки @RootTwo
• -11 [16-07-27] Видалено додаткові дужки / пробіли та перевернуто, якщо оператор
• -49 [16-07-27] Обговорив метод @ squeamishossifrage, створивши квадратний крок за кроком, Дякую!
• -10 [16-07-27] Скоротіть випадкову лямбда-ляльку + математичні речі від @ ConorO'Brien
• -22 [16-07-26] Стисніть в лямбда + різний гольф
• -6 [16-07-26] import*- Завдяки @KevinLau

Діалог APL , 35 байт

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

⎕підказка для номера
⍳1 через
∘.=⍨таблицю рівності чисел (тобто діагональ має 1s)
(⊢∨⌽)сама, або її дзеркальне зображення (дає обидві діагоналі)
95×помножте на 95
?rand int між 1 і 95 для діагоналей, rand плаває між 0 і 1 для решти
⌊поверху до позбудьтеся поплавків,
(⊢+∊∘57 89)додайте один до елементів, що входять до складу {57,89} (Yy - 32),
32+додайте 32, щоб 0 ставили пробіли, а інші числа перетворювали у відповідний діапазон,
⎕UCSперетворюючи на текст

СпробуйтеAPL !

Python 2.7, 205 байт:

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)

Спробуйте в Інтернеті! (Ідеон)

MATL , 28 байт

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

Спробуйте в Інтернеті!

Усі дозволені символи мають однакову ймовірність появи. Працює навіть для введення даних.

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 байти (або 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);}

Або 119 байт як функція, X(h)якщо srand(time(0))піклуватися про інше:

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

Зламатися:

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, 70 байт

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

Мій виконуваний код, розібраний:

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                     

Це функція, яка отримує розмір X в ecx, і вказівник на вихідний буфер в edx.

Він заповнює вихідний буфер послідовно байтами. Є 2 * n - 1ітерації (дорівнює кількості непробільних символів для виводу). При кожній ітерації вона робить наступне:

• Утворіть випадкове число
• Скиньтеся з номером, щоб вписати його в діапазон; якщо це погано, поверніться і генеруйте заново
• Друк випадкового символу
• Друк нового рядка (будь-яка інша ітерація)
• Роздрукуйте належну кількість пробілів

Перетворення від випадкового числа до випадкового символу не примітно:

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

Цікава частина - обчислення кількості пробілів. Він повинен генерувати такі числа (приклад для N = 9):

7    1
5    2
3    3
1    4

     3
1    2
3    1
5    0
7

Числа приймаються по черзі з двох арифметичних прогресій. Перший знижується з кроком -2, а другий йде з кроком 1. Коли перша прогресія доходить до -1 (в середині X), виникає збіг (-1 видаляється), а потім прогресії змінюють напрямок.

Прогресії зберігаються в регістрах ebxі edx- високих частинах bhі dhзберігають поточне число, а низькі частини blі dlзберігають крок. Для чергування між прогресіями код заміняє регістри на xchg.

Коли прогресія досягає -1 (навколо mylabмітки), вона збільшує обидва регістри, перемикаючи кроки з -2, 1на -1, 2. Це також змінює ролі регістрів, тож воно замінює високі частини регістрів.

В кінці функції він зберігає нульовий байт для позначення кінця рядка.

Луа, 277 байт

Ну ... Луа так добре маніпулює струнами: D. Перший раз мені довелося використовувати localв заяві! Я міг би зберегти кілька байтів, використовуючи Lua 5.1 замість 5.3, оскільки вони перемістили глобальну функціюunpack в об’єкт tableу Lua 5.2. Але я вважаю за краще дотримуватися останньої в мене версії :).

Визначає функцію, яку слід викликати з одним параметром (другий використовується для цілей рекурсії) і повертає рядок.

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

Безумовно

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 байт

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`

Де \nпредставляє буквальний символ нового рядка. Редагувати: збережено 1 байт, перемістивши ' 'всередину String.fromCharCodeвиразу. Збережено 5 байт, зробивши моє покоління випадкових символів неоднорідним; вираз r+72&95дорівнює нулю для значень, які відображаються на Yі, yа !генерується на їх місці. Збережено 4 байти, коли я зрозумів, що розповсюдження над ними String.fromCharCodeуникає необхідності join. Збережено 2 байти, вкравши трюк від @ edc65.

PowerShell v2 +, 112 байт

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

Читає вхід із командного рядка.

Для кожного рядка створюється масив пробілів, правильні індекси, заповнені символами, витягнутими з функції f, потім масив char приєднується до виводу як один рядок.

MATLAB, 86 байт

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

Деякі приклади:

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

Піп , 33 байти

32 байти коду, +1 для -lпрапора. Як не дивно, код починається з Yі закінчується y...

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

Вводиться як аргумент командного рядка. Спробуйте в Інтернеті!

Пояснення

Конструює сітку відповідного розміру; замінює елементи на діагоналях випадковим символом не-у, а всі інші елементи пробілом.

                                  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 байт

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

Досить прямолінійний підхід використовує str_pad для створення рядка пробілів необхідної довжини, замінює необхідні символи випадковими, а потім замінює будь-яку Ys (нечутливу до регістру) на Xs та повторює лінію.
Створює 2n + 3 повідомлення, але, як завжди, це добре.

Emacs Lisp, 269 байт

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

Невольф і трохи змінений:

(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 байти, збережені thx @Neil

Так громіздкий, напевно, не найкращий підхід. Бонус - він працює з непарним або парним введенням.

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 байт

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

Телефонуйте f()за розміром, xщоб намалювати.

Матриці , 79 байт (неконкурентні)

MAtricks Excels як початок роблячи й і все випадкові величини, але провалів , коли справа доходить до умовних ...

Я зазначив це як неконкурентоспроможне, тому що мені довелося виправити кілька помилок і отримати всі нові функції, що працюють після публікації цього виклику.

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

Бігайте з python matricks.py x.txt [[]] <input> --asciiprint

Пояснення:

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

Це також підтримує парні числа.

Python 2, 204 191 183 байт

Гаразд, конкуренція Python тут стає жорсткою. Ось моя спроба збрити якомога більше байтів. На даний момент я застряг (Ок, знову застряг).

Кредити @NonlinearFruit за спосіб вибору випадкових символів.

183-байтна версія:

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)

Спробуйте в Інтернеті! (Ідеон)

Основна зміна - переписати умовне

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

як

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

що зберігає 7 байт.

Версія 191 байт:

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)

Спробуйте в Інтернеті! (Ідеон)

Основні зміни - спосіб вибору випадкових символів та деяка перестановка коду, наприклад, s=input();i=s;перетворення s=i=input();, видалення r=rangeзавдання, оскільки воно більше не потрібно, та викликabs безпосередньо, оскільки це призводить до меншої кількості байтів коду.

Побиття попередньої найкоротшої відповіді в Python на 1 байт! @R. Підхід Капа використовується для генерації випадкових символів. Друкується кожна ітерація циклу while ряду колишнього.

204-байтна версія :

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)

Спробуйте в Інтернеті! (Ідеон)

Версія Ungolfed, щоб отримати уявлення про те, як вона працює:

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 символу!

SmileBASIC, 97 байт

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

Замість того, щоб обчислювати кількість пробілів між кожним символом чи чимось, я вирішив просто надрукувати у всіх місцях, де X==Yабо X+Y==Size+1.
Генератор випадкових символів просто додає 1, якщо він генерує yабо Y, так, zі Zє дещо частіше, ніж зазвичай.

PHP, 100 байт

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

приймає вхід з аргументу командного рядка; бігати з -nr.

комбінований цикл друкує символи залежно від положення

зламатися

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