Numéros triangulaires

16

(non, pas ceux-là )

Le défi

Vous recevrez deux entrées. Le premier est un entier positif n > 0, qui est utilisé pour sortir unn x n triangle rectangle des nombres1, 2, 3, ... n . Ce triangle commence dans un coin et augmente horizontalement et verticalement de un et en diagonale de deux. Voir les exemples ci-dessous pour des éclaircissements. Gardez un espace entre les colonnes et gardez tous les nombres alignés à droite dans leurs colonnes particulières. (C'est de l' ascii-art après tout).

La deuxième entrée,, xest l'un des quatre caractères ASCII uniques distincts de votre choix qui détermine le coin de départ du triangle (et donc son orientation). Par exemple, vous pouvez utiliser1,2,3,4 oua,b,c,d ou #,*,!,), etc. Veuillez préciser dans votre réponse comment fonctionne l'orientation.

Pour clarifier ce défi, je vais utiliser 1,2,3,4 ce qui correspondra à1 haut à gauche, en 2haut à droite, et ainsi de suite dans le sens horaire.

Les exemples

Par exemple, pour n = 5, x = 1affichez les éléments suivants:

1 2 3 4 5
2 3 4 5
3 4 5
4 5
5

Pour l'entrée n = 11, x = 1sortez les éléments suivants (notez les espaces supplémentaires afin que les chiffres simples soient alignés à droite):

 1  2  3  4  5  6  7  8  9 10 11
 2  3  4  5  6  7  8  9 10 11
 3  4  5  6  7  8  9 10 11
 4  5  6  7  8  9 10 11
 5  6  7  8  9 10 11
 6  7  8  9 10 11
 7  8  9 10 11
 8  9 10 11
 9 10 11
10 11
11

Avec entrée n=6et x=2sortie:

6 5 4 3 2 1
  6 5 4 3 2
    6 5 4 3
      6 5 4
        6 5
          6

Avec entrée n = 3et x = 4sortie:

3
2 3
1 2 3

Avec entrée n = 1et n'importe quelle xsortie:

1

Les règles

  • Les sauts de ligne de début / fin ou les autres espaces sont facultatifs, à condition que les numéros soient alignés de manière appropriée. (Par exemple, un espace de fin pour faire une sortie carrée est acceptable).
  • Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
  • La sortie peut être vers la console, enregistrée sous forme d'image, renvoyée sous forme de liste de chaînes, etc. Tout format pratique et autorisé .
  • Les failles standard sont interdites.
  • Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.
code-golf  ascii-art  number 
— AdmBorkBork
source
Cette question est juste ceci + cela . Je ne sais pas encore mais j'ai l'impression que c'est une dupe de l'un d'eux.
— Post Rock Garf Hunter
4
@WheatWizard Je ne pense pas que les réponses de l'un ou l'autre de ces défis puissent être trivialement modifiées pour être compétitives ici.
— AdmBorkBork
Pour être honnête, je sais que beaucoup de gens disent que c'est ce qui fait un doublon, mais autant que je sache, ce n'est pas une règle. Pour moi, un doublon est une question qui n'offre rien en termes de défi qui n'est pas fourni par les questions existantes.
— Post Rock Garf Hunter
2
@WheatWizard Meta consensus .
— AdmBorkBork
J'ai lu cette réponse. C'est une recommandation dans un contexte plus spécifique et non une décision universelle.
— Post Rock Garf Hunter

Réponses:

1

MATL , 18 octets

:&YhiX!VZ{' 0'2:YX

La première entrée est n. La deuxième entrée est x, qui peut être:

  • 0: en haut à gauche
  • 1: en bas à gauche
  • 2: en bas à droite
  • 3: en haut à droite

(Ou il peut s'agir de n'importe quel autre entier, qui est interprété modulo 4).

Essayez-le sur MATL Online!

— Luis Mendo
source
1

APL (Dyalog) , 29 octets

{' '@(=∘0)⌽∘⍉⍣⍺⊢↑⌽(⍳+⍵-⊢)¨⍳⍵}

Essayez-le en ligne!

Comment?

¨⍳⍵- pour chacun idans la gamme den

(⍳+⍵-⊢)- produire gamme de iavec addition vectorisée den - i

↑⌽ - inverser et aplatir

⌽∘⍉ - tourner à droite

⍣⍺⊢- xfois

' '@(=∘0) - supprimer les zéros

— Uriel
source
1

JavaScript 130 128 154 142 138 135 135 133 octets

* problèmes de rembourrage fixes

A=(n,x)=>(j=>{for(;n--;s=x<3?S+`
`+s:s+S+`
`)
for(S=O,i=j;i;S=i-->n^~-x%3?X+S:S+X)
X=(i>n?i+O:O).padStart(j.length+1)})(n+=s=O="")||s

console.log(A(6,1))
console.log(A(6,2))
console.log(A(6,3))
console.log(A(6,4))

console.log(A(12,1))
console.log(A(12,2))
console.log(A(12,3))
console.log(A(12,4))

/* 154 solution
A=(n,x)=>{s=""
for(j=n;n--;s=x<3?S+`
`+s:s+S+`
`)
for(S="",i=j;i;S=i-->n?~-x%3?S+X:X+S:~-x%3?X+S:S+X)
X=(i>n?i+"":"").padStart((j+"").length+1)
return s
}

142 solution
A=(n,x)=>{s=""
for(j=n;n--;s=x<3?S+`
`+s:s+S+`
`)
for(S="",i=j;i;S=i-->n ^ ~-x%3?X+S:S+X)
X=(i>n?i+"":"").padStart((j+"").length+1)
return s
}

138 solution
A=(n,x)=>{s=""
for(j=n+" ";n--;s=x<3?S+`
`+s:s+S+`
`)
for(S="",i=+j;i;S=i-->n^~-x%3?X+S:S+X)
X=(i>n?i+"":"").padStart(j.length)
return s
}

135 solution
A=(n,x)=>{for(j=n+=s=O="";n--;s=x<3?S+`
`+s:s+S+`
`)
for(S=O,i=j;i;S=i-->n^~-x%3?X+S:S+X)
X=(i>n?i+O:O).padStart(j.length+1)
return s
}
*/
Développer l'extrait

— DanielIndie
source
@AdmBorkBork je pense que je l'ai corrigé maintenant
— DanielIndie
0

Python 2 , 124 120 octets

n,x=input()
r=range(n)
for l in zip(*[(r+[n]+['']*i)[-n:]for i in r][::1-x%4/2*2])[::1-x/3*2]:print' %%%ds'%len(`n`)*n%l

Essayez-le en ligne! ou Essayez tous les cas de test

(r+[n]+['']*i)[-n:]ajoutera des chaînes vides à la liste des nombres et coupera à la bonne taille, zipavec [::1-x%4/2*2]et[::1-x/3*2] effectuera la rotation, et %%%ds'%len(`n`)*ngénérera une chaîne de fomation (comme ' %3s %3s %3s'...) à utiliser sur chaque nombre + liste de chaînes vide

— Barre
source
0

Mathematica, 89 octets

(R=Reverse;Grid[{#&,R/@#&,R[R/@#]&,R@#&}[[#2]]@PadRight@Array[Range[#,s]&,s=#]/. 0->""])&

voici une autre solution qui fonctionne dans TIO

Mathematica, 122 octets

(R=Reverse;StringRiffle[""<>ToString/@#&/@({#&,R/@#&,R[R/@#]&,R@#&}[[#2]]@PadRight@Array[#~Range~s&,s=#]/. 0->" "),"\n"])&


Essayez-le en ligne!

— J42161217
source
0

Fusain , 39 octets

Ｎτ≔ＥτＥτ◧׋⁺ιλτＩ⊕⁺ιλＬθσＦＮ≔⮌ＥσＥσ§μλσＥσ⪫ι

Essayez-le en ligne! Remarque: Espace de fin. Le lien est vers la version détaillée du code. La deuxième valeur est le nombre de rotations dans le sens antihoraire, donc 0 est en haut à gauche, 1 en bas à gauche, 2 en bas à droite, 3 en haut à droite. Explication:

Ｎτ                                      Assign the first input as an integer
   ＥτＥτ                                 Map in two dimensions
               ⊕⁺ιλ                     Sum of zero-indexed coordinates plus 1
              Ｉ                         Cast to string
         ‹⁺ιλτ                          Is this the upper left triangle?
        ×                               Repeat the string once if so
       ◧           Ｌθ                   Pad to length of first input
  ≔                  σ                  Assign to variable
                          ＥσＥσ§μλ       Transpose the array
                         ⮌              Reflect the array, giving a rotation
                        ≔        σ      Reassign to variable
                       Ｎ                Second input as an integer
                      Ｆ                 Repeat that many times
                                  Ｅσ    Map over array
                                    ⪫ι  Join with spaces and implicitly print
— Neil
source
0

Javascript (ES6), 241 222 214 octets

let f = 

    (n,x)=>(L=x=>(''+x).length,M=b=>x&b?(c,i,a)=>a[n-1-i]:c=>c,Array(n).fill(b=' ').map((c,i)=>b.repeat(L(n)-L(++i))+i).map((c,i,a)=>a.map((v,j)=>j>i?b.repeat(L(n)):v)).map(M(1)).map(c=>c.map(M(2))).map(c=>c.join(b)))


function printTriangle() {  // display array of strings returned by f
    o.innerText = f(
       +Length.value, // number
       Rotate.value[0] // ASCII char
    ).join('\n');
}
Length: <input type="text" value="11" id="Length"><br>
Rotate: <input type="text" value="0" id="Rotate"> 0,1,2,3<br>
<button type="button" onclick="printTriangle()">
  OK
</button>
<br>
<pre id="o"></pre>
Développer l'extrait

Moins de golf

(n,x)=>(
    L= x=> (''+x).length,                // strlen(x)
    M= b=> x&b ? (c,i,a)=>a[n-1-i] : c=>c, // reverse or identity map
    Array(n).fill(b=' ')
   .map((c,i)=>b.repeat(L(n)-L(++i))+i)  // a complete line of numbers
   .map((c,i,a)=>a.map((v,j)=>j>i?b.repeat(L(n)):v)) // to 2-d array
                                         // with spaces for blank numbers
   .map(M(1))                            // flip vertically?
   .map(c=>c.map(M(2)))                  // flip horizontally?
   .map(c=>c.join(b))                    // convert lines to strings
)

Remarque sur l'orientation.

Le deuxième paramètre est un caractère de {'0', '1', '2', '3'} et le type est automatiquement converti en nombre par le & opérateur. Si le bit 0 (lsb) du nombre est défini, les lignes sont inversées verticalement. Si le bit 1 (nlsb) est défini, les colonnes sont inversées horizontalement. D'autres caractères décimaux peuvent être utilisés avec des résultats prévisibles.

Espaces de fin

Les entrées vides dans la chaîne de sortie ont été remplacées par des espaces, ce qui signifie que les lignes ont des espaces de fin dans les orientations «0» et «1».

— traktor53
source
0

Lua, 250 octets

function f(w,m)d=""for y=1,w do for x=1,w do d=string.format("%s%"..tostring(w):len().."s ",d,m<2 and(y+x-1<=w and x+y-1 or"")or(m<3 and(x>=y and w-x+y or"")or(m<4 and(y+x-1>=w and w+w-x-y+1 or"")or(y>=x and w-y+x or""))))end;d=d.."\n"end;print(d)end

Prend les paramètres [w] idth et [m] ode en utilisant 1,2,3,4 pour les modes comme décrit dans l'exemple.

— Jaser
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.