Intervalos Incrementais!

14

Sua tarefa é, dados dois inteiros positivos, e , retornar os primeiros números na sequência de intervalos incrementais.$$xxx$$$$nnn$$$$xxx$$

A sequência de intervalo incremental primeiro gera um intervalo de um a inclusive. Por exemplo, se fosse , isso geraria a lista . Em seguida, ele anexa repetidamente os últimos valores incrementados por à lista existente e continua.$$nnn$$$$nnn$$$$333$$$$[ 1 , 2 , 3 ][1,2,3][1,2,3]$$$$nnn$$$$111$$

Uma entrada de por exemplo:$$n = 3n=3n=3$$

n=3
1. Get range 1 to n. List: [1,2,3]
2. Get the last n values of the list. List: [1,2,3]. Last n=3 values: [1,2,3].
3. Increment the last n values by 1. List: [1,2,3]. Last n values: [2,3,4].
4. Append the last n values incremented to the list. List: [1,2,3,2,3,4]
5. Repeat steps 2-5. 2nd time repeat shown below.

2nd repeat:
2. Get the last n values of the list. List: [1,2,3,2,3,4]. Last n=3 values: [2,3,4]
3. Increment the last n values by 1. List: [1,2,3,2,3,4]. Last n values: [3,4,5].
4. Append the last n values incremented to the list. List: [1,2,3,2,3,4,3,4,5]


Casos de teste:

n,   x,   Output
1,  49,   [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49]
2, 100,   [1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18,19,19,20,20,21,21,22,22,23,23,24,24,25,25,26,26,27,27,28,28,29,29,30,30,31,31,32,32,33,33,34,34,35,35,36,36,37,37,38,38,39,39,40,40,41,41,42,42,43,43,44,44,45,45,46,46,47,47,48,48,49,49,50,50,51]
3,  13,   [1,2,3,2,3,4,3,4,5,4,5,6,5]


Respostas:

7

Gelatina , 4 bytes

Ḷd§‘


Um link diádico que aceita dois números inteiros positivos, xà esquerda e nà direita, que produz uma lista de números inteiros positivos.

Experimente online!

Quão?

Ḷd§‘ - Link: x, n              e.g   13, 3
Ḷ    - lowered range (x)             [0,1,2,3,4,5,6,7,8,9,10,11,12]
d   - divmod (n)                    [[0,0],[0,1],[0,2],[1,0],[1,1],[1,2],[2,0],[2,1],[2,2],[3,0],[3,1],[3,2],[4,0]]
§  - sums                          [0,1,2,1,2,3,2,3,4,3,4,5,4]
‘ - increment (vectorises)        [1,2,3,2,3,4,3,4,5,4,5,6,5]


3
Espere ... isso é divmod? Esperto! E eu estava lutando com p...
Erik the Outgolfer

6

R , 33 bytes

function(n,x,z=1:x-1)z%%n+z%/%n+1

Experimente online!

R , 36 bytes

function(n,x)outer(1:n,0:x,"+")[1:x]

Experimente online!

Minha solução original; gera uma matriz $$n×xn×xn\times x$$ com cada coluna como incrementos, ou seja, $$1…n,2…n+1,…1…n,2…n+1,…1 \ldots n, 2\ldots n+1,\ldots$$ , em seguida, pega as primeiras $$xxx$$ entradas (descendo as colunas).

6

05AB1E , 6 bytes

L<s‰O>


Porto da resposta de @JonathanAllan Jelly , por isso não deixe de vota-lo!

A primeira entrada é $$xxx$$ , a segunda entrada é $$nnn$$ .

Explicação:

L       # Push a list in the range [1, (implicit) input]
#  i.e. 13 → [1,2,3,4,5,6,7,8,9,10,11,12,13]
<      # Decrease each by 1 to the range [0, input)
#  → [0,1,2,3,4,5,6,7,8,9,10,11,12]
s‰    # Divmod each by the second input
#  i.e. 3 → [[0,0],[0,1],[0,2],[1,0],[1,1],[1,2],[2,0],[2,1],[2,2],[3,0],[3,1],[3,2],[4,0]]
O   # Sum each pair
#  → [0,1,2,1,2,3,2,3,4,3,4,5,4]
>  # And increase each by 1
#  → [1,2,3,2,3,4,3,4,5,4,5,6,5]
# (after which the result is output implicitly)

Minha abordagem inicial foi de 8 bytes :

LI∍εN¹÷+

A primeira entrada é $$nnn$$ , a segunda entrada é $$xxx$$ .

Explicação:

L         # Push a list in the range [1, (implicit) input]
#  i.e. 3 → [1,2,3]
I∍       # Extend it to the size of the second input
#  i.e. 13 → [1,2,3,1,2,3,1,2,3,1,2,3,1]
ε      # Map each value to:
N¹÷   #  The 0-based index integer-divided by the first input
#   → [0,0,0,1,1,1,2,2,2,3,3,3,4]
+  #  Add that to the value
#   → [1,2,3,2,3,4,3,4,5,4,5,6,5]
# (after which the result is output implicitly)

4

4

Flak cerebral , 100 bytes

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


Com comentários e formatação:

# Push a zero under the other stack
(<>)<>

# x times
{
# x - 1
({}[()]<

# Let 'a' be a counter that starts at n
# Duplicate a and NOT
(({}))((){[()](<{}>)}{})

# if a == 0
{
# Pop truthy
{}
<>

# Reset n to a
(({})<>)

# Push 0 to each
(<>)(<>)
}

# Pop falsy
{}

# Decrement A, add one to the other stack, and duplicate that number under this stack
({}[()]<
(<>[]({}())<>)
>)
>)
}


Experimente online!

4

J , 13 12 bytes

[$[:,1++/&i.  Experimente online! como Tomamos xcomo argumento à esquerda, ncomo à direita. Vamos pegar x = 8e, n = 3para este exemplo: • +/&i.: Transforme os dois argumentos criando intervalos inteiros i., ou seja, o argumento esquerdo se torna 0 1 2 3 4 5 6 7e o argumento direito se torna 0 1 2. Agora criamos uma "tabela de adição +/desses dois:  0 1 2 1 2 3 2 3 4 3 4 5 4 5 6 5 6 7 6 7 8 7 8 9  • 1 +: Adicione 1 a cada elemento desta tabela:  1 2 3 2 3 4 3 4 5 4 5 6 5 6 7 6 7 8 7 8 9 8 9 10  • [: ,: Achatá-lo ,:  1 2 3 2 3 4 3 4 5 4 5 6 5 6 7 6 7 8 7 8 9 8 9 10  • [$: Dê forma a ele $para que tenha o mesmo número de elementos que o argumento esquerdo não transformado original [, ou seja x:  1 2 3 2 3 4 3 4  4 Oitava , 25 bytes @(n,x)((1:n)'+(0:x))(1:x) Função anônima que insere números ne x, e gera um vetor de linha. Experimente online! Como funciona Considere n=3e x=13. O código (1:n)'fornece o vetor da coluna 1 2 3 Em seguida, (0:x)fornece o vetor de linha 0 1 2 3 4 5 6 7 8 9 10 11 12 13 A adição (1:n)'+(0:x)é elemento-elemento na transmissão e, portanto, fornece uma matriz com todos os pares de somas: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 2 3 4 5 6 7 8 9 10 11 12 13 14 15 3 4 5 6 7 8 9 10 11 12 13 14 15 16 A indexação com (1:x)recupera os primeiros xelementos dessa matriz na ordem linear principal da coluna (abaixo e depois) como um vetor de linha: 1 2 3 2 3 4 3 4 5 4 5 6 5 3 Haskell , 31 bytes n#x=take x$[1..n]++map(+1)(n#x)

Experimente online!

Este pode ser o meu tipo favorito de recursão. Começamos com os valores de 1 a ne concatenamos os mesmos valores (via auto-referência) +1. então apenas pegamos os primeiros x valores.

2

Quarto (gforth) , 34 bytes

: f 0 do i over /mod + 1+ . loop ;

Experimente online!

Código Explicação

: f            \ start a new word definition
0 do         \ start a loop from 0 to x-1
i          \ put the current loop index on the stack
over       \ copy n to the top of the stack
/mod       \ get the quotient and remainder of dividing i by n
+ 1+       \ add them together and add 1
.          \ output result
loop         \ end the counted loop
;              \ end the word definition

2

MATL , 16 , 10 bytes

:!i:q+2G:)


Experimente online!

-6 bytes salvos graças a Guiseppe e Luis Mendo!

Explicação:

:!          % Push the array [1; 2; ... n;]
i:q       % Push the array [0 1 2 ... x - 1]
+      % Add these two arrays with broadcasting
2G    % Push x again
:)  % Take the first x elements


@LuisMendo Thanks! Claramente, eu estou muito enferrujado com o meu MATL :)
DJMcMayhem

1

Perl 5-na , 43 bytes

@r=map$_..$_+$F[1]-1,1..$_;say"@r[0..\$_-1]"

Experimente online!

1

Stax , 6 bytes

⌐çYæ▄9


Execute e depure

Descompactado e explicado:

rmx|%+^ Full program, implicit input (n, x on stack; n in register X)
r       Range [0 .. x)
m      Map:
x|%     Divide & modulo x
+    Add quotient and remainder
^   Add 1
Implicit output


0

Alquimista , 77 bytes

_->In_n+In_x
x+n+0y+0z->a+Out_a+Out_" "+m+y
y+n->n
y+0n->z
z+m+a->z+n
z+0m->a


Experimente online!

Incrementa e gera um contador n vezes e subtrai n-1 antes de repetir.

0

Carvão , 18 bytes

ＮθＦＮ⊞υ⊕⎇‹ιθι§υ±θＩυ


Experimente online! Link é a versão detalhada do código. Eu sonhava em semear a lista com um intervalo indexado a zero e depois cortá-la novamente, mas isso era na verdade 2 bytes mais longo. Explicação:

Ｎθ                  Input n into variable
Ｎ                Input x
Ｆ                 Loop over implicit range
ι          Current index
‹           Less than
θ         Variable n
⎇   ι        Then current index else
θ    Variable n
±     Negated
§υ      Cyclically indexed into list
⊕             Incremented
⊞υ              Pushed to list
Ｉυ  Cast list to string for implicit output


0

JS, 54 bytes

f=(n,x)=>Array.from(Array(x),(_,i)=>i+1-(i/n|0)*(n-1))


Experimente online!

Bem-vindo ao PPCG :) Como essa não é uma função recursiva, você não precisa contar o f=. Você pode salvar um byte alterando os parâmetros ( n=>x=>) e outro espalhando e mapeando a matriz ( [...Array(x)].map()).
34

0

C (gcc) , 49 44 bytes

Usando recursão para salvar alguns bytes.

f(n,x){x&&printf("%d ",x%n+x/n+1,f(n,--x));}

Experimente online!

0

C (clang), 843 bytes

#include <stdlib.h>
main(int argc, char* argv[]){
int x,n;
if (argc == 3 && (n = atoi(argv[1])) > 0 && (x = atoi(argv[2])) > 0){
int* ranges = calloc(x, sizeof *ranges);
for (int i = 0; i < x; i++){
if (i < n){
ranges[i] = i+1;
}
else {
ranges[i] = ranges[i-n] + 1;
}
}
printf("[");
for (int j = 0; j < x - 1; j++){
printf("%d",ranges[j]);
printf(",");
}
printf("%d",ranges[x - 1]);
printf("]\n");
free(ranges);
}
else {
printf("enter a number greater than 0 for n and x\n");
}
}


2
Olá, seja bem-vindo ao PPCG! Esse desafio está marcado como [code-golf], o que significa que você deve concluir o desafio com o menor número possível de bytes / caracteres. Você pode remover um monte de espaços em branco, e mudar os nomes de variáveis para caracteres simples em seu código (a argc, argve ranges). Além disso, não é necessário adicionar nenhuma mensagem de aviso. Você pode assumir que a entrada é válida, a menos que o desafio diga o contrário.
Kevin Cruijssen 31/05/19

0

C # (compilador interativo do Visual C #) , 41 bytes

x=>n=>new int[x].Select((_,a)=>a/n+a%n+1)

Experimente online!

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.