Desafio:

Entrada: Um número inteiro positivo$n$

Saída:

Crie uma lista no intervalo e junte-a a uma sequência (ou seja, seria a sequência ).$[1,n]$$n=13$12345678910111213

Agora, produzimos um triângulo usando os prefixos ou sufixos dessa string, em uma das quatro orientações a seguir, com base no número inteiro de entrada:

• Se $n\equiv 0\pmod 4$ , produza -o na forma de triângulo ◣
• Se $n\equiv 1\pmod 4$ , produza -o na forma de triângulo ◤
• Se $n\equiv 2\pmod 4$ , produza -o na forma de triângulo ◥
• Se $n\equiv 3\pmod 4$ , produza -o na forma de triângulo ◢

Exemplo:

Entrada: $n=13$

Como $13\equiv 1\pmod 4$ , a forma será ◤. Aqui estão três possíveis saídas válidas:

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

Regras do desafio:

• Como você pode ver nas três saídas válidas acima, apenas a forma correta e o uso de todos os dígitos na ordem correta são importantes. Além disso, você é livre para usar prefixos ou sufixos; inverte / reflete; impressão diagonal; etc. etc. Qualquer uma das seis saídas possíveis para cada forma é permitida (consulte o caso de teste abaixo para ver todas as saídas válidas com base na forma). Isso permite que idiomas com built-in de rotação o usem, mas os que não têm também podem usar uma abordagem alternativa de usar os prefixos no tamanho correto de cima para baixo ou usar os prefixos para duas das formas, mas sufixos para as outras duas formas. . A escolha das opções de saída mais apropriadas para o seu idioma faz parte do processo de golfe. :)
• A entrada é garantida como um número inteiro positivo. Para , simplesmente produzimos .$n=1$1
• Qualquer quantidade de linhas / espaços à esquerda / à direita é permitida, desde que imprima o triângulo correto (sem delimitadores verticais nem horizontais!) Em algum lugar da tela.

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta com as regras de E / S padrão , para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código (ou seja, TIO ).
• Além disso, é altamente recomendável adicionar uma explicação para sua resposta.

Casos de teste:

Entrada: Todas as saídas válidas possíveis:$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

Entrada: Todas as saídas possíveis:$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

Entrada: Todas as saídas possíveis:$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

Entrada: Todas as saídas possíveis:$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

Entrada: Somente saída possível:$n=1$

1

Entrada: Todas as saídas possíveis:$n=2$

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

JavaScript (ES6),  93  89 bytes

Retorna uma matriz de caracteres.

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

Experimente online!

Padrão alternativo (mesmo tamanho):

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

Experimente online!

Comentado

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

Resumo da forma

Abaixo está um resumo da forma base (gerada pelos maploops aninhados ) e a forma final (após a sort) para cada :$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 bytes

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)

Experimente online!

Japonês , 8 bytes

Retorna uma matriz de linhas.

õ ¬å+ zU

Tente

Economizou 2 bytes graças a Kevin .

õ ¬å+ 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

Tela , 8 bytes

ŗ］∑［］⁸［↷

Experimente aqui!

Perl 6 , 94 bytes

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

Experimente online!

Bloco de código anônimo que pega um número e retorna uma lista de linhas.

Carvão , 17 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

Ｎθ

Entrada n.

≔⭆θ⊕ιη

Crie uma sequência concatenando os números 1para n.

ＧLＬηη

Preencha um triângulo desse comprimento com a corda.

⟲⊗θ

Gire o triângulo no sentido anti-horário em n*90graus.

‖

Reflita tudo, terminando assim com um triângulo que é girado no sentido horário em n*90graus.

C # (compilador interativo do Visual C #) , 128 bytes

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

Experimente online!

Ruby , 95 82 79 bytes

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

Experimente online!

3 bytes salvos por G B.

R , 152 139 137 134 bytes

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]),'
')

Código desenrolado:

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
  }

Experimente online!

APL + WIN, 45 bytes

Solicita número inteiro

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

Experimente online! Cortesia de Dyalog Classic

PowerShell , 108 bytes

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

Experimente online!

Um pouco áspero nas bordas, mas funciona. Une os dígitos 1 a numa sequência e itera de 0 ao comprimento dessa sequência-1. A cada vez, ele usa a indexação de lista para alternar para o método de espaçamento correto e o intervalo de números usado para fatiar nossa nova string.

Gelatina , 12 bytes

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

Experimente online!

05AB1E (herdado) , 14 12 10 bytes

O uso da versão herdada como reescrita é extremamente lento por algum motivo.

Guardado 2 bytes graças a Kevin Cruijssen

LSηsFRζ}J»

Experimente online!

Explicação

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 bytes

Ç√çZ╟84Γó║

Execute e depure

PowerShell , 105 101 95 bytes

-4 bytes, graças a Arnauld pelo truque com Sort .

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

Experimente online!

Menos golfe:

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 bytes

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

Experimente online!

Uma bagunça horrível em linha!

-3 bytes, alterando a condição de rotação

-17 bytes graças à sugestão do digEmAll , e outro byte depois de jogar golfe,

Wolfram Language (Mathematica) , 137 bytes

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

Experimente online!

Python 2 , 116 bytes

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

Experimente online!

Vermelho , 155 bytes

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

Experimente online!

perl 5, 117 bytes

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

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

Experimente online!

Execute com php -nFentrada de STDIN.

$ echo 6|php -nF t.php

123456
 12345
  1234
   123
    12
     1

JDK (Java) , 247 209 188 186 160 148 bytes

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

Experimente online!

-38 bytesgraças a @KevinCruijssen
-21 bytes, deixando printflidar com o estofamento.
-2 bytesfazendo substring antes da substituição, permitindo incrementar lem um local em vez de dois.
-26 bytes- ao printffazer o preenchimento, a cadeia cheia de espaços não era mais necessária e as cadeias de dígitos podiam ser geradas de maneira mais curta, aparentemente.
-12 bytesnão mexendo com dígitos únicos em vez de imprimir substrings da string de dígitos perfeitamente útil que já temos.

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