Вызов:

Входные данные: положительное целое число$n$

Выход:

Создайте список в диапазоне и объедините его вместе в строку (т. Е. N = 13 будет строкой ).$[1,n]$$n=13$12345678910111213

Теперь мы выводим треугольник, используя префиксы или суффиксы этой строки, в одной из следующих четырех ориентаций на основе входного целого числа:

• Если $n\equiv 0\pmod 4$ , выведите его в форме треугольника ◣
• Если $n\equiv 1\pmod 4$ , выведите его в форме треугольника ◤
• Если $n\equiv 2\pmod 4$ , выведите его в форме треугольника ◥
• Если $n\equiv 3\pmod 4$ , выведите его в форме треугольника ◢

Пример:

Вход: $n=13$

Поскольку $13\equiv 1\pmod 4$ , форма будет ◤. Вот три возможных допустимых выхода:

12345678910111213    11111111111111111    12345678910111213
1234567891011121     2222222222222222     2345678910111213
123456789101112      333333333333333      345678910111213
12345678910111       44444444444444       45678910111213
1234567891011        5555555555555        5678910111213
123456789101         666666666666         678910111213
12345678910          77777777777          78910111213
1234567891           8888888888           8910111213
123456789            999999999            910111213
12345678             11111111             10111213
1234567              0000000              0111213
123456               111111               111213
12345                11111                11213
1234                 1111                 1213
123                  222                  213
12                   11                   13
1                    3                    3

Правила соревнований:

• Как видно из трех приведенных выше выходных данных, важна только правильная форма и использование всех цифр в правильном порядке . Кроме того, вы можете использовать префиксы или суффиксы; Неудачи / Отражает; диагональная печать; и т. д. и т. д. Допускается любой из шести возможных выходных данных для каждой фигуры (см. тестовый пример ниже, чтобы увидеть все действительные выходные данные на основе формы). Это позволяет использовать языки со встроенными вращениями, но те, у кого нет, также могут использовать альтернативный подход - использовать префиксы правильного размера сверху вниз или использовать префиксы для двух фигур, но суффиксы для двух других фигур. , Выбор большинства опций соответствующий выход для языка является частью процесса игры в гольф. :)
• Ввод гарантированно будет положительным целым числом. Для мы просто выводим .$n=1$1
• Допускается любое количество начальных / конечных новых строк / пробелов, если оно печатает правильный треугольник (без вертикальных или горизонтальных разделителей!) Где-нибудь на экране.

Основные правила:

• Это код-гольф , поэтому выигрывает самый короткий ответ в байтах.
  Не позволяйте языкам кода-гольфа отговаривать вас от публикации ответов на языках, не относящихся к кодексу. Попробуйте придумать как можно более короткий ответ для «любого» языка программирования.
• Стандартные правила применяются к вашему ответу с правилами ввода / вывода по умолчанию , поэтому вы можете использовать STDIN / STDOUT, функции / метод с правильными параметрами и типом возврата, полные программы. Ваш звонок.
• По умолчанию лазейки запрещены.
• Если возможно, добавьте ссылку с тестом для вашего кода (например, TIO ).
• Кроме того, добавление объяснения для вашего ответа настоятельно рекомендуется.

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

Вход: Все возможные действительные выходы:$n=5$

12345    54321    12345    54321    11111    55555
1234     5432     2345     4321     2222     4444
123      543      345      321      333      333
12       54       45       21       44       22
1        5        5        1        5        1

Вход: Все возможные выходы:$n=6$

123456    654321    123456    654321    111111    666666
 12345     65432     23456     54321     22222     55555
  1234      6543      3456      4321      3333      4444
   123       654       456       321       444       333
    12        65        56        21        55        22
     1         6         6         1         6         1

Вход: Все возможные выходы:$n=7$

      1          1          7          7          7          1
     12         21         67         76         66         22
    123        321        567        765        555        333
   1234       4321       4567       7654       4444       4444
  12345      54321      34567      76543      33333      55555
 123456     654321     234567     765432     222222     666666
1234567    7654321    1234567    7654321    1111111    7777777

Вход: Все возможные выходы:$n=8$

1           1           8           8           8           1
12          21          78          87          77          22
123         321         678         876         666         333
1234        4321        5678        8765        5555        4444
12345       54321       45678       87654       44444       55555
123456      654321      345678      876543      333333      666666
1234567     7654321     2345678     8765432     2222222     7777777
12345678    87654321    12345678    87654321    11111111    88888888

Вход: Только возможный выход:$n=1$

1

Вход: Все возможные выходы:$n=2$

12    21    12    21    11    22
 1     2     2     1     2     1

JavaScript (ES6),  93  89 байт

Возвращает матрицу символов.

n=>[...(g=n=>n?g(n-1)+n:'')(n)].map((d,y,a)=>a.map(_=>y-(n&2)*y--<0?' ':d)).sort(_=>-n%2)

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

Альтернативный рисунок (такого же размера):

n=>[...(g=n=>n?g(n-1)+n:'')(n)].map((_,y,a)=>a.map(d=>y-(n&2)*y--<0?' ':d)).sort(_=>-n%2)

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

комментарии

n =>                 // n = input
  [...               // split the result of ...
    ( g = n =>       //   ... a call to the recursive function g, taking n
      n ?            //     if n is not equal to 0:
        g(n - 1)     //       append the result of a recursive call with n - 1
        + n          //       append n
      :              //     else:
        ''           //       stop recursion and return an empty string
    )(n)             //   initial call to g
  ].map((d, y, a) => // for each digit d at position y in this array a[]:
    a.map(_ =>       //   for each character in a[]:
      y -            //     we test either y < 0 if (n AND 2) is not set
      (n & 2)        //     or -y < 0 (i.e. y > 0) if (n AND 2) is set
      * y-- < 0      //     and we decrement y afterwards
      ?              //     if the above condition is met:
        ' '          //       append a space
      :              //     else:
        d            //       append d
    )                //   end of inner map()
  )                  // end of outer map()
  .sort(_ => -n % 2) // reverse the rows if n is odd

Сводка по форме

Ниже приведена сводка базовой формы (генерируемой вложенными mapциклами) и окончательной формы (после sort) для каждого :$n\bmod 4$

 n mod 4  | 0     | 1     | 2     | 3
----------+-------+-------+-------+-------
 n & 2    | 0     | 0     | 2     | 2
----------+-------+-------+-------+-------
 test     | y < 0 | y < 0 | y > 0 | y > 0
----------+-------+-------+-------+-------
 base     | #.... | #.... | ##### | #####
 shape    | ##... | ##... | .#### | .####
          | ###.. | ###.. | ..### | ..###
          | ####. | ####. | ...## | ...##
          | ##### | ##### | ....# | ....#
----------+-------+-------+-------+-------
 n % 2    | 0     | 1     | 0     | 1
----------+-------+-------+-------+-------
 reverse? | no    | yes   | no    | yes
----------+-------+-------+-------+-------
 final    | #.... | ##### | ##### | ....#
 shape    | ##... | ####. | .#### | ...##
          | ###.. | ###.. | ..### | ..###
          | ####. | ##... | ...## | .####
          | ##### | #.... | ....# | #####

Python 2 , 94 байта

n=0;s=''
exec"n+=1;s+=`n`;"*input()
K=k=len(s)
while k:k-=1;print s[k^n/-2%-2:].rjust(n%4/2*K)

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

Japt , 8 байт

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

õ ¬å+ zU

Попытайся

Сохранено 2 байта благодаря Кевину .

õ ¬å+ zU     :Implicit input of integer U
õ            :Range [1,U]
  ¬          :Join to a string
   å+        :Cumulatively reduce by concatenation
      zU     :Rotate clockwise by 90 degrees U times

Холст , 8 байт

ŗ］∑［］⁸［↷

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

Perl 6 , 94 байта

{[o](|(&reverse xx$_/2+.5),|(*>>.flip xx$_/2+1))([\~](my@a=[~](1..$_).comb)>>.fmt("%{+@a}s"))}

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

Блок анонимного кода, который принимает число и возвращает список строк.

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

Ｎθ≔⭆θ⊕ιηＧLＬηη⟲⊗θ‖

Попробуйте онлайн! Ссылка на подробную версию кода. Объяснение:

Ｎθ

Вход n.

≔⭆θ⊕ιη

Создайте строку, объединяя числа 1в n.

ＧLＬηη

Заполните треугольник этой длины строкой.

⟲⊗θ

Поверните треугольник против часовой стрелки на несколько n*90градусов.

‖

Отразите все, таким образом заканчивая треугольником, который повернут по часовой стрелке на n*90градусы.

C # (интерактивный компилятор Visual C #) , 128 байт

n=>{var s="";int i=0,j,p;for(;i<n;s+=++i);for(p=j=s.Length;;)Write("{0,"+(n%4>1?p:0)+"}\n",new string(s[--j],-~n%4>1?j+1:p-j));}

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

Рубин , 95 82 79 байтов

->n{r=(0...z=/$/=~s=[*1..n]*'').map{|i|" "*n[1]*i+s[0,z-i]};-n&2>0?r:r.reverse}

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

3 байта сохранены G B.

R , 152 139 137 134 байт

function(n,N=nchar(s<-Reduce(paste0,1:n,'')),A=!n%%4%%3)for(i in 1:N)cat(rep('',(M=c(N-i+1,i))[1+!A]*(n%%4>1)),substr(s,1,M[1+A]),'
')

Развернутый код:

function(n){
  s = Reduce(paste0,1:n,'')      # concat the digits from 1 to n into a string s

  N = nchar(s)                   # store the length of s

  A = !n%%4%%3                   # A = TRUE if n MOD 4 == 1 or 2 

  for(i in 1:N){                 # for 1 to N (length of s)

    M = c(N-i+1,i)               # store N-i+1 and i into a vector

    nSpaces = M[1+!A]*(n%%4>1)   # if n MOD 4 == 1 or 2 then nSpaces = i else nSpaces = N-i+1, 
                                 # but if n MOD 4 == 0 or 1, then force nSpaces = 0

    nDigits = M[1+A]             # if n MOD 4 == 1 or 2 then nDigits = N-i+1 else nDigits = i

    prfx = rep('',)              # create a character vector repeating '' nSpaces times

    sufx = substr(s,1,M[1+A])    # substring s by taking the first nDigits characters

    cat(pr,su,'\n')              # print prfx and sufx using space as separator for the values 
                                 # contatenation (cat function default) and append a newline
  }

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

APL + WIN, 45 байт

Запрашивает целое число

m←⊃(⍳⍴s)↑¨⊂s←(⍕⍳n←⎕)~' '⋄⍎(' ⊖⍉⌽'[1+4|n]),'m'

Попробуйте онлайн! Предоставлено Dyalog Classic

PowerShell , 108 байт

param($n)0..($y=($x=-join(1..$n)).length-1)|%{' '*(0,0,$_,($z=$y-$_))[$n%4]+-join$x[0..($_,$z,$z,$_)[$n%4]]}

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

Немного грубо по краям, но работает. Соединяет цифры 1 nв строку, затем перебирает от 0 до длины этой строки-1. Каждый раз он использует индексирование списка, чтобы переключиться на правильный метод пробелов и диапазон номеров, используемый для нарезки нашей новой строки.

Желе , 12 байт

D€Ẏ;\z⁶U$⁸¡Y

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

05AB1E (legacy) , 14 12 10 байт

По какой-то причине использование старой версии в качестве переписывания происходит крайне медленно.

Сохранено 2 байта благодаря Кевину Круйссену

LSηsFRζ}J»

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

объяснение

L           # push range [1 ... input]
 S          # split to list of individual digits
  η         # calculate prefixes
   sF  }    # input times do:
     R      # reverse list
      ζ     # and transpose it
        J   # join to list of strings
         »  # and join on newlines

Stax , 10 байт

Ç√çZ╟84Γó║

Запустите и отладьте его

PowerShell , 105 101 95 байт

-4 байта спасибо Арно за трюк с сортировкой .

param($n)($x=1..$n-join'')|% t*y|%{($s+="$_")}|sort -d:($n%4-in1,2)|% *ft($x.Length*($n%4-ge2))

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

Менее гольф:

param($n)
$x=1..$n-join''
$x|% toCharArray |% {
    ($s+="$_")
} | sort -Descending:($n%4-in1,2) |% PadLeft ($x.Length*($n%4-ge2))

R , 175 172 154 байт

function(n)write(c(" ",0:9)[1+(x=utf8ToInt(Reduce(paste0,1:n,""))-47)*!upper.tri(diag(y<-sum(x|1)))["if"(n%%4>1,1:y,y:1),"if"(!n%%4%%3,y:1,1:y)]],1,y,,"")

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

Ужасный беспорядок в линии!

-3 байта путем изменения условия вращения

-17 байт благодаря предложению digEmAll и еще один байт после игры в гольф

Wolfram Language (Mathematica) , 137 байт

(t=Table[Table[" ",If[(m=#~Mod~4)>1,Tr[1^s]-k,0]]<>ToString/@s[[;;k]],{k,Length[s=Join@@IntegerDigits/@Range@#]}];If[0<m<3,Reverse@t,t])&

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

Python 2 , 116 байт

n=input()
s=''.join(map(str,range(1,n+1)));L=len(s)
p=-~n/2%2;i=~-L*p+1
exec'print s[:i].rjust(n/2%2*L);i+=1-2*p;'*L

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

Красный , 155 байт

func[n][b: copy""repeat i n[append b i]repeat i l:
length? b[t:[l - i + 1]set[k m]pick[i t[l t][l i]]n % 4 + 1
print pad/left copy/part b do do m do do k]]

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

Perl 5, 117 байт

$p=$_++&2?'/ ':'$/';$s='(.*\d.\n)';$r=$_--&2?$s.'\K$':"^(?=$s)";$_=(join"",1..$_).$/;1while s,$r,'$1=~s/\d'."$p/r",ee

TIO

PHP ,116 111 109 байт

for($m=$l=strlen($s=join(range(1,$n=$argn)));$l--;)printf('%'.($n&2?$m:-$l).'.'.($n-1&2?$m-$l:$l+1)."s
",$s);

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

Запустить с php -nFвводом из STDIN.

$ echo 6|php -nF t.php

123456
 12345
  1234
   123
    12
     1

Ява (JDK) , 247 209 188 186 160 148 байт

i->{String s="";int l=0,w;for(;l<i;s+=++l);for(w=s.length(),l=0;l<w;)System.out.printf("%"+(1>i%4/2?1:w)+"s\n",s.substring(0,1>~-i%4/2?w-l++:++l));}

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

-38 bytesблагодаря @KevinCruijssen
-21 bytes, позволив printfобрабатывать отступы.
-2 bytesделая подстроку перед заменой, что позволяет нам увеличивать lодно место, а не два.
-26 bytes- при printfвыполнении дополнения строка, заполненная пробелами, больше не нужна, и строки цифр, очевидно, могут быть сгенерированы более коротким способом.
-12 bytesне возиться с однозначными цифрами вместо печати подстрок идеально обслуживаемой цепочки цифр, которую мы уже имеем.

Ungolfed

input->{
    // Lambda expression with target type of IntConsumer
    String allDigits = "";
    int lineLength, line = 0;

    // Collect a list of all digits in order.
    for (;line < input; allDigits += ++line) {}

    // Save the max length of a line, and create a string of that many spaces.
    for (lineLength=allDigits.length(), line=0; line < lineLength;) {
        System.out.printf(   "%" // construct a format string to handle the padding
                           + (   1 > input%4/2
                               ? 1 // No padding
                               : w // Yes padding
                             )
                           + "s\n"
                         , allDigits.substring( 0
                                              ,   1 > (i-1)%4/2
                                                ? w - l++
                                                : ++l
                                              ) // A string containing only the digit we want.
                         );
    }
}