Ihre Aufgabe ist es, bei zwei positiven ganzen Zahlen, $x$ und , die ersten Zahlen in der Reihenfolge der inkrementellen Bereiche zurückzugeben.$n$$x$

Die inkrementelle Bereichssequenz erzeugt zunächst einen Bereich von eins bis einschließlich . Zum Beispiel, wenn war , wäre es die Liste erzeugen . Anschließend werden die letzten Werte, die um erhöht wurden, wiederholt an die vorhandene Liste angehängt und fortgesetzt.$n$$n$$3$$[1,2,3]$$n$$1$

Eine Eingabe von $n=3$ zum Beispiel:

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]

Testfälle:

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]

Python 2 , 39 Bytes

lambda n,x:[v/n+v%n+1for v in range(x)]

Probieren Sie es online!

Gelee , 4 Bytes

Ḷd§‘

Ein dyadischer Link, xder links und nrechts zwei positive Ganzzahlen akzeptiert und eine Liste positiver Ganzzahlen liefert.

Probieren Sie es online!

Wie?

Ḷ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]

R , 33 Bytes

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

Probieren Sie es online!

Portiert Jonathan Allans Python-Lösung .

R , 36 Bytes

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

Probieren Sie es online!

Meine ursprüngliche Lösung; erzeugt eine $n\times x$ Matrix mit jeder Spalte als Inkremente, dh $1 \ldots n, 2\ldots n+1,\ldots$ , und nimmt dann die ersten$x$ Einträge (durch die Spalten).

05AB1E , 6 Bytes

L<s‰O>

Port of @JonathanAllan 's Jelly antworte , also stelle sicher, dass du ihn positiv bewertest!

Erster Eingang ist $x$ , zweiter Eingang ist$n$ .

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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)

Mein erster Ansatz war 8 Bytes :

LI∍εN¹÷+

Die erste Eingabe ist $n$ , die zweite Eingabe ist $x$ .

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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)

Perl 6 , 18 Bytes

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

Probieren Sie es online!

Curry-Funktion f(x)(n) .

Erläuterung

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

Brain-Flak , 100 Bytes

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

Mit Kommentaren und Formatierungen:

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

Probieren Sie es online!

J , ^13-12 Bytes

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

Probieren Sie es online!

Wie

Wir nehmen xals das linke Argument, nals das rechte. Nehmen wir x = 8und n = 3für dieses Beispiel:

• +/&i.: Transformieren Sie beide Argumente, indem Sie ganzzahlige Bereiche erstellen, dh i.das linke Argument wird 0 1 2 3 4 5 6 7und das rechte Argument wird 0 1 2. Nun erstellen wir eine "Additionstabelle" +/aus diesen beiden:

   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 +: Addiere 1 zu jedem Element dieser Tabelle:

   1 2  3
   2 3  4
   3 4  5
   4 5  6
   5 6  7
   6 7  8
   7 8  9
   8 9 10
  

• [: ,: Flache es ,:

   1 2 3 2 3 4 3 4 5 4 5 6 5 6 7 6 7 8 7 8 9 8 9 10
  

• [ $: Form es $so, dass es die gleiche Anzahl von Elementen hat wie das ursprüngliche, nicht transformierte linke Argument [, dh x:

   1 2 3 2 3 4 3 4 
  

Oktave , 25 Bytes

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

Anonyme Funktion, die Zahlen nund xeinen Zeilenvektor eingibt und ausgibt.

Probieren Sie es online!

Wie es funktioniert

Betrachten n=3und x=13.

Der Code (1:n)'gibt den Spaltenvektor an

1
2
3

Dann (0:x)ergibt sich der Zeilenvektor

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

Der Zusatz (1:n)'+(0:x)ist elementweise bei Broadcasts und gibt daher eine Matrix mit allen Summenpaaren:

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

Indizierung mit (1:x)ruft die ersten xElemente dieser Matrix in der linearen Reihenfolge von Spalte zu Spalte (abwärts, dann quer) als Zeilenvektor ab:

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

Haskell , 31 Bytes

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

Probieren Sie es online!

Dies könnte meine Lieblingsrekursion sein. Wir beginnen mit den Werten von 1 bis n und verketten dann dieselben Werte (über Selbstreferenz) +1. dann nehmen wir einfach die ersten x-Werte.

Viertens (gviertens) , 34 Bytes

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

Probieren Sie es online!

Code-Erklärung

: 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

MATL , 16 , 10 Bytes

:!i:q+2G:)

Probieren Sie es online!

-6 Bytes gespart dank Guiseppe und Luis Mendo!

Erläuterung:

:!          % 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

Gaia , 8 Bytes

…@┅+‡t_<

Probieren Sie es online!

Funktioniert im Prinzip genauso wie die Antworten von Octave und MATL .

Gelee , 5 Bytes

+þẎḣ’

Probieren Sie es online!

Ruby , 32 Bytes

->n,x{(0...x).map{|i|i/n+i%n+1}}

Probieren Sie es online!

Japt -m , 12 7 Bytes

Port von Jonathans Python-Lösung .

Nimmt xals erste Eingabe.

%VÄ+UzV

Versuch es

JavaScript, 36 Bytes

n=>g=x=>x?[...g(--x),1+x%n+x/n|0]:[]

Probieren Sie es online!

Perl 5 -na , 43 Bytes

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

Probieren Sie es online!

K (oK) , 17 bis 16 Bytes

{y#,/1_y(1+)\!x}

Probieren Sie es online!

Stax , 6 Bytes

⌐çYæ▄9

Führen Sie es aus und debuggen Sie es

Ausgepackt & erklärt:

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

Alchemist , 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

Probieren Sie es online!

Erhöht und gibt einen Zähler n-mal aus und subtrahiert dann n-1, bevor er wiederholt wird.

Kohle , 18 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Ich hatte den Traum, die Liste mit einem Bereich von Null zu versehen und sie dann wieder abzutrennen, aber das war eigentlich 2 Bytes länger. Erläuterung:

Ｎθ                  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

JS, 54 Bytes

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

Probieren Sie es online!

Haskell, 34 33 Bytes

n#x=take x$do j<-[1..];[j..j+n-1]

Probieren Sie es online!

Perl 5 , 39 Bytes

say 1+int($_/$F[1])+$_%$F[1]for 0..$_-1

Probieren Sie es online!

C (GCC) , 49 44 Bytes

Verwenden der Rekursion zum Speichern einiger Bytes.

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

Probieren Sie es online!

APL + WIN, 29 23 16 Bytes

 x↑,1+(⍳x←⎕)∘.+⍳⎕

Indexursprung = 0 und fordert zur Eingabe von n und x auf

Probieren Sie es online! Mit freundlicher Genehmigung von Dyalog Classic

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

Icon , 48 Bytes

procedure f(x,n)
write((0to n)+(1to x))\n&\z
end

Probieren Sie es online!

C # (Visual C # Interactive Compiler) , 41 Byte

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

Probieren Sie es online!

Faktor 55 Bytes

: f ( a b -- c ) [0,b) [ over /mod + 1 + . ] with map ;

Probieren Sie es online!