(Défi tiré d'un jeu multijoueur (conflit de code) sur codingame.com )

Le défi

Trouvez le n- ième terme de la séquence suivante: 1, 1, 2, 1, 2, 3, 1, 2, 3, 4...ou, pour le rendre plus évident,{1}, {1,2}, {1,2,3}, {1,2,3,4}...

La séquence est composée de plages concaténées de 1 à x , allant de 1 à l'infini.

Règles / IO

L'entrée et la sortie peuvent être dans n'importe quel format, à condition qu'elles soient distinguables. Les entrées peuvent être prises à partir de n’importe quelle source appropriée: STDIN, fichier, etc.

L'entrée peut être indexée 0 ou 1, et l'indexation sélectionnée doit être mentionnée dans l'article.

Vous devrez gérer au moins un résultat de 255 inclus (ce qui signifie que l'entrée maximale indexée par 0 est 32640). Tout ce qui a été traité doit être géré si votre langue le permet.

C'est code-golfle nombre d'octets le plus court qui gagne!

Cas de test (indexation basée sur 0)

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

05AB1E , 5 octets

Le programme est indexé par 0, code:

ÌLL¹è

Explication:

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

Utilise le codage CP-1252 . Essayez-le en ligne!

Haskell , 27 à 26 octets

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

Essayez-le en ligne!

Merci @DanD. pour -1 octet!

Ceci est une fonction anonyme, ce qui crée la séquence infinie un juste retour du nson -ième élément: [[1..k]| k<-[1..]]produit une liste infinie de la liste: [[1],[1,2],[1,2,3],[1,2,3,4],...]. Pour concaténer ceux-ci, nous pouvons écrire [z|k<-[1..],z<-[1..k]]ce qui aboutit [1,1,2,1,2,3,1,2,3,4,...]et finalement (...!!)accepte l’entrée n(notation sans point) et renvoie le n-th terme (basé sur 0).

JavaScript, 29 28 octets

-1 octet grâce à Arnauld!

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

Utilise la formule récursive à indice 0 trouvée dans OEIS.

Lorsqu'il est appelé avec 1 argument comme prévu, la valeur par défaut du second m, sera undefined. Cependant, -~undefinedretourne 1, ce qui nous permet de faire rouler la récursivité sans explicite m = 1dans la liste des arguments (merci @Arnauld!)

Extrait de test:

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

Alternativement, pour le même nombre d'octets, nous pouvons avoir une fonction curry comme ceci:

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

Vous pouvez appeler cela avec f(5)()- il renvoie une fonction qui, lorsqu'elle est appelée, renvoie le résultat, comme décrit dans cette méta publication .

Gelée , 5 octets, 1 indexé

RRF³ị

Essayez-le en ligne!

Explication:

                                      (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 ...] 
                                                ^

Octave, 39 octets

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

Indice basé sur 1

Explication:

Considérons cette séquence:

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

si nous comptons le nombre d'éléments de sous-séquences que nous avons

1   2        3          4               5         

donc en utilisant la formule de Gauss pour les nombres triangulaires, nous pouvons former une formule pour z:

z=n*(n+1)/2

c'est une équation du second degré si nous le résolvons pour n nous avons

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

Essayez-le en ligne!

Haskell, 25 à 24 octets

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

Exemple d'utilisation: ((!!)$[1..]>>= \x->[1..x]) 10-> 1. Essayez-le en ligne! .

Mappe la fonction anonyme make-a-list-from-1-to-x \x->[1..x](l'intégration enumFromTo 1est un octet plus long) à la liste infinie [1..]et concatène les listes résultantes en une liste unique. !!choisit le nième élément.

Merci à @flawr pour un octet.

Octave , 39 octets

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

Essayez-le en ligne!

Ceci utilise une approche alternative.

Par exemple, n=1cela A=triu(v'+0*v)crée la matrice

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

En supprimant tous les éléments nuls et en ajoutant les colonnes par, A(A>0)on obtient la séquence:

1   1  2  1  2  3  1  2  3  4

Ensuite, il suffit d'extraire le ième nterme de cette séquence.

Python , 39 36 octets

-3 octets grâce à Dennis!

Un lambda récursif qui utilise l'indexation basée sur 1.

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

Essayez-le en ligne!

Nous gardons une trace de la "taille" actuelle en utilisant m. Si nest inférieur ou égal à m, il correspond à la "hausse" actuelle et nous le renvoyons donc. Cependant, si sa taille est supérieure à m, nous la msupprimons plutôt que d'ajouter 1 met d'appeler la fonction de manière récursive (en passant à la prochaine hausse).

R, 25 octets

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

L'indice est basé sur 1.

Pyth , 6 5 octets

1 octet enregistré grâce à @TheBikingviking!

@s._S

Ceci utilise l'indexation basée sur 0.

Essayez-le en ligne!

Explication

@          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 octets

Merci @MartinEnder pour 3 octets!

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

1 indexé. Cela génère des erreurs que vous pouvez ignorer en toute sécurité.

Explication

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

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

Prend les entrées (basées sur 0) et les sorties sous forme d'octets.

Vous pouvez le tester ici.

La saisie nécessite un nombre \avant décimal (par exemple, \10pour 10). Si la sortie est un caractère ASCII imprimable, vous devriez le voir. Sinon, appuyez sur view memory -> final dump. La valeur qui a été imprimée est dans la 3ème cellule (numéro de cellule 2).

Explication:

Cellule 0 (ENTREE): est l'entrée et est décrémentée de 1 chaque fois dans la boucle.

Cellule 1 (RESET): incrémente de 1 chaque fois qu'elle est égale à TERM. Pour ce faire, nous ajoutons 1 à chaque boucle de la boucle et soustrayons 1.

Cellule 2 (TERM): incrémente de 1 chaque boucle et est définie sur 0 si elle correspond à RESET. Pour ce faire, je ne recopie la valeur de HOLD que si cette cellule n’est pas égale à RESET.

Cellule 3 (EQUAL): permet de vérifier si RESET et TERM sont égaux.

Cellule 4 (HOLD): permet de copier les valeurs de RESET et TERM après le contrôle d’égal.

,>+<              # 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 octets

OmSsQ@

Essayez-le ici!

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

0 indexé.

R, 43 41 octets

Edit: trouvé une approche récursive plus courte en utilisant A002262 + 1 (0 indexé):

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

Ancienne version:

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

Formule 1-indexée d'OEIS.

Perl 6 , 21 octets

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

0 indexé. Essayez-le en ligne!

Comment ça marche:

{                 }  # 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 octets

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

0 indexé. Essayez-le en ligne!

Comment ça marche:

{                   }  # 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.

Aucune de ces solutions n'est aussi courte que celle de JungHawn Min , mais ce sont des approches alternatives, ce que je suppose. Les deux sont des fonctions sans nom prenant une entrée d’entier positif (indexé 1) et renvoyant un entier positif.

Mathematica, 30 octets

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

Une formule mathématique réelle pour cette fonction! Fait plus lisible (en partie en traduisant les caractères 3 octets ⌈, √et ⌉):

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

Ceiling[Sqrt[2 * #] - 1/2]nous dit à quelle sous-liste se réfère l'entrée, à laquelle nous soustrayons un pour nous dire quelle sous-liste se termine avant d'arriver à l'entrée; puis ((#^2 + #) / 2 &)calcule le nombre d’éléments contenus dans toutes les sous-listes avant celle qui nous intéresse, que nous soustrayons de l’entrée #pour obtenir notre réponse. (Certains remarqueront la formule familière (#^2 + #) / 2pour le #nombre triangulaire th; Ceiling[Sqrt[2 * #] - 1/2]est essentiellement la fonction inverse.)

Mathematica, 32 octets

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

Solution récursive, fondamentalement la même que dans la réponse de Billywob et d’autres.

Brain-Flak , 46 bytes

Zéro indexé

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

Essayez-le en ligne!

Stack Clean, 48 octets

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

Essayez-le en ligne!

Explication

Ceci est une version modifiée de la fonction modulo . Au lieu d'utiliser un nombre constant comme diviseur, il incrémente le diviseur à chaque fois que le diviseur en est soustrait (une fois par itération de la boucle extérieure).

Code annoté

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

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

Approche récursive indexée par 0 avec la formule fournie dans l' OEIS :

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

Essayez ici.

Ancienne réponse ( 85 56 octets):

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

Utilisation de l’autre formule à indexation 0 fournie dans le système OEIS :

ième terme est n - m*(m+1)/2 + 1, où m = floor((sqrt(8*n+1) - 1) / 2).

Essayez ici.

Perl , 30 octets

29 octets de code + -pdrapeau.

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

Essayez-le en ligne!

MATL, 8 octets

:"@:]vG)

Cette solution utilise l'indexation 1

Essayez-le sur MATL Online

Explication

        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 octets, 1 indexé

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

Explication:

:      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.

Approche légèrement plus intéressante, mais 10 octets de plus:

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

Ce programme calcule en continu le nombre total de nombres dans cette tranche et tous les précédents ( 1 at loop 1, 3 at loop 2, 6 at loop 3 ...). Lorsque ce compteur dépasse l'indice N recherché, retournez X depuis le support actuel, où X est N moins le montant précédent du compteur.

Ruby, 30 octets

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

Indexation basée sur 1

R, 37 octets

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

Prend une entrée à partir de net crée la séquence pour les premières nséquences. Cela le rend quelque peu inefficace avec des intrants plus élevés, mais ça devrait aller. Il retourne ensuite la n-ème entrée, 1-indexée.

Utilise une petite astuce en commençant par la séquence avec T, qui est TRUEou 1par défaut.

C11, 48 octets

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

Essayez-le en ligne!

Fonctionne également en C ++ et Java.

Une alternative pour le même nombre d'octets:

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

brainfuck, 141 octets

Je sais que je suis trop tard pour la prime, mais je voulais simplement savoir combien d'octets l'algorithme auquel je pensais serait destiné.

Ce programme est indexé à zéro.

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

Essayez-le en ligne

• Sélectionnez la mémoire dynamique (infinie) , ou cela ne fonctionnera pas
• Pour tester les valeurs d'entrée> 255, définissez Taille de la cellule (bits) sur 16 ou 32 .
• L'interprète explique comment entrer. Pour une entrée décimale, utilisez \5pour entrer 5.
  • La valeur décimale maximale avec laquelle vous pouvez tester l’entrée est \999
  • L'entrée hexadécimale peut aller aussi haut que la taille de la cellule.

Explication:

Cela montre le programme divisé en étapes, montrant ce qui se passe pour la saisie de 5. #sont placés dans les emplacements de vidage de mémoire idéaux pour l'interprète.

Vous voudrez probablement utiliser la case à cocher Dump Memory at char:# si vous utilisez cette version. Cela videra la mémoire lors de la frappe #, ce qui vous permettra de voir la valeur sur la bande dans le cas où il s'agirait d'un caractère non imprimable, ou de voir ce qui se passe à n'importe quelle étape de votre choix. La cellule sur laquelle se trouve le pointeur sera en gras.

,>+<                       (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

Essayez-le en ligne

• Sélectionnez la mémoire dynamique (infinie) , ou cela ne fonctionnera pas
• Dump Memory at char: #

Remarques:

• Pour exécuter ceci sur un autre interpréteur qui ne permet pas de se déplacer vers la gauche de la cellule de départ (c'est pourquoi j'utilise la mémoire dynamique), insérez plusieurs éléments >au début. Le nombre requis peut varier en fonction de la valeur d'entrée, mais est O (1).

tinylisp ( repl ), 90 octets (indexé par 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

Ou, non en concurrence (à l'aide d'une fonctionnalité validée après la publication de ce défi), 80 octets :

(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 première ligne définit une fonction d'assistance ret la deuxième ligne est une fonction non nommée qui prend net retourne le nième terme de la séquence. J'ai spécifié cela en tant que soumission de réplication, car la réplication complète automatiquement les parenthèses à la fin de chaque ligne, pas seulement à la fin du programme. Avec ces mises en garde, voici une version modifiée pour fonctionner sur Essayez-le en ligne , et voici une version non-golfée exécutée sur les entrées 0 à 54.

Explication

Je vais utiliser la version non compétitive ici. La seule différence est que la version officielle doit implémenter l'addition sous forme de deux soustractions.

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

Ce n'est pas la solution C la plus courte, mais elle a le mérite de fonctionner en temps constant (pas de boucles, juste des maths). Il utilise l'indexation à base zéro:

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
}

Test avec:

#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 octets

Pour un débutant, ça va, je pense :).

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

ou la manière formatée

#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 octets, indexation basée sur 0

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

Essayez le programme en ligne!

Explication:

?      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).

Le sommet de la pile contient maintenant l'indice k du plus grand nombre triangulaire qui est <= 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.

Ce programme en continu peut être converti en un script bash de taille compétitive:

Utilitaires Bash + Unix, 28 octets, indexation basée sur 0

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

Essayez le programme bash en ligne!

C, 81 44 octets

méthode itérative droite, 0 indexée et avec un léger massage;

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

Essayez-le en ligne!