Нарисуй большую косую черту X

21

Учитывая неотрицательное целое число, распечатайте это, Xкоторое является большим. Xявляется выходом для ввода 0, и вы добавите косые черты, равные вводу в каждом направлении, чтобы расширить Xдля более крупных входов.

Тестовые случаи

0

X

1

\ /
 X
/ \

2

\   /
 \ /
  X
 / \
/   \

...

10

\                   /
 \                 /
  \               /
   \             /
    \           /
     \         /
      \       /
       \     /
        \   /
         \ /
          X
         / \
        /   \
       /     \
      /       \
     /         \
    /           \
   /             \
  /               \
 /                 \
/                   \

правила

Вы можете либо распечатать вывод, либо вернуть строку или список строк из функции. Разрешается использовать завершающий символ новой строки, а также дополнительные внутренние пробелы, которые не влияют на отображение.

Это код-гольф , поэтому выигрывает самый короткий ответ в байтах!

code-golf  ascii-art 
— Стивен
источник
— Стивен
6
... Я просто подожду 1-байтового решения для угля.
— Утренняя монахиня
@LeakyNun Я был бы удивлен, если бы Древесный уголь мог легко иметь дело с Xсерединой (часть того, почему я добавил это), но кто знает: D
— Стивен
— Value Ink
— xnor

Ответы:

6

Холст , 3 байта

╵＼┼

Попробуй это здесь!

половина размера угольного ответа: D

╵    increment the input
 \   create a diagonal that long
  ┼  and quad-palindromize, mirroring what's required, with 1 overlap;
     This overlaps the `/` and `\`, resulting in `X`
— dzaima
источник
Черт, это коротко.
— dylnan
: ||||||| +1 для игры в гольф
— только ASCII
также мне интересно, если языки на основе стека в основном всегда превосходят другие языки?
— Только для ASCII
@ ASCII-только желе
— Okx
@Okx * на основе стека / молчаливый
— только для ASCII
22

Древесный уголь , 6 байт

ＰX⁺¹ＮX

Ваша ерунда не останавливает меня;)

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

— Okx
источник
2
TIO выглядит ... интересно, когда вы
— Стивен
@StephenS Только из-за упаковки.
— Okx
Я знаю, просто интуитивно понятно, что все обернутые `выровнены по левому краю (потому что пробелы не оборачиваются)
— Стивен
5 символов (задание на постдат) только для того, чтобы немного приблизиться к Canvas
— только ASCII
16

JavaScript (ES6), 79 байт

Использует рекурсивную функцию g, которая проходит по сетке и строит вывод за символом.

n=>(g=x=>`/\\ X
`[~x?x-y?x+y-w&&2:x-n?1:3:4]+(~y?g(~x--?x:y--&&w):''))(y=w=n*2)

Как?

Обе переменные x и y выполняют итерацию от 2n до -1 , где n - это ввод.

Для каждой позиции (x, y) в сетке мы выбираем один из этих символов:

  • 0: /
  • 1: \
  • 2: пробел
  • 3: X
  • 4: новая строка

используя следующие тесты:

  • ~x: Ложь, если x == -1 : мы достигли конца строки.
  • x-y: Ложь, если x == y : мы находимся на анти-диагонали.
  • x+y-w: Ложь, если x + y == w : мы находимся на диагонали.
  • x-n: Ложь, если x == n : потому что этот тест выполняется только при x == y , это означает, что мы находимся в точном центре сетки.

и следующее дерево решений:

Древо решений

демонстрация

Показать фрагмент кода

— Arnauld
источник
4
Это ... JavaScript? Что случилось с тобой, старый друг.
— roberrrt-s
13

MATL , 16 байт

'\/X 'iEQXytEP+)

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

Рассмотрим ввод 2в качестве примера. Стек показан здесь вверх ногами, то есть нижние элементы - это те, которые были добавлены последними.

'\/X '  % Push this string
        %   STACK: '\/X '
iEQ     % Input a number, n. Multiply by 2, add 1: gives 2*n+1
        %   STACK: '\/X '
                   5
Xy      % Identity matrix of that size
        %   STACK: '\/X '
                   [1 0 0 0 0;
                    0 1 0 0 0;
                    0 0 1 0 0;
                    0 0 0 1 0;
                    0 0 0 0 1]
tEP     % Duplicate, multiply each entry by 2, flip vertically
        %   STACK: '\/X '
                   [1 0 0 0 0;
                    0 1 0 0 0;
                    0 0 1 0 0;
                    0 0 0 1 0;
                    0 0 0 0 1]
                   [0 0 0 0 2;
                    0 0 0 2 0;
                    0 0 2 0 0;
                    0 2 0 0 0;
                    2 0 0 0 0]
+       % Add the two matrices
        %   STACK: '\/X '
                   [1 0 0 0 2;
                    0 1 0 2 0;
                    0 0 3 0 0;
                    0 2 0 1 0;
                    2 0 0 0 1]
)       % Index into the string. Indexing is 1-based and modular, so 1 picks
        % the first character ('\'), ..., 0 picks the last (space)
        %   STACK: ['\   /';
                    ' \ / ';
                    '  X  ';
                    ' / \ ';
                    '/   \']
        % Implicit display
— Луис Мендо
источник
Я хотел сделать что-то подобное в Octave, но вы меня опередили, а в MATL он даже короче, чем Octave, так что отличная работа!
— Миштхан
@Michthan Спасибо! Стоит также опубликовать версию Octave. Моя попытка составляет 38 байт, а какая ваша?
— Луис Мендо
Я думал об этом все выходные и не мог найти более эффективный способ, чем тот, который вы используете здесь ... Так что все кредиты должны идти к вам для октавной версии.
— Миштхан
6

C 108 106 байтов

a;g(n){for(int b=2*n,i=1,c=47;a+=i;b?puts(""):(i=-i,c=92),b-=2*i)printf("%*c%*c",a,b?c+45*i:88,b,b?c:10);}

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

(-2 игра в гольф благодаря MD XF)

Он печатает два символа (сначала c = 47косая черта и c + 45обратная косая черта; затем они меняются местами) с шириной динамического поля.

Ширина полей начинается с 1и 2n, и на каждой итерации первая ширина увеличивается на 1, а вторая уменьшается на 2.

Когда ширина второго поля становится равной 0, он выводит 'X'и новую строку вместо обычных символов и меняет направление приращений ( i). Новая строка печатается для всех остальных строк отдельно ( puts("")).

— anatolyg
источник
106 байт: a,b,i=1,c;g(n){for(b=2*n,c=47;a+=i;b?puts(""):(i=-i,c=92),b-=2*i)printf("%*c%*c",a,b?c+45*i:88,b,b?c:10);} попробуйте онлайн!
— MD XF
Спасибо за идею! Я использовал только часть этого, чтобы убедиться, что код может быть вызван дважды.
— Анатолий
5

shortC , 111 байт

s(x){Wx--)R" ")}j;f(x){O;j<x;j++)s(j),P92),s((x-j)*2-1),R"/\n");s(x);R"X\n");Wj--)s(j),P47),s((x-j)*2-1),R"\\\n

На основании моего C ответа . Конверсии:

  • R -> printf(
  • P -> putchar(
  • W -> while(
  • O -> for(
  • Автоматически вставленное закрытие ");}

Это также использует коды ASCII для \и /.

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

— MD XF
источник
5

C 168 155 150 байт

-5 благодаря компутронию

#define p printf(
s(x){while(x--)p" ");}j;f(x){for(;j<x;j++)s(j),p"\\"),s((x-j)*2-1),p"/\n");s(x);p"X\n");while(j--)s(j),p"/"),s((x-j)*2-1),p"\\\n");}

Конечно, можно играть в гольф; Я делаю так. Попробуйте онлайн!

Ungolfed:

int space(int x)
{
    while (x--)
        putchar(' ');
}

int f(int x)
{
    for (int j = 0; j < x; j++) {
        space(j);
        printf("\\");
        space((x-j)*2-1);
        printf("/\n");
    }

    space(x);
    puts("X");

    while (j--) {
        space(j);
        putchar('/');
        space((x-j)*2-1);
        printf("\\\n");
    }
}
— MD XF
источник
2
Вы можете потерять 5 символов, определив p как «printf (» вместо «printf».
— Computronium
3

V , 21 байт

éXÀñ>HÄÒ r\Á/YGpr/$r\

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

HexDump:

00000000: e958 c0f1 3e48 c4d2 2072 5cc1 2f59 4770  .X..>H.. r\./YGp
00000010: 722f 2472 5c                             r/$r\

Объяснение:

éX                      " Insert an 'X'
  Àñ                    " Arg1 times:
    >H                  "   Add a space to every line.
                        "   Conveniently, this also puts us on the first line
      Ä                 "   Duplicate this line
       Ò                "   And replace the whole line with spaces
         r\             "   Replace the first char with '\'
           Á/           "   Append a '/' char
             Y          "   Yank this line
              G         "   Move to the last line
               p        "   And paste the line we yanked
                r/      "   Replace the first character with a '/'
                  $     "   Move to the end of the line
                   r\   "   And replace the last character with a '\'

По сути, у нас есть Вставка X, n раз расширить косую черту .

Но это не так просто, потому что мы также должны добавлять слэши в первый раз. Если косые черты уже были, мы могли бы написать расширение косых черт как:

>HÄX2pGÙX2p

Что бы сэкономить нам 6 байтов.

— DJMcMayhem
источник
3

C #, 157 122 120 байт

_=d=>"".PadLeft(d)
a=>{var s=_(a)+"X\n";for(int i=0;++i<=a;)s=$@"{_(a-i)}\{_(i*2-1)}/
{s+_(a-i)}/{_(i*2-1)}\
";return s;}

Безголовая версия: 

 Func<int, string> _ = (d) =>"".PadLeft(d);
        Func<int, string> func = a => {

            var s = _(a) + "X\n";

            for (int i = 0; ++i <= a;) {

                s = $@"{_(a - i)}\{_(i * 2 - 1)}/
{s + _(a - i)}/{_(i * 2 - 1)}\
";

            }
            return s;
        };
— LiefdeWen
источник
1
Вы можете переместить другую анонимную функцию из первой, а затем включить ее как _=d=>new string(' ',d);(обратите внимание, что в скобках нет необходимости d). Вы можете удалить фигурные скобки вокруг цикла. Используйте дословную строку с таким образом, чтобы вам не нужно было избегать обратной косой черты. Если вы установите, i=0то вы можете сделать ++i<a+1и удалить i++.
— TheLethalCoder
Также с дословными строками вам не нужно включать \nфактический перевод строки, но я не уверен, что если вы сможете удалить скобки вокруг цикла for, вам придется попробовать.
— TheLethalCoder
1
После применения первого предложения TheLethalCoder вы также можете заменить ++i<a+1на ++i<=a EDIT. Вы также можете сохранить еще 4 байта, изменив значение Funcс new string(' ',d)на"".PadLeft(d)
— auhmaan
Спасибо за предложения, @TheLethalCoder. Разрешено ли мне объявлять 2 такие функции, разве это не уменьшит возможности игры в C #, если мы сможем это сделать?
— LiefdeWen
1
@StefanDelport Мета-обсуждение где-то есть, но в его нынешнем виде я верю, что вы можете, пока вы показываете имя функции. В этом случае _.
— TheLethalCoder
3

Mathematica, 71 байт

(Частично вдохновлено 104-байтовым решением Jenny_mathy)

""<>#&/@(#"\\"+Reverse@#"/"&@IdentityMatrix[2#+1]/.{0->" ",a_+_->"X"})&

Возвращает список строк.

Пояснение: IdentityMatrix[2#+1]делает матрицу правильного размера с 1 с по диагонали и 0 с в другом месте. Затем мы умножаем его на "\\"(экранированный обратный слеш), что делает его матрицей с обратным слешем по диагонали и 0 в другом месте, поскольку, конечно, 1 раз обратный слеш является "/"обратным слешем, а 0 раз обратным слешем равен 0. Мы добавляем это к разам, обратным для форма Х Мы почти закончили, за исключением того, что по-прежнему везде 0, а середина есть "\\" + "/". Зафиксируем эти две вещи, заменив " "на 0и "X"на a_+_, что соответствует любой сумме двух вещей (например , _+_следует, кроме Mathematica слишком умна для своего собственного блага , и трактует , что в 2 раза _). Наконец, ""<>#&/@превращает это в список строк.

— Не дерево
источник
3

Java (OpenJDK 8) , 135 байт

i->{int k=0,j,l=2*i+1;String[]s=new String[l];for(;k<l;k++)for(s[k]="",j=0;j<l;j++)s[k]+=j==k?j==i?"X":"\\":j==l-1-k?"/":" ";return s;}

Лямбда-выражение, которое принимает целое число и возвращает массив строк

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

Ungolfed:

i->{
    int k=0,j,l=2*i+1;                // Some variables to be used
    String[]s=new String[l];            // Return array (size 2*i+1)
    for(;k<l;k++)                       // For each array entry
        for(s[k]="",j=0;j<l;j++)        // Set each character to 
            s[k]+=j==k?j==i?"X":"\\"    // \ or X if it's the jth character of the jth row
                 :j==l-1-k?"/"          // / if it's the opposite char
                 :" ";                  // else blank
    return s;
}
— PunPun1000
источник
3

T-SQL, 201 байт

DECLARE @ INT SELECT @=a FROM t DECLARE @i INT=@
WHILE @>0BEGIN PRINT SPACE(@i-@)+'\'+SPACE(2*@-1)+'/'SET @-=1 END
PRINT SPACE(@i)+'X'WHILE @<@i BEGIN SET @+=1 PRINT SPACE(@i-@)+'/'+SPACE(2*@-1)+'\'END

отформатирован:

DECLARE @ INT 
SELECT @=a FROM t 
DECLARE @i INT=@
WHILE @>0
    BEGIN
        PRINT SPACE(@i-@)+'\'+SPACE(2*@-1)+'/'
        SET @-=1 
    END
PRINT SPACE(@i)+'X'
WHILE @<@i 
    BEGIN 
        SET @+=1 
        PRINT SPACE(@i-@)+'/'+SPACE(2*@-1)+'\'
    END

Ввод осуществляется через колонки а в имени таблицы т , согласно нашим правилам .

— BradC
источник
3

Рубин , 66 байт

Рекурсивная функция.

f=->x{?X[x]||"\\#{s=' '*(2*x-1)}/
#{f[x-1].gsub /^/,' '}
/#{s}\\"}

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

объяснение

f=->x{                  # Start of recursive function named `f`
      ?X[x]||           # Return 'X' if x==0, otherwise the following:
"\\#{s=' '*(2x-1)}/     #  Top edge of the cross. Save no. of spaces needed
#{f[x-1]                #  Get result of f[x-1]
        .gsub /^/,' '}  #  Regex sub to left-pad every line w/ a space
/#{s}\\"                #  Bottom edge of cross (insert saved no. of spaces)
— Значение чернил
источник
3

Желе , 24 17 байт

Ḥ‘=þ`µḤ+Uị“/\x ”Y

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

Как это устроено

Ḥ‘=þ`µḤ+Uị“/\x ”Y   main link, input a
Ḥ‘                  input doubled and incremented
   þ                Make a table: Apply  
  =                 "equals"/ to      
    `               each element in range(2a+1) cartesian multiplied with itself.
                      eg. For input 1: [1=1,1=2,1=3],[2=1,2=2,2=3],[3=1,3=2,3=3]      
     µ              on this array:
       +            add: 
      Ḥ             double of it to
        U           its reverse (changes south-east to north-west)
         ị“/\x ”    index into the string "/\x " to get the right characters
                Y   join by newlines for the final output.

-6 байт благодаря @LeakyNun и -1 байт с дополнительным улучшением

— fireflame241
источник
— Утренняя монахиня
2

Пакет, 201 байт

@echo off
set s= /
for /l %%i in (2,1,%1)do call set s=  %%s%%
set s=\%s%
for /l %%i in (-%1,1,%1)do call:c
exit/b
:c
echo %s%
set s=%s:\ = \%
set s=%s:X =/\%
set s=%s:\/=X %
set s=%s: /=/ %

Начинается с построения верхней строки, затем после печати каждой строки перемещается \вправо на один пробел и /влево на один пробел, следя за тем, чтобы они были Xпосередине.

— Нил
источник
2

Сетчатка , 74 байта

.+
$* X
+`^ ( *).( *)
$1\  $2/¶$&
+`¶ ( *).( *).?$
$&¶$1/  $2\
m` (\W)$
$1

Попробуйте онлайн!Объяснение:

.+
$* X

Поместите X .

+`^ ( *).( *)
$1\  $2/¶$&

Начиная с X, вверх, \ставьте каждый раз по диагонали влево. Также поместите/ два пробела после, /чем в прошлый раз.

+`¶ ( *).( *).?$
$&¶$1/  $2\

Начиная с X, работая вниз, /каждый раз располагайте по диагонали влево. Также поместите еще \два пробела после/ чем в прошлый раз.

m` (\W)$
$1

Количество пробелов между двумя диагоналями должно быть нечетным, поэтому последний пробел в каждой строке (кроме исходной Xстроки) удаляется.

— Нил
источник
2

Mathematica, 131 байт

(F[x_,y_]:=Table[x<>StringJoin@Table[" ",i]<>y,{i,1,#*2,2}];Column[Join[Reverse@F["\\","/"],{"X"},F["/","\\"]],Alignment->Center])&


Mathematica, 104 байта

вот еще один подход с использованием сетки 

(S=DiagonalMatrix[Table["\\",r=2#+1]];Table[S[[r+1-i,0+i]]="/",{i,r}];S[[#+1,#+1]]="X";Grid@S/. 0->" ")&
— J42161217
источник
2

APL (Дьялог) , 25 байт

Требуется ⎕IO←0по умолчанию во многих системах.

' \/X'[(⊢+2×⌽)∘.=⍨⍳1+2×⎕]

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

' \/'[...]  индексировать строку с

 ⎕ получить вход

 2× умножить на два

 1+ добавить одну

 ⍳ чем много целых чисел

 ∘.=⍨ таблица равенства (т.е. единичная матрица; диагональ NW-SE)

 (...)  Применить следующую молчаливую функцию к этому

  ⊢ Аргумент

  + плюс

  2× два раза

  ⌽ зеркально отраженный аргумент (то есть диагональ NE-SW)

— Адам
источник
2

Баш , 138 байт

for i in `seq $1;seq $[$1-1] -1 1`
{ $[a++]
printf "%*c%*s\n" `echo ' '$i $[a>$1?1:2] $[($1-i)*2]' '$[a<$1?1:2]`
}|sed 's/22/X/'|tr 12 /\\

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

Действительно долго, bash нагревает '\ and /'

Меньше гольфа

 for i in {1..10} {9..1};{
   $[a++];                      #argument as padding, prints 1 for \ and 2 for /
   printf "%*c%*s\n" `echo ' '$i $[a>$1?1:2] $[($1-i)*2]' '$[a<$1?1:2]`;
  }|sed 's/22/X/g' | tr 12 /\\
— marcosm
источник
1

Perl 5, 110 + 1 = 111 байт

Использует -nфлаг.

$x=$_;$,="\n";push@x,$"x($x-$_)."\\".$"x(2*--$_+1)."/"while$_>0;say@x,$"x$x."x";for(reverse@x){y!\\/!/\\!;say}
— Крис
источник
1

QBIC , 90 байт

~b=0|?@X`\[0,:-1|X=space$(a)┘Z=Z+X+@\`+space$((b-a)*2-1)+@/`+X+@┘`]Z=Z+space$(b)+A+_fZ

Как работает это чудовище, оставлено в качестве упражнения для читателя ...

Пример вывода:

Command line: 3
\     /
 \   / 
  \ /  
   X
  / \  
 /   \ 
/     \
— steenbergh
источник
1

Visual Basic.Net , 454 450 байт

Option Strict Off
module m
sub main(a As String())
dim v=Convert.toInt32(a(0))
for i as Integer=v to 1 step -1
for j as Object=1 to v-i
w(" ")
next
w("\")
for j as Object=1 to i*2-1
w(" ")
next
console.writeline("/")
next
console.writeline(new String(" ",v)&"X")
for i as Object=1 to v
for j as Object=1 to v-i
w(" ")
next
w("/")
for j as Object=1 to i*2-1
w(" ")
next
console.writeline("\")
next
end sub
sub w(s)
console.write(s)
end Sub
end module

не уверен, writelineсэкономит ли создание функции for несколько байтов, спасибо Стивену S за указание на as ...удаление, также измененный integerв object последнее изменение, измененный первый назад

— polyglotrealIknow
источник
Вы смелый человек :) Я думаю, что вы можете удалить все as Types, потому что, если у вас есть Option Strict Off, VB.NET действует как свободно типизированный язык.
— Стивен
В настоящее время на Linux моно раздражает
— polyglotrealIknow
mono не волнует Option Strict, или, по крайней мере, так я думаю
— polyglotrealIknow
О, это казалось functions ! = for loops Спасибо за гольф
— polyglotrealIknow
Не Option Strictвыключен по умолчанию? Это как минимум в Visual Studio
— Стивен
1

05AB1E , 22 байта

F'\IN-úR.∞})Âí'Xs)˜.c»

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

объяснение

F                        # for N in [0...input-1] do
 '\                      # push a backslash
   IN-ú                  # prepend input-N spaces
       R                 # reverse
        .∞               # mirror
          }              # end loop
           )             # wrap stack in a list
            Â            # bifurcate
             í           # reverse each item
              'Xs        # push an "X" between the 2 lists on the stack
                 )˜      # wrap in flattened list
                   .c    # pad lines to equal length
                     »   # join on newlines

Альтернативное 22-байтовое решение

F'\N·>ú'/ì})Âí'X¸«ì.c»
— Emigna
источник
1

tcl, 134

proc P {x s b} {time {puts [format %[incr ::i $x]s%[expr ($::n-$::i)*2+2]s $s $b]} $::n}
P 1 \\ /
puts [format %[incr i]s X]
P -1 / \\

демонстрация

Установить nна первой строке.

Может быть, я могу играть в гольф больше, используя рекурсивный подход

— sergiol
источник
1

R , 75 72 байта

y=diag(b<-2*scan()+1);write(c(" ",'\\','/','X')[y+2*y[,b:1]+1],'',b,,'')

Вдохновленный этим ответом , генерирует неявную матрицу и записывает ее в стандартный вывод; читает размер из стандартного ввода. Он должен построить матрицу из пробелов и использует sep=''b / c, в противном случае он имеет проблемы с пробелами.

diag(b)                     # generates a main diagonal of 1, rest 0
2*diag(b)[,b:1]             # the other diagonal is 2
                            # [,b:1] reverses columns
                            # [b:1,] reverses the rows; they're equivalent
diag(b)+2*diag(b)[,b:1]     # sums, so we get 1 for main diagonal
                            # 2 for other diagonal, 3 for center
diag(b)+2*diag(b)[,b:1]+1   # add 1 since R is 1-indexed
                            # the result is indices for the vector
c(' ','\\','/','X')

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

— Giuseppe
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.