Défi:

Entrée: Un entier positif $n$

Sortie:

Créez une liste dans la plage et joignez-la à une chaîne (c.-à-d. serait la chaîne ). $[1,n]$ $n=13$ 12345678910111213

Maintenant, nous sortons un triangle en utilisant les préfixes ou suffixes de cette chaîne, dans l'une des quatre orientations suivantes en fonction de l'entier d'entrée:

Si $n\equiv 0\pmod 4$ , sortez-le en forme de triangle ◣
Si $n\equiv 1\pmod 4$ , sortez-le en forme de triangle ◤
Si $n\equiv 2\pmod 4$ , sortez-le en forme de triangle ◥
Si $n\equiv 3\pmod 4$ , sortez-le en forme de triangle ◢

Exemple:

Entrée: $n=13$

Parce que $13\equiv 1\pmod 4$ , la forme sera ◤. Voici trois sorties valides possibles:

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

Règles du défi:

Comme vous pouvez le voir sur les trois sorties valides ci-dessus, seule la forme correcte et l'utilisation de tous les chiffres dans le bon ordre sont importantes. En dehors de cela, vous êtes libre d'utiliser des préfixes ou des suffixes; inverse / réfléchit; impression diagonale; etc. etc. N'importe laquelle des six sorties possibles pour chaque forme est autorisée (voir le cas de test ci-dessous pour voir toutes les sorties valides en fonction de la forme). Cela permet aux langues avec des rotations intégrées de l'utiliser, mais celles sans peuvent également utiliser une approche alternative consistant à utiliser les préfixes de la bonne taille de haut en bas, ou à utiliser les préfixes pour deux des formes mais des suffixes pour les deux autres formes . Le choix des options de sortie les plus appropriées pour votre langue fait partie du processus de golf. :)
L'entrée est garantie comme un entier positif. Pour nous sortons simplement . $n=1$ 1
N'importe quel nombre de nouvelles lignes / espaces de début / fin est autorisé, tant qu'il imprime le triangle correct (sans délimiteurs verticaux ou horizontaux!) Quelque part sur l'écran.

Règles générales:

C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
Des règles standard s'appliquent à votre réponse avec des règles d'E / S par défaut , vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
Les failles par défaut sont interdites.
Si possible, veuillez ajouter un lien avec un test pour votre code (par exemple TIO ).
De plus, l'ajout d'une explication à votre réponse est fortement recommandé.

Cas de test:

Entrée: Toutes les sorties valides possibles: $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

Entrée: Toutes les sorties possibles: $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

Entrée: Toutes les sorties possibles: $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

Entrée: Toutes les sorties possibles: $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

Entrée: Seule sortie possible: $n=1$

Entrée: Toutes les sorties possibles: $n=2$

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

— Kevin Cruijssen
source

Pouvons-nous utiliser d'autres valeurs pour différents triangles, comme 1 pour ◤, etc.?

— Incarnation de l'ignorance

@EmbodimentofIgnorance Un exemple malheureux, car c'est ce que dit la spécification. Je pense que vous vouliez demander si nous pouvons changer l'ordre des quatre arrangements tant que nous le maintenons cohérent (je pense que ce serait un non).

— Erik the Outgolfer

1

Si n==13, la ligne du haut peut-elle être '33333333333333333'(ou, de manière équivalente '31211101987654321')?

— Chas Brown

@EmbodimentofIgnorance Désolé, mais je dirais non dans ce cas. Les formes et leurs correspondances mod 4sont des paires strictes pour ce défi. Vous ne pouvez donc pas changer les quatre formes pour les quatre mod 4cas. Mais bonne question quand même.

— Kevin Cruijssen

@ChasBrown Oui, les deux sont très bien. Je n'ai donné que trois exemples possibles pour le , mais les six options (comme le cas de test ) sont des sorties valides.

n = 13

$n=13$

n = 5

$n=5$

— Kevin Cruijssen

9

JavaScript (ES6), 93 89 octets

Renvoie une matrice de caractères.

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

Essayez-le en ligne!

Motif alternatif (même taille):

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

Essayez-le en ligne!

Commenté

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

Résumé de la forme

mapsort $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    | ##... | ####. | .#### | ...##
          | ###.. | ###.. | ..### | ..###
          | ####. | ##... | ...## | .####
          | ##### | #.... | ....# | #####

— Arnauld
source

1

merci pour vos détails expliquant.

— chau giang

9

Python 2 , 94 octets

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)

Essayez-le en ligne!

— xnor
source

7

Japt , 8 octets

Renvoie un tableau de lignes.

õ ¬å+ zU

Essayez-le

Enregistré 2 octets grâce à 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

— Hirsute
source

1

Est-ce únécessaire? Il semble que la rotation le fasse implicitement?

— Kevin Cruijssen

@KevinCruijssen, hmm ... c'est vrai. J'oublie toujours ça; rarement à utiliser z.

— Shaggy

1

Eh bien, je ne connais pas du tout Japt. J'étais juste curieux de savoir à quoi ressemblait la sortie sans le rembourrage pour le plaisir, et j'ai vu que cela fonctionnait exactement de la même manière

— ;;

4

Toile , 8 octets

ŗ］∑［］⁸［↷

Essayez-le ici!

— dzaima
source

4

Perl 6 , 94 octets

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

Essayez-le en ligne!

Bloc de code anonyme qui prend un nombre et renvoie une liste de lignes.

— Jo King
source

3

Fusain , 17 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ｎθ

Entrée n.

≔⭆θ⊕ιη

Créez une chaîne en concaténant les nombres 1à n.

ＧLＬηη

Remplissez un triangle de cette longueur avec la chaîne.

⟲⊗θ

Faites pivoter le triangle dans le sens antihoraire par n*90degrés.

‖

Refléter tout, se terminant ainsi par un triangle qui est tourné dans le sens horaire par n*90degrés.

— Neil
source

3

C # (Visual C # Interactive Compiler) , 128 octets

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

Essayez-le en ligne!

— Incarnation de l'ignorance
source

3

Rubis , 95 82 79 octets

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

Essayez-le en ligne!

3 octets enregistrés par G B.

— Kirill L.
source

3

R , 152 139 137 134 octets

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

Code déroulé:

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
  }

Essayez-le en ligne!

— digEmAll
source

... ça n'a pas été ma journée pour le golf, clairement.

— Giuseppe

@Giuseppe: ahah été là ... et puis tu me surpassais habituellement: P

— digEmAll

2

APL + WIN, 45 octets

Demande un entier

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

Essayez-le en ligne! Gracieuseté de Dyalog Classic

— Graham
source

2

PowerShell , 108 octets

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

Essayez-le en ligne!

Un peu rude sur les bords mais ça marche. Joint les chiffres 1 à nune chaîne, puis itère de 0 à la longueur de cette chaîne-1. À chaque fois, il utilise l'indexation de liste pour basculer vers la méthode d'espacement et la plage de numéros utilisées pour découper notre nouvelle chaîne.

— Veskah
source

2

Gelée , 12 octets

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

Essayez-le en ligne!

— Erik le Outgolfer
source

2

05AB1E (hérité) , 14 12 10 octets

L'utilisation de la version héritée comme réécriture est extrêmement lente à ce sujet pour une raison quelconque.

Enregistré 2 octets grâce à Kevin Cruijssen

LSηsFRζ}J»

Essayez-le en ligne!

Explication

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

— Emigna
source

Vous pouvez enregistrer 2 octets changeant LJη€Sà LSη, depuis Saplanit implicitement.

— Kevin Cruijssen

@KevinCruijssen: Oh oui, merci! J'avais oublié ça. J'ai essayé €Sce qui n'a pas très bien fonctionné;)

— Emigna

2

Stax , 10 octets

Ç√çZ╟84Γó║

Exécuter et déboguer

— récursif
source

2

PowerShell , 105 101 95 octets

-4 octets remercie Arnauld pour l' astuce avec Sort .

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

Essayez-le en ligne!

Moins golfé:

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

— mazzy
source

2

R , 175 172 154 octets

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

Essayez-le en ligne!

Un horrible bordel en ligne!

-3 octets en modifiant la condition de rotation

-17 octets grâce à la suggestion de digEmAll , et un autre octet après avoir joué au golf encore plus loin

— Giuseppe
source

J'aime cette approche upper.triangle et peut être raccourcie à 155 octets ... peut-être encore plus, je suis sûr que je manque quelque chose d'évident ...

— digEmAll

@digEmAll ah, beaucoup amélioré, mais toujours long :-(

— Giuseppe

1

Wolfram Language (Mathematica) , 137 octets

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

Essayez-le en ligne!

— J42161217
source

1

Python 2 , 116 octets

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

Essayez-le en ligne!

— Chas Brown
source

1

Rouge , 155 octets

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

Essayez-le en ligne!

— Galen Ivanov
source

1

perl 5, 117 octets

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

TIO

— Nahuel Fouilleul
source

1

PHP ,116 111 109 octets

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

Essayez-le en ligne!

Exécutez avec l' php -nFentrée de STDIN.

$ echo 6|php -nF t.php

— 640 Ko
source

1

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

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

Essayez-le en ligne!

-38 bytesmerci à @KevinCruijssen
-21 bytesen laissant printfgérer le rembourrage.
-2 bytesen faisant la sous-chaîne avant le remplacement, ce qui nous permet d'incrémenter là un endroit plutôt qu'à deux.
-26 bytes- avec printfle remplissage, la chaîne pleine d'espaces n'était plus nécessaire, et les chaînes de chiffres pouvaient apparemment être générées de manière plus courte.
-12 bytesen ne jouant pas avec des chiffres uniques au lieu d'imprimer des sous-chaînes de la chaîne de chiffres parfaitement utilisable que nous avons déjà.

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

— Sara J
source

1

Bonne réponse. Cependant, il y a beaucoup de choses à for(jouer au golf: les espaces après le peuvent être supprimés. new String(new char[w=s.length()]).replace('\0',' ')peut " ".repeat(w=s.length())utiliser Java 11+. Vous pouvez supprimer les parenthèses autour des vérifications ternaires. 1>(i-1)%4/2peut être 1>~-i%4/2. w-1-l++peut être w+~l++. Et vous n'avez pas à compter le point-virgule de fin dans le nombre d'octets. Le tout combiné devient 209 octets .

— Kevin Cruijssen

Les triangles numériques

Défi:

Règles du défi:

Règles générales:

Cas de test:

JavaScript (ES6), 93 89 octets

Commenté

Résumé de la forme

Python 2 , 94 octets

Japt , 8 octets

Toile , 8 octets

Perl 6 , 94 octets

Fusain , 17 octets

C # (Visual C # Interactive Compiler) , 128 octets

Rubis , 95 82 79 octets

R , 152 139 137 134 octets

APL + WIN, 45 octets

PowerShell , 108 octets

Gelée , 12 octets

05AB1E (hérité) , 14 12 10 octets

Stax , 10 octets

PowerShell , 105 101 95 octets

R , 175 172 154 octets

Wolfram Language (Mathematica) , 137 octets

Python 2 , 116 octets

Rouge , 155 octets

perl 5, 117 octets

PHP ,116 111 109 octets

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

Non golfé