(Desafio retirado de um jogo multiplayer (confronto de código) em codingame.com )

O desafio

Encontre o n- ésimo termo da seguinte sequência: 1, 1, 2, 1, 2, 3, 1, 2, 3, 4...ou, para torná-lo mais óbvio,{1}, {1,2}, {1,2,3}, {1,2,3,4}...

A sequência é composta de intervalos concatenados de 1 a x , começando em 1, até o infinito.

Regras / IO

A entrada e a saída podem estar em qualquer formato, desde que sejam distinguíveis. A entrada pode ser obtida de qualquer fonte apropriada: STDIN, arquivo, etc ...

A entrada pode ser indexada em 0 ou 1 e a indexação selecionada deve ser mencionada na publicação.

Você precisará manipular pelo menos até um resultado de 255 inclusive (o que significa que a entrada máxima indexada em 0 é 32640). Qualquer coisa além disso deve ser tratada, se o seu idioma suportar.

É code-golfassim que a menor contagem de bytes vence!

Casos de teste (indexação baseada em 0)

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

05AB1E , 5 bytes

O programa é indexado em 0, código:

ÌLL¹è

Explicação:

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

Usa a codificação CP-1252 . Experimente online!

Haskell , 27 26 bytes

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

Experimente online!

Obrigado @DanD. para -1 byte!

Esta é uma função anônima, criando a sequência infinita de apenas retornar o nelemento -ésimo mesmo: [[1..k]| k<-[1..]]produz uma lista infinita de lista: [[1],[1,2],[1,2,3],[1,2,3,4],...]. Para concatená-las, podemos escrever [z|k<-[1..],z<-[1..k]]quais resultam [1,1,2,1,2,3,1,2,3,4,...]e finalmente (...!!)aceitam a entrada n(notação sem sentido) e retornam o n-ésimo termo (com base em 0).

JavaScript, 29 28 bytes

-1 byte graças a Arnauld!

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

Usa a fórmula recursiva indexada em 0 encontrada no OEIS.

Quando chamado com 1 argumento conforme o esperado, o valor padrão do segundo m,, será undefined. No entanto, -~undefinedretorna 1, que permite que a recursão seja m = 1executada sem um explícito na lista de argumentos (obrigado @Arnauld!)

Snippet de teste:

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

Como alternativa, para a mesma contagem de bytes, podemos ter uma função ao curry da seguinte forma:

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

Você pode chamar isso com f(5)()- ele retorna uma função que, quando chamada, retorna o resultado, conforme descrito nesta meta post .

Geléia , 5 bytes, 1 indexado

RRF³ị

Experimente online!

Explicação:

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

Oitava, 39 bytes

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

1- índice baseado

Explicação:

Considere esta sequência:

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

se contarmos o número de elemento de subsequências, temos

1   2        3          4               5         

então, usando a fórmula de Gauss para número triangular , podemos formar uma fórmula para z:

z=n*(n+1)/2

que é uma equação quadrática se resolvermos por n temos

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

Experimente Online!

Haskell, 25 24 bytes

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

Exemplo de uso: ((!!)$[1..]>>= \x->[1..x]) 10-> 1. Experimente online! .

Mapeia a função anônima de fazer uma lista de 1 para x \x->[1..x](o interno enumFromTo 1é um byte a mais) para a lista infinita [1..]e concatena as listas resultantes em uma única lista. !!escolhe o enésimo elemento.

Graças a @flawr por um byte.

Oitava , 39 bytes

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

Experimente online!

Isso usa uma abordagem alternativa.

Por exemplo, n=1isso A=triu(v'+0*v)cria a matriz

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

Ao remover todos os elementos zero e anexar as colunas A(A>0), obtemos a sequência:

1   1  2  1  2  3  1  2  3  4

Então, é apenas uma questão de extrair o n-ésimo termo dessa sequência.

Python , 39 36 bytes

-3 bytes graças a Dennis!

Um lambda recursivo que usa indexação baseada em 1.

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

Experimente online!

Nós acompanhamos o tamanho atual do "aumento" usando m. Se nfor menor ou igual a m, ele se encaixa no atual "aumento" e, portanto, o devolvemos. No entanto, se for maior que m, mafastamos-o, adicione 1 me chame a função recursivamente (passando para a próxima subida).

R, 25 bytes

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

O índice é baseado em 1.

Pitão , 6 5 bytes

1 byte salvo graças a @TheBikingviking!

@s._S

Isso usa indexação baseada em 0.

Experimente online!

Explicação

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

Obrigado @MartinEnder por 3 bytes!

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

1 indexado. Isso gera erros que são seguros para ignorar.

Explicação

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

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

Recebe entrada (com base em 0) e saídas como valores de bytes.

Você pode testá-lo aqui.

A entrada requer um \número decimal anterior (por exemplo, \10para 10). Se a saída for um caractere ASCII imprimível, você deverá vê-lo. Caso contrário, clique em ver memória -> despejo final. O valor impresso está na 3ª célula (número da célula 2).

Explicação:

Célula 0 (ENTRADA): é a entrada e é decrementada minha 1 cada vez que passa pelo loop.

Célula 1 (RESET): aumenta em 1 toda vez que é igual a TERM. Para fazer isso, sempre que adicionamos 1 ao loop, subtraímos 1.

Célula 2 (TERM): aumenta em 1 a cada loop e é definido como 0 se corresponder a RESET. Para fazer isso, copio apenas o valor de HOLD se essa célula não for igual a RESET.

Célula 3 (EQUAL): é usada para verificar se RESET e TERM são iguais.

Célula 4 (HOLD): é usada para copiar os valores de RESET e TERM de volta após a verificação de igual.

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

OmSsQ@

Experimente aqui!

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

Indexado a 0.

R, 43 41 bytes

Edit: Encontrou uma abordagem recursiva mais curta usando A002262 + 1 (0 indexado):

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

Versão antiga:

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

Fórmula 1-indexada da OEIS.

Perl 6 , 21 bytes

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

Indexado a 0. Experimente online!

Como funciona:

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

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

Indexado a 0. Experimente online!

Como funciona:

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

Nenhuma dessas soluções é tão curta quanto a de JungHawn Min , mas são abordagens alternativas, o que é algo que eu acho. Ambas são funções sem nome, recebendo uma entrada inteira positiva (indexada em 1) e retornando um número inteiro positivo.

Mathematica, 30 bytes

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

Uma fórmula matemática real para esta função! Feita mais legível (em parte, ao traduzir os caracteres de 3 bytes ⌈, √e ⌉):

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

Ceiling[Sqrt[2 * #] - 1/2]nos diz a qual sublista a entrada se refere, da qual subtraímos uma para nos dizer qual sublista termina antes de chegarmos à entrada; depois ((#^2 + #) / 2 &)calcula quantos elementos ocorrem em todas as sublistas anteriores àquela com a qual nos preocupamos, que subtraímos da entrada #para obter nossa resposta. (Alguns notarão a fórmula familiar (#^2 + #) / 2para o #th número triangular;Ceiling[Sqrt[2 * #] - 1/2] é essencialmente a função inversa.)

Mathematica, 32 bytes

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

Solução recursiva, basicamente a mesma que na resposta de Billywob e outras.

Brain-Flak , 46 bytes

Zero indexado

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

Experimente online!

Pilha limpa, 48 bytes

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

Experimente online!

Explicação

Esta é uma versão modificada da função modulo . Em vez de usar um número constante como divisor, ele aumenta o divisor para cada vez que o divisor é subtraído (uma vez por iteração de loop externo).

Código anotado

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

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

Abordagem recursiva indexada a 0 com a fórmula fornecida no OEIS :

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

Experimente aqui.

Resposta antiga ( 85 56 bytes):

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

Usou a outra fórmula indexada em 0 fornecida no OEIS :

n-ésimo termo é n - m*(m+1)/2 + 1onde m = floor((sqrt(8*n+1) - 1) / 2).

Experimente aqui.

Perl , 30 bytes

29 bytes de código + -psinalizador.

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

Experimente online!

MATL, 8 bytes

:"@:]vG)

Esta solução usa indexação baseada em 1

Experimente no MATL Online

Explicação

        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 bytes, 1 indexado

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

Explicação:

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

Abordagem um pouco mais interessante, mas com 10 bytes a mais:

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

Este programa calcula continuamente o número total de números neste colchete e todos os anteriores ( 1 at loop 1, 3 at loop 2, 6 at loop 3 ...). Quando esse contador exceder o índice N procurado, retorne X do colchete atual, onde X é N menos o valor anterior do contador.

Ruby, 30 bytes

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

Indexação baseada em 1

R, 37 bytes

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

Recebe entrada ne cria a sequência para as primeiras nseqüências. Isso o torna um pouco ineficiente em entradas mais altas, mas deve estar bem. Em seguida, retorna on -ésima entrada, indexada em 1.

Usa um pequeno truque, iniciando a sequência com T, que é TRUEou 1por padrão.

C11, 48 bytes

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

Experimente online!

Também funciona em C ++ e Java.

Uma alternativa para a mesma contagem de bytes:

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

brainfuck, 141 bytes

Eu sei que estou muito atrasado para a recompensa, mas eu só queria ver quantos bytes o algoritmo que eu pensava acabaria sendo.

Este programa é indexado em zero.

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

Experimente online

• Selecione memória dinâmica (infinita) ou não funcionará
• Para testar os valores de entrada> 255, altere o tamanho da célula (bits) para 16 ou 32 .
• O intérprete explica como dar entrada. Para entrada decimal, use \5a entrada de5 .
  • O valor decimal máximo com o qual você pode testar a entrada é \999
  • A entrada hexadecimal pode aumentar o tamanho da célula.

Explicação:

Isso mostra o programa dividido por etapas, mostrando o que acontece para a entrada de 5.#são colocados nos locais ideais de despejo de memória para o intérprete.

Você provavelmente desejará usar a caixa de seleção Dump Memory em char:# se estiver executando esta versão. Isso irá despejar a memória ao bater #, permitindo que você veja o valor na fita no caso de ser um caractere não imprimível ou o que acontece em qualquer etapa que você desejar. A célula em que o ponteiro está estará em negrito.

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

Experimente online

• Selecione Memória dinâmica (infinita) ou não funcionará
• Despejar memória no char: #

Notas:

• Para executar isso em outro intérprete que não permite mover para a esquerda da célula inicial (é por isso que eu uso a Memória dinâmica), coloque um monte >no início. O número necessário pode variar dependendo do valor de entrada, mas é O (1).

tinylisp (repl), 90 bytes (indexado 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, não concorrente (usando um recurso confirmado após o lançamento deste desafio), 80 bytes :

(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

A primeira linha define uma função auxiliar re a segunda linha é uma função sem nome que pega ne retorna o enésimo termo da sequência. Especifiquei isso como um envio de repl, porque o repl preenche parênteses no final de cada linha, não apenas no final do programa. Com essas ressalvas, aqui está uma versão modificada para funcionar em Experimente online , e aqui uma versão não- executada, executada nas entradas de 0 a 54.

Explicação

Vou usar a versão não-competitiva aqui. A única diferença é que a versão oficial precisa implementar a adição como duas subtrações.

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

Não é a solução C mais curta, mas tem o mérito de funcionar em tempo constante (sem loops, apenas matemática). Ele usa indexação baseada em 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
}

Teste com:

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

Para um iniciante, tudo bem, eu acho :).

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 a maneira formatada

#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 bytes, indexação baseada em 0

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

Experimente o programa dc online!

Explicação:

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

O topo da pilha agora contém o índice k do maior número triangular que é <= 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.

Este programa dc pode ser convertido em um script bash de tamanho competitivo:

Utilitários Bash + Unix, 28 bytes, indexação baseada em 0

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

Experimente o programa bash online!

C, 81 44 bytes

método iterativo direto, 0 indexado e com alguma massagem suave;

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

Experimente online!