Inkrementelle Bereiche!

14

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

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.nn3[1,2,3]n1

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]
code-golf number sequence array Genosse SparklePony
quelle

Antworten:

7

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]
Jonathan Allan
quelle
3
Warten Sie ... ist das Divmod? Klug! Und ich hatte p
Probleme
6

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×x Matrix mit jeder Spalte als Inkremente, dh 1…n,2…n+1,… , und nimmt dann die erstenx Einträge (durch die Spalten).

Giuseppe
quelle
6

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

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

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
nwellnhof
quelle
4

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!

DJMcMayhem
quelle
4

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
Jona
quelle
1
Nett! Meine 12-Byte-Alternative
Galen Ivanov
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
Luis Mendo
quelle
3

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.

user1472751
quelle
2

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
reffu
quelle
2

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
DJMcMayhem
quelle
@ LuisMendo Danke! Klar, ich bin ziemlich verrostet mit meiner MATL :)
DJMcMayhem
1

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
wastl
quelle
0

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.

Nitrodon
quelle
0

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
Neil
quelle
0

JS, 54 Bytes

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

Probieren Sie es online!

user2657799
quelle
Willkommen bei PPCG :) Da dies keine rekursive Funktion ist, müssen Sie die nicht zählen f=. Sie können ein Byte speichern, indem Sie die Parameter ( n=>x=>) und ein anderes durch Verteilen und Zuordnen des Arrays ( [...Array(x)].map()) ändern .
Shaggy
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");
        }   
}
Weltraumrennen
quelle
2
Hallo, willkommen bei PPCG! Diese Herausforderung ist mit [Code-Golf] gekennzeichnet, was bedeutet, dass Sie die Herausforderung in möglichst wenigen Bytes / Zeichen abschließen müssen. Sie können viele Leerzeichen entfernen und die Variablennamen in einzelne Zeichen in Ihrem Code ändern (das argc, argvund ranges). Außerdem müssen keine Warnmeldungen hinzugefügt werden. Sie können davon ausgehen, dass die Eingabe gültig ist, sofern die Abfrage nichts anderes angibt.
Kevin Cruijssen