Reto:

Entrada: un entero positivo $n$

Salida:

Cree una lista en el rango $[1,n]$ y únala a una cadena (es decir, $n=13$ sería la cadena 12345678910111213).

Ahora sacamos un triángulo usando los prefijos o sufijos de esta cadena, en una de las siguientes cuatro orientaciones basadas en el entero de entrada:

• Si , imprímalo en forma de triángulo ◣$n\equiv 0\pmod 4$
• Si $n\equiv 1\pmod 4$ , imprímalo en forma de triángulo ◤
• Si $n\equiv 2\pmod 4$ , imprímalo en forma de triángulo ◥
• Si $n\equiv 3\pmod 4$ , imprímalo en forma de triángulo ◢

Ejemplo:

Entrada: $n=13$

Como $13\equiv 1\pmod 4$ , la forma será ◤. Aquí tres posibles salidas 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

Reglas de desafío:

• Como puede ver en las tres salidas válidas anteriores, solo es importante la forma correcta y el uso de todos los dígitos en el orden correcto . Aparte de eso, eres libre de usar prefijos o sufijos; se invierte / refleja; impresión diagonal; etc. etc. Se permite cualquiera de las seis salidas posibles para cada forma (consulte el caso de prueba a continuación para ver todas las salidas válidas basadas en la forma). Esto permite que los idiomas con rotación incorporada lo usen, pero los que no lo tienen también pueden usar un enfoque alternativo de usar los prefijos en el tamaño correcto de arriba a abajo, o usar los prefijos para dos de las formas pero los sufijos para las otras dos formas . Elegir las opciones de salida más apropiadas para su idioma es parte del proceso de golf. :)
• Se garantiza que la entrada sea un número entero positivo. Para simplemente sacamos .$n=1$1
• Se permite cualquier cantidad de líneas / espacios iniciales / finales, siempre que imprima el triángulo correcto (¡sin delimitadores verticales u horizontales!) En algún lugar de la pantalla.

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de code-golf lo desanimen a publicar respuestas con lenguajes que no sean codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Las reglas estándar se aplican a su respuesta con las reglas de E / S predeterminadas , por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código (es decir, TIO ).
• Además, se recomienda agregar una explicación para su respuesta.

Casos de prueba:

Entrada: Todas las salidas válidas posibles:$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 las salidas posibles:$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 las salidas posibles:$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 las salidas posibles:$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: Solo salida posible:$n=1$

1

Entrada: Todas las salidas posibles:$n=2$

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

JavaScript (ES6),  93  89 bytes

Devuelve una 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)

Pruébalo en línea!

Patrón alternativo (mismo tamaño):

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

Pruébalo en línea!

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

Resumen de forma

A continuación se muestra un resumen de la forma base (generada por los mapbucles anidados ) y la forma final (después de 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)

Pruébalo en línea!

Japt , 8 bytes

Devuelve una matriz de líneas.

õ ¬å+ zU

Intentalo

Guardado 2 bytes gracias 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

Lienzo , 8 bytes.

ŗ］∑［］⁸［↷

Pruébalo aquí!

Perl 6 , 94 bytes

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

Pruébalo en línea!

Bloque de código anónimo que toma un número y devuelve una lista de líneas.

Carbón , 17 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｎθ

Entrada n.

≔⭆θ⊕ιη

Crea una cadena concatenando los números 1a n.

ＧLＬηη

Llena un triángulo de esa longitud con la cuerda.

⟲⊗θ

Gire el triángulo en sentido antihorario en n*90grados.

‖

Refleja todo, terminando así con un triángulo que gira en sentido horario en n*90grados.

C # (compilador interactivo de 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));}

Pruébalo en línea!

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}

Pruébalo en línea!

3 bytes guardados 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 desenrollado:

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
  }

Pruébalo en línea!

APL + WIN, 45 bytes

Solicitudes de entero

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

Pruébalo en línea! Cortesía 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]]}

Pruébalo en línea!

Un poco áspero alrededor de los bordes pero funciona. Une los dígitos 1 nen una cadena y luego itera de 0 a la longitud de esa cadena-1. Cada vez, usa la indexación de listas para cambiar al método de espaciado correcto y al rango de números utilizado para cortar nuestra nueva cadena.

Jalea , 12 bytes

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

Pruébalo en línea!

05AB1E (legado) , 14 12 10 bytes

El uso de la versión heredada como reescritura es extremadamente lenta en esto por alguna razón.

Guardado 2 bytes gracias a Kevin Cruijssen

LSηsFRζ}J»

Pruébalo en línea!

Explicación

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Γó║

Ejecutar y depurarlo

PowerShell , 105 101 95 bytes

-4 bytes gracias Arnauld por el truco con Sort .

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

Pruébalo en línea!

Menos golfizado:

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

Pruébalo en línea!

¡Un horrible desastre en línea!

-3 bytes cambiando la condición de rotación

-17 bytes gracias a la sugerencia de digEmAll , y otro byte después de jugar golf.

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

Pruébalo en línea!

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

Pruébalo en línea!

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

Pruébalo en línea!

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

Pruébalo en línea!

Ejecutar con php -nFentrada de STDIN.

$ echo 6|php -nF t.php

123456
 12345
  1234
   123
    12
     1

Java (JDK) , 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));}

Pruébalo en línea!

-38 bytesgracias a @KevinCruijssen
-21 bytespor dejar que se printfmaneje el relleno.
-2 byteshaciendo subcadena antes de reemplazar, lo que nos permite incrementar len una ubicación en lugar de dos.
-26 bytes- con printfel relleno, la cadena llena de espacios ya no era necesaria, y las cadenas de dígitos podrían generarse aparentemente de una manera más corta.
-12 bytesal no jugar con un solo dígito en lugar de imprimir subcadenas de la cadena de dígitos perfectamente útil que ya tenemos.

Sin golf

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