Plages incrémentales!

14

Votre tâche consiste à, étant donné deux entiers positifs, x et n , renvoyer les premiers nombres x dans la séquence des plages incrémentielles.

La séquence de plages incrémentielles génère d'abord une plage de un à n inclus. Par exemple, si n était 3 , il générerait la liste [1,2,3] . Il ajoute ensuite à plusieurs reprises les n dernières valeurs incrémentées de 1 à la liste existante et continue.

Une entrée de n=3 par exemple:

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]

Cas de test:

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]
Camarade SparklePony
la source

Réponses:

7

Gelée , 4 octets

Ḷd§‘

Un lien dyadique acceptant deux entiers positifs, xà gauche et nà droite, ce qui donne une liste d'entiers positifs.

Essayez-le en ligne!

Comment?

Ḷ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]
Jonathan Allan
la source
3
Attendez ... c'est divmod? Intelligent! Et je me débattais avec p...
Erik the Outgolfer
6

R , 33 octets

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

Essayez-le en ligne!

Ports de la solution Python de Jonathan Allan .

R , 36 octets

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

Essayez-le en ligne!

Ma solution originale; génère une matrice n×X avec chaque colonne comme incréments, c'est-à-dire 1n,2n+1, , puis prend les X premières entrées (en descendant les colonnes).

Giuseppe
la source
6

05AB1E , 6 octets

L<s‰O>

Port de la réponse Jelly de @JonathanAllan , alors assurez-vous de voter pour lui!

La première entrée est x , la deuxième entrée est n .

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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)

Ma propre approche initiale était de 8 octets :

LI∍εN¹÷+

La première entrée est n , la deuxième entrée est X .

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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)
Kevin Cruijssen
la source
4

Perl 6 , 18 octets

{(1..*X+ ^*)[^$_]}

Essayez-le en ligne!

Fonction curry f(x)(n).

Explication

{                }  # Anonymous block
      X+     # Cartesian product with addition
  1..*       # of range 1..Inf
         ^*  # and range 0..n
 (         )[^$_]  # First x elements
nwellnhof
la source
4

Brain-Flak , 100 octets

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

Avec commentaires et mise en forme:

# 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
        ({}[()]<
            (<>[]({}())<>)
        >)
    >)
}

Essayez-le en ligne!

James
la source
4

J , 13 12 octets

[$[:,1++/&i.

Essayez-le en ligne!

Comment

Nous prenons xcomme argument de gauche, ncomme droite. Prenons x = 8et n = 3pour cet exemple:

  • +/&i.: Transformez les deux arguments en créant des plages entières i., c'est-à-dire que l'argument gauche devient 0 1 2 3 4 5 6 7et l'argument droit devient 0 1 2. Maintenant, nous créons une "table d'addition à +/partir de ces deux:

     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 +: Ajoutez 1 à chaque élément de ce tableau:

     1 2  3
     2 3  4
     3 4  5
     4 5  6
     5 6  7
     6 7  8
     7 8  9
     8 9 10
    
  • [: ,: Aplatissez-le ,:

     1 2 3 2 3 4 3 4 5 4 5 6 5 6 7 6 7 8 7 8 9 8 9 10
    
  • [ $: Formez-le $pour qu'il ait le même nombre d'éléments que l'argument gauche non transformé d'origine [, c'est-à-dire x:

     1 2 3 2 3 4 3 4 
    
Jonas
la source
1
Agréable! Mon alternative à 12 octets
Galen Ivanov
4

Octave , 25 octets

@(n,x)((1:n)'+(0:x))(1:x)

Fonction anonyme qui entre les nombres net x, et sort un vecteur ligne.

Essayez-le en ligne!

Comment ça fonctionne

Considérez n=3et x=13.

Le code (1:n)'donne le vecteur colonne

1
2
3

(0:x)Donne ensuite le vecteur ligne

0  1  2  3  4  5  6  7  8  9 10 11 12 13

L'addition (1:n)'+(0:x)est élément par élément avec diffusion, et donc elle donne une matrice avec toutes les paires de sommes:

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

L'indexation avec (1:x)récupère les premiers xéléments de cette matrice dans l'ordre linéaire des colonnes (vers le bas, puis à travers), comme vecteur de ligne:

1 2 3 2 3 4 3 4 5 4 5 6 5
Luis Mendo
la source
3

Haskell , 31 octets

n#x=take x$[1..n]++map(+1)(n#x)

Essayez-le en ligne!

Cela pourrait être mon type de récursivité préféré. Nous commençons avec les valeurs de 1 à n, puis nous concaténons ces mêmes valeurs (via l'auto-référence) +1. nous prenons ensuite les premières valeurs x.

user1472751
la source
2

Forth (gforth) , 34 octets

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

Essayez-le en ligne!

Explication du code

: 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
reffu
la source
2

MATL , 16 , 10 octets

:!i:q+2G:)

Essayez-le en ligne!

-6 octets économisés grâce à Guiseppe et Luis Mendo!

Explication:

:!          % 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
James
la source
@LuisMendo Merci! De toute évidence, je suis assez rouillé avec mon MATL :)
James
1

Stax , 6 octets

⌐çYæ▄9

Exécuter et déboguer

Déballé et expliqué:

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
wastl
la source
0

Alchimiste , 77 octets

_->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

Essayez-le en ligne!

Incrémente et sort un compteur n fois, puis soustrait n-1 avant de répéter.

Nitrodon
la source
0

Fusain , 18 octets

NθFN⊞υ⊕⎇‹ιθι§υ±θIυ

Essayez-le en ligne! Le lien est vers la version détaillée du code. J'ai rêvé de semer la liste avec une plage indexée zéro, puis de la couper à nouveau, mais c'était en fait 2 octets de plus. Explication:

Nθ                  Input `n` into variable
   N                Input `x`
  F                 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
                Iυ  Cast list to string for implicit output
Neil
la source
0

JS, 54 octets

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

Essayez-le en ligne!

user2657799
la source
Bienvenue dans PPCG :) Comme il ne s'agit pas d'une fonction récursive, vous n'avez pas besoin de compter le f=. Vous pouvez enregistrer un octet en curryant les paramètres ( n=>x=>) et un autre en étalant et en mappant le tableau ( [...Array(x)].map()).
Shaggy
0

C (clang), 843 octets

#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");
        }   
}
Course spaciale
la source
2
Salut, bienvenue chez PPCG! Ce défi est étiqueté [code-golf], ce qui signifie que vous devez terminer le défi en un minimum d'octets / caractères. Vous pouvez supprimer de nombreux espaces blancs et changer les noms de variables en caractères uniques dans votre code (les argc, argvet ranges). En outre, pas besoin d'ajouter de messages d'avertissement. Vous pouvez supposer que l'entrée est valide, sauf indication contraire du défi.
Kevin Cruijssen