(Sfida presa da una partita multiplayer (scontro di codice) su codingame.com )

La sfida

Trovare il n termine esimo della seguente sequenza: 1, 1, 2, 1, 2, 3, 1, 2, 3, 4...o, per renderlo più evidente,{1}, {1,2}, {1,2,3}, {1,2,3,4}...

La sequenza è composta da intervalli concatenati da 1 a x , a partire da 1, fino all'infinito.

Regole / IO

L'input e l'output possono essere in qualsiasi formato, purché sia ​​distinguibile. L'input può essere preso da qualsiasi fonte appropriata: STDIN, file, ecc ...

L'input può essere indicizzato 0 o 1 e l'indicizzazione selezionata deve essere menzionata nel post.

Dovrai gestire almeno fino a un risultato compreso di 255 (il che significa che l'ingresso massimo indicizzato 0 è 32640). Tutto ciò che deve essere gestito, se la tua lingua lo supporta.

Questo è code-golfquindi il conteggio dei byte più corto vince!

Casi di test (indicizzazione basata su 0)

0 -> 1
1 -> 1
5 -> 3
10 -> 1
59 -> 5
100 -> 10
1001 -> 12

05AB1E , 5 byte

Il programma è indicizzato 0, codice:

ÌLL¹è

Spiegazione:

Ì       # Double increment the input
 LL     # List of list on the input
   ¹è   # Get nth element

Utilizza la codifica CP-1252 . Provalo online!

Haskell , 27 26 byte

([z|k<-[1..],z<-[1..k]]!!)

Provalo online!

Grazie @DanD. per -1 byte!

Questa è una funzione anonima, creando la sequenza infinita un solo restituire l' nelemento -esimo thereof: [[1..k]| k<-[1..]]produce un elenco infinito di elenco: [[1],[1,2],[1,2,3],[1,2,3,4],...]. Per concatenarli possiamo scrivere il [z|k<-[1..],z<-[1..k]]risultato [1,1,2,1,2,3,1,2,3,4,...]e infine (...!!)accettare l'input n(notazione inutile) e restituire il ntermine -th (basato su 0).

JavaScript, 29 28 byte

-1 byte grazie ad Arnauld!

f=(n,m)=>n++<m?n:f(n+~m,-~m)

Utilizza la formula ricorsiva con 0 indici trovata su OEIS.

Quando viene chiamato con 1 argomento come previsto, il valore di default del secondo m, sarà undefined. Tuttavia, -~undefinedrestituisce 1, che ci consente di avviare la ricorsione senza un esplicito m = 1nell'elenco degli argomenti (grazie @Arnauld!)

Snippet di prova:

f=(n,m)=>n++<m?n:f(n+~m,-~m)

let examples = [0, 1, 5, 10, 15, 1000];

examples.forEach(function log(x) {
    console.log(x, " => ", f(x))
});

In alternativa, per lo stesso numero di byte, possiamo avere una funzione curry in questo modo:

f=n=>m=>n++<m?n:f(n+~m)(-~m)

Puoi chiamarlo con f(5)()- restituisce una funzione, che quando viene chiamata, restituisce il risultato, come descritto in questo meta post .

Gelatina , 5 byte, 1 indicizzata

RRF³ị

Provalo online!

Spiegazione:

                                      (Assume N = 4 for the examples)
R      Generate a list of 1 to N      [1, 2, 3, 4]
 R     Generate new lists for each item on the previous list, with that item as N
                                      [[1], [1,2], ...]
  F    Flatten that list              [1, 1, 2, 1, 2, 3 ...]
   ³ị  Use the input number (³) as index (ị) on the list. 
       This is one-based:             [1, 1, 2, 1, 2, 3 ...] 
                                                ^

Ottava, 39 byte

@(z)z-(n=ceil((8*z+1)^.5/2-.5))*(n-1)/2

1- indice basato

Spiegazione:

Considera questa sequenza:

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

se contiamo il numero di elementi di sottosequenze che abbiamo

1   2        3          4               5         

quindi usando la formula di Gauss per il numero triangolare possiamo formare una formula per z:

z=n*(n+1)/2

questa è un'equazione quadratica se la risolviamo per n abbiamo

n=(sqrt(8*z+1)-1)/2

Provalo online!

Haskell, 25 24 byte

(!!)$[1..]>>= \x->[1..x]

Esempio di utilizzo: ((!!)$[1..]>>= \x->[1..x]) 10-> 1. Provalo online! .

Mappa la funzione anonima make-a-list-from-1-to-x \x->[1..x](il built-in enumFromTo 1è un byte più lungo) all'elenco infinito [1..]e concatena gli elenchi risultanti in un unico elenco. !!seleziona l'ennesimo elemento.

Grazie a @flawr per un byte.

Ottava , 39 byte

@(n){v=1:n,A=triu(v'+0*v),A(A>0)(n)}{3}

Provalo online!

Questo utilizza un approccio alternativo.

Ad esempio, n=1questo A=triu(v'+0*v)crea la matrice

1   1   1   1
0   2   2   2
0   0   3   3
0   0   0   4

Quando rimuoviamo tutti gli elementi zero e accodiamo le colonne A(A>0)otteniamo la sequenza:

1   1  2  1  2  3  1  2  3  4

Quindi si tratta solo di sottrarre il ntermine di quella sequenza.

Python , 39 36 byte

-3 byte grazie a Dennis!

Una lambda ricorsiva che utilizza l'indicizzazione basata su 1.

f=lambda n,m=1:n*(n<=m)or f(n-m,m+1)

Provalo online!

Teniamo traccia delle attuali dimensioni di "aumento" utilizzando m. Se nè inferiore o uguale a m, si inserisce nell'attuale "aumento", e quindi lo restituiamo. Tuttavia, se è più grande di m, lo togliamo m, quindi aggiungiamo 1 a me chiamiamo la funzione in modo ricorsivo (passando al successivo aumento).

R, 25 byte

i=scan();sequence(1:i)[i]

L'indice è basato su 1.

Pyth , 6 5 byte

1 byte salvato grazie a @TheBikingviking!

@s._S

Questo utilizza l'indicizzazione basata su 0.

Provalo online!

Spiegazione

@          Index with implicit input into
   ._      all prefixes of
     S     1-based range of implicit input
 s         concatenated into an un-nested list

Mathematica, 27 24 byte

Grazie @MartinEnder per 3 byte!

((r=Range)@r@#<>1)[[#]]&

1-indicizzati. Ciò genera errori che è possibile ignorare.

Spiegazione

((r=Range)@r@#<>1)[[#]]&
  r=Range                 (* Store Range function in r *)
           r@#            (* Create list {1..n} *)
 (r      )@               (* For each element, generate {1..n} *)
              <>1         (* Join the lists and append a 1; throws errors *)
(                )[[#]]&  (* Take the nth element *)

brainf * ck, 78 byte

,>+<[>[->>+>+<<<]>>>[-<<<+>>>]<<+[->->+<<]>[<<->>>[-<<+>>]<[-]]>[-]<<<+<-]>>+.

Accetta input (basato su 0) e output come valori byte.

Puoi provarlo qui.

L'input richiede un \numero decimale prima (ad es. \10Per 10). Se l'output è un carattere ASCII stampabile, dovresti vederlo. Altrimenti, premi view memory -> dump finale. Il valore che è stato stampato è nella 3a cella (cella numero 2).

Spiegazione:

Cella 0 (INGRESSO): è l'ingresso e viene decrementato il mio 1 ogni volta attraverso il loop.

Cella 1 (RESET): aumenta di 1 ogni volta che è uguale a TERM. Per fare ciò, ogni volta che attraverso il ciclo aggiungiamo 1 e se non sono uguali sottraggiamo 1.

Cella 2 (TERM): aumenta di 1 ogni ciclo ed è impostata su 0 se corrisponde a RESET. Per fare questo, copio il valore indietro da HOLD solo se questa cella non era uguale a RESET.

Cella 3 (EQUAL): viene utilizzata per verificare se RESET e TERM sono uguali.

Cella 4 (HOLD): viene utilizzata per copiare i valori di RESET e TERM dopo il controllo uguale.

,>+<              # get input and put a 1 in RESET
[                 # for INPUT to 0
  >[->>+>+<<<]    # copy RESET to EQUAL and HOLD
  >>>[-<<<+>>>]   # copy HOLD back into RESET
  <<+             # add 1 to TERM
  [->->+<<]       # subtract TERM from EQUAL and copy it to HOLD
  >[              # if RESET and TERM were not equal
    <<-           # subtract 1 from RESET
    >>>[-<<+>>]   # copy HOLD back to TERM
    <[-]          # zero out EQUAL
  ]               # end if
  >[-]            # zero out HOLD
  <<<+            # add 1 to RESET (this cancels out the subtraction if
                  #     RESET did not equal TERM)
  <-              # subtract 1 from INPUT
]>>+.             # end for and add 1 because the sequence resets to 1 not 0

Pyke, 6 byte

OmSsQ@

Provalo qui!

O      -    input+2
 mS    -   map(range(1,i+1), range(^))
   s   -  sum(^)
    Q@ - ^[input]

0-indicizzati.

R, 43 41 byte

Modifica: trovato un approccio ricorsivo più breve utilizzando A002262 + 1 (0 indicizzato):

f=function(n,m=1)`if`(n<m,n+1,f(n-m,m+1))

Vecchia versione:

n=scan();n-choose(floor((1+sqrt(8*n))/2),2)

Formula 1 indicizzata da OEIS.

Perl 6 , 21 byte

{map(|^*,^∞)[$_]+1}

0-indicizzati. Provalo online!

Come funziona:

{                 }  # A lambda.
         ^∞          # Range from 0 to Inf-1. (Same byte count as 0..*, but cooler.)
 map( ^*,  )         # Map each number n to the range 0..(n-1),
     |               # And slip each range into the outer list.
            [$_]     # Index the sequence with the lambda argument.
                +1   # Add 1.

Perl 6 , 21 byte

{[\,](1..*).flat[$_]}

0-indicizzati. Provalo online!

Come funziona:

{                   }  # A lambda.
      1..*             # Range from 1 to infinity.
 [ ,](    )            # Fold it with the comma operator,
  \                    # and return all intermediate results, e.g. (1), (1,2), (1,2,3)...
           .flat       # Flatten the sequence.
                [$_]   # Index it with the lambda argument.

Nessuna di queste soluzioni è breve come quella di JungHawn Min , ma sono approcci alternativi, il che è qualcosa che immagino. Entrambe sono funzioni senza nome che accettano un input intero positivo (1-indicizzato) e restituiscono un intero positivo.

Mathematica, 30 byte

-#^2-#&@⌈√(2#)-3/2⌉/2+#&

Una vera formula matematica per questa funzione! Fatto più leggibile (in parte traducendo i caratteri 3 byte ⌈, √e ⌉):

# - ((#^2 + #) / 2 &)[Ceiling[Sqrt[2 * #] - 3/2]] &

Ceiling[Sqrt[2 * #] - 1/2]ci dice a quale lista secondaria fa riferimento l'input, da cui sottraggiamo uno per dirci quale elenco secondario termina prima di arrivare all'input; quindi ((#^2 + #) / 2 &)calcola il numero di elementi presenti in tutte le liste secondarie prima di quello a cui teniamo, che sottraiamo dall'input #per ottenere la nostra risposta. (Alcuni noteranno la formula familiare (#^2 + #) / 2per il #numero triangolare;Ceiling[Sqrt[2 * #] - 1/2] è essenzialmente la funzione inversa.)

Mathematica, 32 byte

If[#2<=#,#2,#0[#+1,#2-#]]&[1,#]&

Soluzione ricorsiva, sostanzialmente la stessa della risposta di Billywob e di altri.

Brain-Flak , 46 byte

Zero indicizzato

(<>()){(({}())[()]){({}[()])<>}{}}<>([{}()]{})

Provalo online!

Stack pulito, 48 byte

(<>()){(({}())[()]){({}[()])<>}{}}{}<>([{}()]{})

Provalo online!

Spiegazione

Questa è una versione modificata della funzione modulo . Invece di usare un numero costante come divisore, incrementa il divisore per ogni volta che il divisore viene sottratto da esso (una volta per iterazione del ciclo esterno).

Codice annotato

(<>())       # Switch to the opposite stack and push 1 (the initial divisor)
{            # (outside loop) While top of stack is not 0...
  (          # Push...
    ({}())   # Push the divisor plus 1
  [()])      # ...minus one (ie push a copy of the original divisor
  {          # (inner loop) While the top of stack does not equal zero
    ({}[()]) # Decrement the top of the active stack
    <>       # Switch stacks
  }{}        # (inside loop) End loop and pop zero off the top of stack)
}            # (outside loop) End loop
<>           # Switch stacks (to the one with the divisor)
([{}()]{})   # Calculate the result

Java 8, 85 73 55 byte

n->f(n,1)+1int f(int n,int m){return n<m?n:f(n-m,m+1);}

Approccio ricorsivo a 0 indici con la formula fornita nell'OEIS :

a(n) = 1 + A002262(n).
A002262 : a(n)=f(n,1)con f(n,m) = if n<m then n else f(n-m,m+1).

Provalo qui.

Vecchia risposta ( 85 56 byte):

n->{int m=~-(int)Math.sqrt(8*n+1)/2;return n-m*-~m/2+1;}

Utilizzata l'altra formula indicizzata 0 fornita nell'OEIS :

l'ennesimo termine è n - m*(m+1)/2 + 1dove m = floor((sqrt(8*n+1) - 1) / 2).

Provalo qui.

Perl , 30 byte

29 byte di codice + -pflag.

map{$\-=$c++if$c<++$\}0..$_}{

Provalo online!

MATL, 8 byte

:"@:]vG)

Questa soluzione utilizza l'indicizzazione basata su 1

Provalo su MATL Online

Spiegazione

        Implicitly grab input (N)
:       Create an array from [1...N]
"       For each element (A) in this array...
  @:    Create an array from [1....A]
]       End for loop
v       Vertically concatenate everything on the stack
G       Explicitly grab the input again
)       And use it to index into the vertically concatenated array
        Implicitly display the result

QBIC , 21 byte, 1 indicizzato

:[a|[b|~q=a|_Xc\q=q+1

Spiegazione:

:      Get 'a' from the cmd line
[a|    FOR (b = 1; b <= a; b++) This creates an outer loop from 1 to N
[b|    FOR (c = 1; c <= b; c++) This creates an iteration, yielding the 1, 12, 123 pattern
       'q' stores how many terms we've seen. It starts at 1 b default.
~q=a   if we are at the desired term (q == a)
|_Xc   Then quit, and print 'c' (the current number in the sequence)
\q=q+1 Else, increase 'q' and run again.

Approccio leggermente più interessante, ma 10 byte in più:

:{~b+q>=a|_xa-b|\b=b+q┘q=q+1

Questo programma calcola continuamente il numero totale di numeri in questa parentesi e tutti quelli precedenti (1 at loop 1, 3 at loop 2, 6 at loop 3 ... ). Quando quel contatore supera l'indice N richiesto, quindi restituisce X dalla parentesi corrente, dove X è N meno la quantità precedente del contatore.

Rubino, 30 byte

->n{(0..n).find{|x|0>=n-=x}+n}

Indicizzazione basata su 1

R, 37 byte

n=scan();for(i in 2:n)T=c(T,1:i);T[n]

Riceve input da ne crea la sequenza per la priman sequenze. Questo lo rende in qualche modo inefficiente con input più alti, ma dovrebbe andare bene. Quindi restituisce iln -esima voce, 1-indicizzata.

Utilizza un piccolo trucco iniziando con la sequenza T, che è TRUEo 1per impostazione predefinita.

C11, 48 byte

int f(int x){int q=1;while(x>q)x-=q++;return x;}

Provalo online!

Funziona anche in C ++ e Java.

Un'alternativa per lo stesso conteggio byte:

int f(int x){int q=0;while(x>++q)x-=q;return x;}

Brainfuck, 141 byte

So di essere in ritardo per la taglia, ma volevo solo vedere quanti byte l'algoritmo a cui pensavo sarebbe finito.

Questo programma è a zero.

,>+<[[->>+>+<<<]>>[-<<+>>]<[->+>>+<<<]>[-<+>]>>+[[-<->>+<]>[-<+>]<<<<]>>[>>>]>[.[<<<]]<<<<<<<[[-]>>>[-<+<<+>>>]<[->+<]<<<<<]>>>[>>>]<<<]>[.>]

Provalo online

• Seleziona memoria dinamica (infinita) , altrimenti non funzionerà
• Per testare i valori di input> 255, modifica Dimensione cella (Bit) su 16 o 32 .
• L'interprete spiega come dare input. Per input decimale utilizzare \5per input di 5.
  • Il massimo valore decimale con cui è possibile verificare l'input è \999
  • L'input esadecimale può arrivare fino alla dimensione della cella.

Spiegazione:

Questo mostra il programma suddiviso per passaggio, mostrando cosa succede per l'input di 5. #sono collocati nelle posizioni ideali di dump della memoria per l'interprete.

Probabilmente vorrai usare la casella Dump Memory al char:# se stai eseguendo questa versione. Questo scaricherà la memoria al momento del colpo #, permettendoti di vedere il valore sul nastro nel caso in cui si tratti di un carattere non stampabile o di vedere cosa succede in ogni passaggio desiderato. La cella su cui si trova il puntatore sarà in grassetto.

,>+<                       (5) 1
[[->>+>+<<<]>>[-<<+>>]       5 1 (0) 5
<[->+>>+<<<]>[-<+>]>>+       5 1 0 5 (2)
[[-<->>+<]>[-<+>]<<<<] (0) 0 4 1 0 3 2 0 0
>>[>>>]                      4 1 0 3 2 0 (0) 0
                             1 1 0 (0) 2 0
>[.#[<<<]]<<<<                4 1 0 (3) 2 0 0 0
<<<[[-]>>>[-<+<<+>>>]<[->+<]<<<<<]>>> (3) 1 0 3 2 0 0 0
[>>>]<<<]>[.#>]

Tape structure:
    (cell_1 cell_2 temp), (cell_1 cell_2 temp), ...

Take Input;
If not zero:
  copy last pair to the right and add one to its cell_2
  subtract each cell_2 from each cell_1 (leaving each cell_2 intact)
  move checking from left to right: 
    If cell_1 is zero and cell_2 isn't:
      print cell_2
    Else:
      copy last cell_1 back, overwriting each previous cell_1
Else:
  right one and print result

Provalo online

• Seleziona Memoria dinamica (infinita) , altrimenti non funzionerà
• Memoria di dump al char: #

Gli appunti:

• Per eseguirlo su un altro interprete che non consente di spostarsi a sinistra della cella iniziale (ecco perché utilizzo la memoria dinamica), inseriscilo >all'inizio. Il numero richiesto può variare in base al valore di input, ma è O (1).

tinylisp ( sostitu ), 90 byte (indicizzato 0)

(d r(q((n j x)(i n(i(e j x)(r(s n 1)1(s x(s 0 1)))(r(s n 1)(s j(s 0 1))x))j
(q((n)(r n 1 1

Oppure, non competitiva (utilizzando una funzione che è stata impegnata dopo la pubblicazione di questa sfida), 80 byte :

(d r(q((n j x)(i n(i(e j x)(r(s n 1)1(a x 1))(r(s n 1)(a j 1)x))j
(q((n)(r n 1 1

La prima riga definisce una funzione di supporto re la seconda riga è una funzione senza nome che accetta ne restituisce l'ennesimo termine della sequenza. L'ho specificato come invio sostitutivo perché il rimpiazzo completa automaticamente le parentesi alla fine di ogni riga, non solo alla fine del programma. Con questi avvertimenti, ecco una versione modificata per funzionare su Provalo online , ed ecco una versione non golfata eseguita contro gli input da 0 a 54.

Spiegazione

Userò la versione non competitiva qui. L'unica differenza è che la versione ufficiale deve implementare l'addizione come due sottrazioni.

(d r           Define r to be:
 (q(           A lambda function (= a list of two elements, quoted to prevent evaluation):
  (n j x)       Arguments n, j (the range counter), and x (the range limit)
  (i n          If n is truthy, i.e. nonzero:
   (i(e j x)     If counter equals limit:
    (r            Call r recursively on:
     (s n 1)       n-1
     1             counter reset to 1
     (a x 1))      limit increased by 1
    (r           Else, call r recursively on:
     (s n 1)       n-1
     (a j 1)       counter increased by 1
     x))           same limit
   j))))        Else, we're done; return the counter value

(q(            Lambda function:
 (n)            Argument n
 (r n 1 1)))    Call r with n, counter = 1, range limit = 1

C, 54 byte

Non è la soluzione C più corta, ma ha il merito di correre a tempo costante (niente loop, solo matematica). Utilizza l'indicizzazione in base zero:

x;f(n){x=floor(sqrt(8*n+1)-1)/2;return 1+n-x*(x+1)/2;}

Ungolfed:

int f(int n) {
    int x = floor(sqrt(8*n+1)-1)/2; //calculate the number of the current subsequence (zero based)
    return 1+n-x*(x+1)/2;   //x*(x+1)/2 is the zero based index of the `1` starting the subsequence
}

Prova con:

#include <math.h>
#include <assert.h>
#include <stdio.h>

x;f(n){x=floor(sqrt(8*n+1)-1)/2;return 1+n-x*(x+1)/2;}

int main(){
    int i;
    for(i = 0; i < 10; i++) printf("%d ", f(i));
    printf("\n");

    assert(f(0) == 1);
    assert(f(1) == 1);
    assert(f(5) == 3);
    assert(f(10) == 1);
    assert(f(59) == 5);
    assert(f(100) == 10);
    assert(f(1001) == 12);
}

C, 103 byte

Per un mendicante va bene, penso :).

int main(){int n,c,i,j;scanf("%d",&n);while(c<n){for(i=1;i<=j;i++){c++;if(c==n)printf("%d",i);}j++;}}

o il modo formattato

#include <stdio.h>

int main() {
    int n,c,i,j;
    scanf("%d",&n);
    while(c<n) 
    {
        for(i=1;i<=j;i++)
        {
            c++;
            if(c==n) printf("%d",i);
        }
        j++;
    }
}

dc , 21 byte, indicizzazione basata su 0

?d8*1+v1-2/d1+*2/-1+p

Prova il programma dc online!

Spiegazione:

?      Push input number n.
d      Duplicate n at the top of the stack.
8*1+   Replace n at the top of the stack with 8n+1.
v      Replace 8n+1 at the top of the stack with the floor of its square root.
1-2/   Subtract 1, and divide by 2 (ignoring any fractional part).

La parte superiore della pila ora contiene l'indice k del massimo numero triangolare che è <= n.

d1+*2/ Compute k(k+1)/2, which is the greatest triangular number <= n.
-      Subtract n-(the greatest triangular number <= n). The first n is on the stack in position 2, because the input number n was duplicated at the top of the stack at the very beginning of the program, and only one of the values was popped and used (until now).
1+     Add 1 because the desired sequence starts over again at 1 (not 0) at every triangular number.
p      Print the answer.

Questo programma in cc può essere convertito in uno script bash di dimensioni competitive:

Utilità Bash + Unix, 28 byte, indicizzazione basata su 0

dc -e"?d8*1+v1-2/d1+*2/-1+p"

Prova il programma bash online!

C, 81 44 byte

metodo iterativo diretto, indicizzato 0, e con un leggero massaggio;

m=1,c=1;f(n){for(;n--;c=c^m?c+1:!!++m);c=c;}

Provalo online!