(no, non quelli )

La sfida

Ti verranno dati due input. Il primo è un numero intero positivo n > 0, che viene utilizzato per generare un n x ntriangolo rettangolo dei numeri 1, 2, 3, ... n. Questo triangolo inizia in un angolo e aumenta orizzontalmente e verticalmente di uno e in diagonale di due. Vedi gli esempi sotto per chiarimenti. Mantenere uno spazio tra le colonne e mantenere tutti i numeri allineati a destra nelle rispettive colonne. (Questa è arte ascii dopo tutto).

Il secondo input, xè uno dei quattro caratteri ASCII singoli distinti di tua scelta che determina l'angolo iniziale del triangolo (e quindi l'orientamento). Ad esempio, è possibile utilizzare 1,2,3,4o a,b,c,do #,*,!,), ecc. Specificare nella risposta come funziona l'orientamento.

Per chiarimenti in questa sfida, userò 1,2,3,4quale corrisponderà per 1in alto a sinistra, 2in alto a destra e così via in senso orario.

Gli esempi

Ad esempio, per n = 5, x = 1produrre quanto segue:

Per l'input n = 11, x = 1produrre quanto segue (notare gli spazi extra in modo che le singole cifre siano allineate a destra):

 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

Con input n=6e x=2output:

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

Con input n = 3e x = 4, output:

3
2 3
1 2 3

Con input n = 1e any x, output:

Le regole

Le linee guida iniziali / finali o altri spazi bianchi sono opzionali, a condizione che i numeri siano allineati in modo appropriato. (Ad esempio, è accettabile lo spazio bianco finale per creare un output quadrato).
È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
L'output può essere sulla console, salvato come immagine, restituito come un elenco di stringhe, ecc. Qualsiasi formato comodo e consentito .
Sono vietate le scappatoie standard .
Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

code-golf ascii-art number

— AdmBorkBork
fonte

Questa domanda è proprio questo + questo . Non lo so ancora, ma mi sento come se questo fosse un inganno di uno di loro.

— Post Rock Garf Hunter,

4

@WheatWizard Non credo che le risposte di nessuna di queste sfide possano essere banalmente modificate per essere competitive qui.

— AdmBorkBork,

Ad essere sincero, so che molte persone dicono che è ciò che rende un duplicato, ma per quanto ne so non è una regola. Per me un duplicato è una domanda che non offre nulla in termini di sfida che non è fornita dalle domande esistenti.

— Post Rock Garf Hunter,

2

@WheatWizard Meta consenso .

— AdmBorkBork,

Ho letto quella risposta. È una raccomandazione in un contesto più specifico, non una sentenza universale.

— Post Rock Garf Hunter,

3

Gelatina , 13 byte

Rṫ`z⁶ṚH}¡U⁹¡G

Provalo online!

Argomento sinistro: Argomento n
destro: x( 0= in alto a sinistra, 1= in alto a destra, 2= in basso a sinistra, 3= in basso a destra)

— Erik the Outgolfer
fonte

1

MATL , 18 byte

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

Il primo input è n. Il secondo input è x, che può essere:

0: in alto a sinistra
1: in basso a sinistra
2: in basso a destra
3: in alto a destra

(O può essere qualsiasi altro numero intero, che viene interpretato modulo 4).

Provalo su MATL Online!

— Luis Mendo
fonte

1

APL (Dyalog) , 29 byte

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

Provalo online!

Come?

¨⍳⍵- per ciascuno inel range din

(⍳+⍵-⊢)- produce gamma di icon aggiunta vettoriale din - i

↑⌽ - invertire e appiattire

⌽∘⍉ - ruota a destra

⍣⍺⊢- xvolte

' '@(=∘0) - rimuove gli zeri

— Uriel
fonte

1

JavaScript 130 128 154 142 138 135 133 byte

* risolti problemi di imbottitura

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
}
*/

Espandi frammento

— DanielIndie
fonte

@AdmBorkBork penso di averlo corretto ora

— DanielIndie,

0

Python 2 , 124 120 byte

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

Provalo online! oppure Prova tutti i casi di test

(r+[n]+['']*i)[-n:]aggiungerà alcune stringhe vuote all'elenco dei numeri e taglierà le dimensioni giuste, zipcon [::1-x%4/2*2]e [::1-x/3*2]farà la rotazione, e %%%ds'%len(`n`)*ngenererà una stringa per la fomata (come ' %3s %3s %3s'...) da usare su ogni numero + lista di stringhe vuota

— asta
fonte

0

Mathematica, 89 byte

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

ecco un'altra soluzione che funziona in TIO

Mathematica, 122 byte

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

Provalo online!

— J42161217
fonte

0

Carbone , 39 byte

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

Provalo online! Nota: spazio finale. Il collegamento è alla versione dettagliata del codice. Il secondo valore è il numero di rotazioni in senso antiorario, quindi 0 è in alto a sinistra, 1 in basso a sinistra, 2 in basso a destra, 3 in alto a destra. Spiegazione:

Ｎτ                                      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
fonte

0

Javascript (ES6), 241 222 214 byte

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>

Espandi frammento

Meno golfato

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

Nota sull'orientamento.

Il secondo parametro è un carattere compreso tra {'0', '1', '2', '3'} e digita automaticamente convertito in un numero &dall'operatore. Se viene impostato il bit 0 (lsb) del numero, le linee vengono capovolte verticalmente. Se il bit 1 (nlsb) è impostato, le colonne vengono capovolte orizzontalmente. È possibile utilizzare altri caratteri con cifre decimali con risultati prevedibili.

Spazi finali

Le voci vuote nella stringa di output sono state sostituite con spazi, il che significa che le linee hanno spazi finali negli orientamenti '0' e '1'.

— traktor53
fonte

0

Lua, 250 byte

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

Prende i parametri [w] idth e [m] ode usando 1,2,3,4 per le modalità come descritto nell'esempio.

— spifferare
fonte

0

05AB1E (61 byte)

F¹N-LN+¹N-LN+Rõ¸N∍s«N>LN¹<--N>LN¹<--Rõ¸¹<N-∍s«)²èvy¹gyg-ú}ðý,

Provalo online

— David Smith
fonte

Numeri triangolari

La sfida

Gli esempi

Le regole

Gelatina , 13 byte

MATL , 18 byte

APL (Dyalog) , 29 byte

JavaScript 130 128 154 142 138 135 133 byte

Python 2 , 124 120 byte

Mathematica, 89 byte

Mathematica, 122 byte

Carbone , 39 byte

Javascript (ES6), 241 222 214 byte

Meno golfato

Nota sull'orientamento.

Spazi finali

Lua, 250 byte

05AB1E (61 byte)