Вам будет дано положительное целое число в Nкачестве входных данных. Ваша задача - построить полу-зигзаг из Nсторон, каждой длины N. Поскольку довольно сложно четко описать задачу, вот несколько примеров:

• N = 1:

  О
  

• N = 2:

  О
   OO
  

• N = 3:

  OO
   OO
    ООО
  

• N = 4:

  OOOOO
   OO
    OO
     ОООО
  

• N = 5:

  OOOOOO
   ООО
    ООО
     ООО
      OOOOOO
  

• N = 6:

  ООООООО
   ООО
    ООО
     ООО
      ООО
       OOOOOOOOOOOO
  

• N = 7:

  OOOOOOOOO
   ОООО
    ОООО
     ОООО
      ОООО
       ОООО
        OOOOOOOOOOOOOO
  

• Большой тестовый набор с N = 9

Как вы можете видеть, полузигзаг состоит из чередующихся диагональных и горизонтальных линий, и он всегда начинается с диагональной линии слева направо сверху вниз. Обратите внимание, что символы на горизонтальных линиях разделены пробелом.

правила

• Вы можете выбрать любой непробельный символ вместо O, он может даже быть непоследовательным.

• Вы можете вывести / вернуть результат в виде строки или в виде списка строк, каждая из которых представляет одну строку .

• У вас может быть завершающий или ведущий символ новой строки.

• Применяются стандартные лазейки .

• Вы можете принимать входные данные и предоставлять выходные данные любым стандартным способом .

• Если возможно, пожалуйста, добавьте ссылку на тестирование в ваше сообщение. Я буду приветствовать любой ответ, который показывает усилия в гольф и имеет объяснение.

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

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

ＦＮ«↶§7117ι×⁺#× ﹪ι²⁻Ｉθ¹»#

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

-5 спасибо Нейлу .

АСТ:

Program
├Ｆ: For
│├Ｎ: Input number
│└Program
│ ├↶: Pivot Left
│ │└§: At index
│ │ ├'7117': String '7117'
│ │ └ι: Identifier ι
│ └Print
│  └×: Product
│   ├⁺: Sum
│   │├'#': String '#'
│   │└×: Product
│   │ ├' ': String ' '
│   │ └﹪: Modulo
│   │  ├ι: Identifier ι
│   │  └2: Number 2
│   └⁻: Difference
│    ├Ｉ: Cast
│    │└θ: Identifier θ
│    └1: Number 1
└Print
 └'#': String '#'

Python 2 , 157 153 байта

n=input()
o,s=q='O '
def p(k,t=q*n+s*(4*n-6)):print(t*n)[k*~-n:][:n*3/2*~-n+1]
p(2)
for i in range(n-2):p(0,i*s+s+o+s*(4*n-7-2*i)+o+s*(2*n+i-2))
n>1>p(5)

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

• n*3/2*~-n+1 ширина каждой строки: n3n / 2⌋ · (n − 1) + 1 символ.
• Строка q*n+s*(4*n-6)представляет верхнюю и нижнюю строки. Если мы повторим это и нарежем, [2*(n-1):]мы получим верхний ряд; если мы нарезаем, [5*(n-1):]мы получаем нижний ряд. Отсюда и определение pи призывы к p(2)и p(5). Но так как нам все равно нужны повторение и разрезание по длине строки для всех других строк, мы снова используем pв цикле.
• Это i*s+s+o+…просто скучное выражение для средних рядов.
• n>1>p(5)будет короткое замыкание, если n≯1, не вызывая p(5)оценки. Следовательно, это сокращение для if n>1:p(5).

Mathematica, 126 125 121 112 104 89 86 байт

(m=" "&~Array~{#,#^2-#+1};Do[m[[1[i,#,-i][[j~Mod~4]],j#-#+i+1-j]]="X",{j,#},{i,#}];m)&

• #номер входа для анонимной функции (завершается финалом &).
• m=" "&~Array~{#,#^2-#+1};создает матрицу пространственных символов правильного размера, заполняя массив заданных измерений #,#^2-#+1выходными данными постоянной анонимной функции «вывести пробел» " "&.
• Do[foo,{j,#},{i,#}]представляет собой пару вложенных циклов делать, где jдиапазоны от 1к #и внутри этого iдиапазона от 1до #.
• m[[1[i,#,-i][[j~Mod~4]],j#-#+i+1-j]]="X"устанавливает соответствующую часть матрицы как символ Xна основе jи i. -iИспользует отрицательную индексацию , чтобы сохранить байты из #-i+1. (Я забыл написать, Mod[j,4]как j~Mod~4в оригинальной версии этого кода.) Jenny_mathy указала, что мы можем использовать модульный остаток для индексации в списке напрямую (а не использовать Switch) для сохранения 9 байтов, а JungHwan Min отметил, что мы не ' не нужно использовать, ReplacePartтак как мы можем установить часть массива, которая 1[i,#,-i][[j~Mod~4]]использует странное поведение и общность [[foo]]для сохранения байтов{1,i,#,-i}[[j~Mod~4+1]]
• Так как мета установила, что список символов является строкой (как указал JungHwan Min ), нам не нужно отображать какие-либо функции по строкам матрицы символов, поскольку это уже список «строк».

Вы можете проверить это в изолированной программной среде Wolfram Cloud , вставив код, подобный следующему, и нажав Shift + Enter или цифровую клавишу Enter:

(m=" "&~Array~{#,#^2-#+1};Do[m[[1[i,#,-i][[j~Mod~4]],j#-#+i+1-j]]="X",{j,#},{i,#}];m)&@9//MatrixForm

C ++, 321 234 байта

-87 байт благодаря Захари

#include<vector>
#include<string>
auto z(int n){std::vector<std::string>l;l.resize(n,std::string(n*n+n/2*(n-1),32));l[0][0]=79;int i=0,j,o=0;for(;i<n;++i)for(j=1;j<n;++j)l[i%4?i%4-1?i%4-2?0:n-j-1:n-1:j][i*n+j-i+(o+=i%2)]=79;return l;}

Возвращает вектор строк

Mathematica, 179 байтов

Rotate[(c=Column)@(t=Table)[{c@(a=Array)[" "~t~#<>(v="o")&,z,0],c@t[t[" ",z-1]<>v,z-1],c@a[t[" ",z-2-#]<>v&,z-1,0],c@t[v,z-Boole[!#~Mod~4<1]-1]}[[i~Mod~4+1]],{i,0,(z=#)-1}],Pi/2]&

редактировать для @JungHwanMin

05AB1E , 21 20 19 байтов

Код

Использует новый режим холста:

Fx<)Nè'ONÉúR3212NèΛ

Использует кодировку 05AB1E . Попробуйте онлайн!

Объяснение:

F                      # For N in range(0, input)
 x<)                   #   Push the array [input, 2 × input - 1]
    Nè                 #   Retrieve the Nth element
      'ONÉúR           #   Push "O" if N is odd, else "O "
            3212Nè     #   Retrieve the Nth element of 3212
                  Λ    #   Write to canvas

Для ввода 6 это дает следующие аргументы (в том же порядке) для холста:

[<num>, <fill>, <patt>]
[6,     'O',     3]
[11,    'O ',    2]
[6,     'O',     1]
[11,    'O ',    2]
[6,     'O',     3]
[11,    'O ',    2]

Чтобы объяснить, что делает холст, мы выбираем первый набор аргументов из списка выше.

Число 6 определяет длину строки, которая будет записана на холсте. Наполнитель используется для записи на холсте, который в данном случае является O. Он циклически проходит через строку наполнителя. Направление строки определяется последним аргументом, направлением. Направления:

7  0  1
 \ | /
6- X -2
 / | \
5  4  3

Это означает, что 3 устанавливает направление на юго-восток , что также можно попробовать онлайн .

SOGL V0.12 , 36 байт

╝.H∫2\?.╝}F2%?№@.┌Ο};1w⁄Hh1ž}.4%1>?№

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

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

╝                                     get a diagonal from the bottom-left corner with the length of the input - the starting canvas
 .H∫                        }         for each number in the range [1,inp-1] do, pushing counter
    2\?  }                              if it divides by 2, then
       .╝                                 create another diagonal of the input
          F2%                           push counter % 2
             ?     }                    if that [is not 0]
              №                           reverse the current canvas upside down
               @.┌Ο                       get an alternation of spaces and dashes with the dash amount of the input length
                    ;                   get the canvas on top of the stack
                     1w⁄                get its 1st element length
                        H               decrease it
                         h              swap the bottom 2 items - the canvas is now at the bottom and the current addition ontop
                          1             push 1
                           ž            at 1-indexed coordinates [canvasWidth-1, 1] in the canvas insert the current part made by the Ifs
                             .4%1>?   if input%4 > 1
                                   №    reverse the array vertically

Если ввод 1 не разрешен, то ο.∫2%?.╝}F2\?№@.┌Ο};1w⁄Hh1ž}.4%1>?№тоже будет работать. Если бы случайные числа с плавающей точкой были разрешены, .∫2%?.╝}F2\?№@.┌Ο};1w⁄Hh1ž}.4%1>?№это тоже сработало бы. Если бы я не ленился и не реализовал ‼, }F2%?можно было бы заменить ‼на -4 байта

Mathematica, 106 87 байтов

SparseArray[j=i=1;k=#-1;Array[{j+=Im@i;k∣#&&(i*=I);j,#+1}->"o"&,l=k#+1,0],{#,l}," "]&

Возвращает SparseArrayобъект Strings. Чтобы визуализировать вывод, вы можете добавить Grid@. Выдает ошибку для случая 1, но это безопасно игнорировать.

объяснение

j=i=1

Установите iи j1.

k=#-1

Установите kдля ввода - 1.

l=k#+1

Установите lнаk*input + 1

Array[ ..., l= ...,0]

Итерируйте lвремя, начиная с 0, увеличивая 1каждый раз ...

j+=Im@i

Добавьте мнимый компонент iк j...

k∣#&&(i*=I)

Если текущая итерация делится на k, умножьте iна мнимую единицу ...

{... j,#+1}->"o"

Создайте Ruleобъект, который меняет элемент в позиции {j, current iteration + 1}на"o"

SparseArray[ ...,{#,l}," "]

Создайте SparseArrayобъект, используя сгенерированные Ruleобъекты, с измерением {input, l}, используя " "как пустое.

Попробуйте это на Wolfram Sandbox!

Python 3 , 228 226 224 215 197 195 байт

-11 байт благодаря @Mr. Xcoder

-2 байта благодаря @Mr. Xcoder

def f(n,s=range):
 x=y=t=c=0;z=[]
 for i in s(n*n-n+2):c+=i%(n-(2<=n))<1;z+=[[x,y]];t=max(t,x);x+=2-c%2;y+=[-1,1][c%4<3]*(c%2)
 return'\n'.join(''.join(' O'[[k,j]in z]for k in s(t))for j in s(n))

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

Пояснение и менее понятный код:

def f(n):
 x=y=t=c=0;z=[]                       #initialize everything
 for i in range(n*n-n+2):             #loop n*n-n+2 times which is the numberr of 'o's expected
    c+=i%[~-n,n]<n-1                  #if one cycle has been completed, increase c by 1, if n>1.                                            
    z+=[[x,y]]                        #add [x,y] to z(record the positions of 'o')
    t=max(t,x)                        #trap maximum value of x-coordinate(to be used later while calculatng whole string)
    r=[[2,0],[1,1],[2,0],[1,-1]][c%4] #r gives direction for x and y to move, adjust it as per c i.e. cycles
    x+=r[0];y+=r[1]                   #yield newer values of x and y 
 return '\n'.join(''.join(' o'[[k,j]in z]for k in range(t))for j in range(n)) #place space or 'o' accordingly as per the recorded posititons in z

Haskell , 197 байт

a n c=take(2*n)$cycle$c:" "
r i n x y=take(div(3*n)2*(n-1)+1)$(' '<$[1..i])++(cycle$"O "++(a(2*n-i-3)y)++"O "++(a(n+i-2)x))
z n=take n$(r 0 n 'O' ' '):[r i n ' ' ' '|i<-[1..n-2]]++[r(n-1)n ' ' 'O']

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

Благодаря @Lynn: исправлены пробелы между Os на горизонтальных сегментах зигзага, но это стоит много байтов!

Некоторые объяснения:

• rстрока вывода: она имеет 0 y y y y y 0 x x x 0 y ...формат, количество xи в yзависимости от строки и начальногоn
• для верхнего ряда x='0'иy=' '
• для средних рядов x=' 'иy=' '
• для нижнего ряда x=' 'иy='0'
• take(div(3*n)2*(n-1)+1) режет бесконечный ряд в нужном месте
• каждый вывод имеет одну верхнюю строку и одну нижнюю строку, за исключением случаев, когда n=1: take nобрабатывает этот случай.

Python 2 , 155 151 146 137 байт

m=input()
n=m-1
r=range(n+2)
for L in zip(*[' '*i+'O'+n*' 'for i in(r+[n,m]*~-n+r[-2::-1]+([m,0]*n)[:-1])*m][:1+3*m/2*n]):print''.join(L)

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