Dato un numero intero n , scomporlo in una somma di numeri triangolari massimi (dove T _m rappresenta il m numero triangolare o la somma dei numeri interi da 1 a m ) come segue:

• mentre n> 0 ,

  • trova il più grande numero triangolare possibile T _m tale che T _m ≤ n .

  • append m alla rappresentazione a decomposizione triangolare di n .

  • sottrai T _m da n .

Ad esempio, un input di 44 produrrebbe un output di 8311 , perché:

• 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 = 36 <44, ma 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 = 45> 44.

  • la prima cifra è 8 ; sottrai 36 da 44 per ottenere 8 rimasti.

• 1 + 2 + 3 = 6 <8, ma 1 + 2 + 3 + 4 = 10> 8.

  • la seconda cifra è 3 ; sottrai 6 da 8 per ottenere 2 rimasti.

• 1 <2, ma 1 + 2 = 3> 2.

  • la terza e la quarta cifra devono essere 1 e 1 .

Usa le cifre da 1 a 9 per rappresentare i primi 9 numeri triangolari, quindi usa le lettere dalla a alla z (possono essere maiuscole o minuscole) per rappresentare il numero triangolare dal 10 ° al 35 °. Non ti verrà mai dato un input che richiederà l'uso di una "cifra" più grande.

I limiti sull'ingresso sono 1 ≤ n <666 e sarà sempre un numero intero.

Tutti gli ingressi e le uscite possibili e alcuni casi di test selezionati (elencati come input, quindi output):

1 1
2 11
3 2
4 21
5 211
6 3
100 d32
230 k5211
435 t
665 z731

Non è necessario un output di ∞ per un input di -1/12 . :)

JavaScript (ES6), 52 byte

f=(n,t=0)=>t<n?f(n-++t,t):t.toString(36)+(n?f(n):'')

Come?

Invece di calcolare esplicitamente T _i  = 1 + 2 + 3 +… + i , iniziamo con t = 0 e sottraggiamo iterativamente t + 1 da n mentre t <n , incrementando t ad ogni iterazione. Quando la condizione non è più soddisfatta, un totale di T _t è stato sottratto da n e l'output viene aggiornato di conseguenza. Ripetiamo il processo fino a n = 0 .

Di seguito è riportato un riepilogo di tutte le operazioni per n = 100 .

 n  |  t | t < n | output
----+----+-------+--------
100 |  0 | yes   | ""
 99 |  1 | yes   | ""
 97 |  2 | yes   | ""
 94 |  3 | yes   | ""
 90 |  4 | yes   | ""
 85 |  5 | yes   | ""
 79 |  6 | yes   | ""
 72 |  7 | yes   | ""
 64 |  8 | yes   | ""
 55 |  9 | yes   | ""
 45 | 10 | yes   | ""
 34 | 11 | yes   | ""
 22 | 12 | yes   | ""
  9 | 13 | no    | "d"
----+----+-------+--------
  9 |  0 | yes   | "d"
  8 |  1 | yes   | "d"
  6 |  2 | yes   | "d"
  3 |  3 | no    | "d3"
----+----+-------+--------
  3 |  0 | yes   | "d3"
  2 |  1 | yes   | "d3"
  0 |  2 | no    | "d32"

Casi test

f=(n,t=0)=>t<n?f(n-++t,t):t.toString(36)+(n?f(n):'')

console.log(f(1))   // 1
console.log(f(2))   // 11
console.log(f(3))   // 2
console.log(f(4))   // 21
console.log(f(5))   // 211
console.log(f(6))   // 3
console.log(f(100)) // d32
console.log(f(230)) // k5211
console.log(f(435)) // t
console.log(f(665)) // z731

Gelatina , 18 17 byte

Ḥ‘½+.Ḟ©ịØB2®cạµ¹¿

Questo è un collegamento monadico che stampa su STDOUT. Il valore restituito è 0 e deve essere ignorato.

Provalo online!

dc, 74 byte

?sa[2k_1K/1 4/la2*+v+0k1/dlardd*+2/-sadd10<t9>ula0<s]ss[87+P]st[48+P]sulsx

Questo è terribile.

?sa             stores the input
[2k             sets precision to 2 so dc doesn't truncate 1/4
_1K/1 4/la2*+v+ uses the quadratic formula to find k, the next value to print
0k1/d           truncates k to an integer
lardd*+2/-sa    subtracts kth triangular number from the input 
dd10<t9>u       determines whether to print k as a letter or a digit         
la0<s]ss        loops when a is greater than 0
[87+P]st        prints k as a letter
[48+P]su        prints k as a digit (not p, as that leaves a trailing newline)
lsx             starts the main loop

JavaScript (ES6), 61 57 byte

Salvato 4 byte grazie a @Arnauld

f=(n,p=q=0)=>n?p-~q>n?q.toString(36)+f(n-p):f(n,++q+p):''

Java 7, 81 byte

int i=0;String c(int n){return i<n?c(n-++i):Long.toString(i,36)+(n>(i=0)?c(n):"");}

Port da @Arnauld sorprendente risposta s' JavaScript (ES6) .
Il mio approccio era lungo quasi il doppio ..

Provalo qui.

Spiegazione:

int i=0;                  // Temp integer `i` (on class level)
String c(int n){          // Method with integer parameter and String return-type
  return i<n?             //  If `i` is smaller than the input integer
    c(n-++i)              //   Return a recursive call with input minus `i+1` (and raise `i` by 1 in the process)
   :                      //  Else:
    Long.toString(i,36)+  //   Return `i` as Base-36 +
     (n>(i=0)?            //   (If the input integer is larger than 0 (and reset `i` to 0 in the process)
      c(n)                //    Recursive call with the input integer
     :                    //   Else:
      "");                //    an empty String)
}                         // End of method

Retina , 115 108 38 34 byte

.+
$*¶
(\G¶|¶\1)+
0$1
+T`_w¶`w_`.¶

[Provalo online!] (Include la suite di test) Utilizza lettere maiuscole. Modifica: salvato 70 74 byte adattando spudoratamente la risposta di @ MartinEnder a Questo numero è triangolare? Spiegazione: Il numero viene convertito in unario, quindi il numero triangolare più grande possibile viene ripetutamente abbinato fino all'esaurimento del numero. Ogni partita viene quindi convertita nella base 36.

PHP, 74 byte

for(;$n=&$argn;$t.=$i>10?chr($i+86):$i-1)for($i=0;$n>=++$i;)$n-=$i;echo$t;

Versione online

R, 87 byte

Inizialmente, ho provato a preimpostare i possibili numeri triangolari. Ciò ha portato a questo codice con 105 byte:

pryr::f(n,{l=cumsum(1:35)
k=''
while(n){y=tail(which(l<=n),1)
n=n-l[y]
k=paste0(k,c(1:9,letters)[y])}
k})

Ciò ha richiesto più indicizzazione, quindi ho provato la metodologia di @Arnauld per ridurre i byte fino a 87.

pryr::f(n,{k='';while(n){t=0;while(t<n){t=t+1;n=n-t};k=paste0(k,c(1:9,letters)[t])};k})

Entrambi i codici utilizzavano le lettere preimpostate, dal momento che il loro non riuscivo a trovare un modo breve per convertire in base 36.