Обычно говорят, что «Делать X без Y» может быть ловушкой для начинающих, пишущих задачи ( источник ). Тем не менее, я дерзкий и думаю , что я могу определенно сделать X без Ys. Случайным образом. О да, это будет хорошо.

Задача: Учитывая нечетное целое число, nбольшее или равное 1, выведите ex длины стороны, 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-р \! \ ~ "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

Попробуйте онлайн!

Mathematica, 146 байт

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

Анонимная функция. Принимает число в качестве ввода и возвращает строку в качестве вывода.

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

РЕДАКТИРОВАТЬ: Спасибо Морган Трепп за исправления.

Python, 142 139 135 байтов

Это прямая реализация создания квадратного символа за символом. Если символ находится по диагонали : используйте случайный символ, иначе : используйте пробел. Это также использует подстановку регулярных выражений и случайное 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] Изменен на одиночный цикл for
• -6 [16-07-29] Обменялась ли инструкция для троичной операции. Благодаря @RootTwo
• -11 [16-07-27] Убрал лишние скобки / пробелы и перевернул оператор if
• -49 [16-07-27] Поглощаем метод @ squeamishossifrage, создавая шаг за шагом квадрат, Спасибо!
• -10 [16-07-27] Укоротить случайную лямбда-символ + математическое произведение от @ ConorO'Brien
• -22 [16-07-26] Скрип в лямбде + разный гольф
• -6 [16-07-26] import*- Спасибо @KevinLau

Дьялог АПЛ , 35 байт

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

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

TryAPL !

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)

Попробуйте онлайн! (Ideone)

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

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

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

Принимает ввод в качестве аргумента командной строки. Попробуйте онлайн!

объяснение

Строит сетку соответствующего размера; заменяет элементы на диагонали случайным не-y символом, а все остальные элементы - пробелом.

                                  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 для создания строки пробелов требуемой длины, заменяет необходимые символы случайными, а затем заменяет любые Y (без учета регистра) на X и выводит строку.
Создает 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 выделяется как начало создания x и всех случайных значений, но проваливается, когда дело доходит до условных выражений ...

Я отметил это как неконкурентоспособное, потому что мне пришлось исправить несколько ошибок и заставить все новые функции работать после того, как эта проблема была опубликована.

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)

Попробуйте онлайн! (Ideone)

Главное изменение - переписать условное

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

Попробуйте онлайн! (Ideone)

Основные изменения пути выбираются случайные символы и некоторый код перегруппировка , такие как s=input();i=s;стать s=i=input();, удаляя r=rangeзадание , как он больше не нужен , и вызывающиеabs непосредственно , как это приводит к меньшему количеству байт коды.

Превышение предыдущего кратчайшего ответа в Python на 1 байт! @Р. Подход Kap используется для генерации случайных символов. Каждая итерация цикла while выводит строку ex.

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)

Попробуйте онлайн! (Ideone)

Беззвучная версия, чтобы понять, как это работает:

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