Nhiệm vụ của bạn là, đưa ra hai số nguyên dương, và , trả về các số đầu tiên trong chuỗi phạm vi tăng dần.$x$$n$$x$

Trình tự phạm vi gia tăng trước tiên tạo ra một phạm vi từ một đến bao gồm. Ví dụ: nếu là , nó sẽ tạo danh sách . Sau đó, nó liên tục nối thêm giá trị cuối cùng tăng thêm vào danh sách hiện có và tiếp tục.$n$$n$$3$$[1,2,3]$$n$$1$

Một đầu vào của chẳng hạn:$n=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]

Các trường hợp thử nghiệm:

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 byte

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

Hãy thử trực tuyến!

Thạch , 4 byte

Ḷd§‘

Một liên kết dyadic chấp nhận hai số nguyên dương, xở bên trái và nbên phải, tạo ra một danh sách các số nguyên dương.

Hãy thử trực tuyến!

Làm sao?

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

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

Hãy thử trực tuyến!

Cổng giải pháp Python Jonathan Allan .

R , 36 byte

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

Hãy thử trực tuyến!

Giải pháp ban đầu của tôi; tạo ra một $n\times x$ ma trận với mỗi cột như gia tăng, tức là $1 \ldots n, 2\ldots n+1,\ldots$ , sau đó sẽ đưa người đầu tiên $x$ mục (đi xuống các cột).

05AB1E , 6 byte

L<s‰O>

Cảng @JonathanAllan 's Jelly câu trả lời , vì vậy hãy chắc chắn để upvote anh ta!

Đầu vào đầu tiên là $x$ , đầu vào thứ hai là $n$ .

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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)

Cách tiếp cận ban đầu của riêng tôi là 8 byte :

LI∍εN¹÷+

Đầu vào đầu tiên là $n$ , đầu vào thứ hai là $x$ .

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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 byte

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

Hãy thử trực tuyến!

Chức năng cuộn tròn f(x)(n).

Giải trình

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

Brain-Flak , 100 byte

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

Với ý kiến ​​và định dạng:

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

Hãy thử trực tuyến!

J , ¹³ 12 byte

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

Hãy thử trực tuyến!

làm sao

Chúng tôi lấy xnhư arg bên trái, nnhư bên phải. Hãy lấy x = 8và n = 3cho ví dụ này:

• +/&i.: Chuyển đổi cả hai đối số bằng cách tạo các phạm vi số nguyên i., nghĩa là, đối số bên trái trở thành 0 1 2 3 4 5 6 7và đối số bên phải trở thành 0 1 2. Bây giờ chúng tôi tạo một "bảng bổ sung +/từ hai:

   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 +: Thêm 1 cho mọi phần tử của bảng này:

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

• [: ,: Làm phẳng nó ,:

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

• [ $: Định hình nó $sao cho nó có cùng số phần tử với gốc arg [, chưa được dịch bên trái , nghĩa là x:

   1 2 3 2 3 4 3 4 
  

Octave , 25 byte

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

Hàm ẩn danh nhập số nvà x, và xuất ra một vectơ hàng.

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Hãy xem xét n=3và x=13.

Mã (1:n)'cho vectơ cột

1
2
3

Sau đó (0:x)đưa ra vector hàng

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

Việc bổ sung (1:n)'+(0:x)là yếu tố khôn ngoan với phát sóng, và do đó, nó đưa ra một ma trận với tất cả các cặp tổng:

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ập chỉ mục với (1:x)truy xuất các xphần tử đầu tiên của ma trận này theo thứ tự tuyến tính chính cột (xuống, sau đó qua), dưới dạng một vectơ hàng:

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

Haskell , 31 byte

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

Hãy thử trực tuyến!

Đây có thể là loại đệ quy yêu thích của tôi. Chúng tôi bắt đầu với các giá trị từ 1 đến n và sau đó ghép các giá trị tương tự (thông qua tự tham chiếu) +1. sau đó chúng ta chỉ lấy các giá trị x đầu tiên.

Forth (gforth) , 34 byte

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

Hãy thử trực tuyến!

Giải thích mã

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

:!i:q+2G:)

Hãy thử trực tuyến!

-6 byte được lưu nhờ Guiseppe và Luis Mendo!

Giải trình:

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

…@┅+‡t_<

Hãy thử trực tuyến!

Về cơ bản, điều tương tự như câu trả lời của Octave và MATL .

Thạch , 5 byte

+þẎḣ’

Hãy thử trực tuyến!

Ruby , 32 byte

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

Hãy thử trực tuyến!

Japt -m , 12 7 byte

Giải pháp Python của cảng Jonathan .

Lấy xlàm đầu vào đầu tiên.

%VÄ+UzV

Thử nó

JavaScript, 36 byte

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

Dùng thử trực tuyến!

Perl 5 -na , 43 byte

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

Hãy thử trực tuyến!

K (oK) , 17 16 byte

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

Hãy thử trực tuyến!

Stax , 6 byte

⌐çYæ▄9

Chạy và gỡ lỗi nó

Giải nén & giải thích:

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

Nhà giả kim , 77 byte

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

Hãy thử trực tuyến!

Tăng và xuất ra một bộ đếm n lần, sau đó trừ n-1 trước khi lặp lại.

Than , 18 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Tôi có ước mơ gieo hạt vào danh sách với phạm vi không có chỉ mục và sau đó cắt nó ra một lần nữa nhưng thực tế nó dài hơn 2 byte. Giải trình:

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

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

Hãy thử trực tuyến!

Haskell, 34 33 byte

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

Hãy thử trực tuyến!

Perl 5 , 39 byte

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

Hãy thử trực tuyến!

C (gcc) , 49 44 byte

Sử dụng đệ quy để lưu một số byte.

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

Hãy thử trực tuyến!

APL + THẮNG, 29 23 16 byte

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

Chỉ số gốc = 0 và lời nhắc cho n và x

Hãy thử trực tuyến! Lịch sự của Dyalog Classic

C (tiếng kêu), 843 byte

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

Biểu tượng , 48 byte

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

Hãy thử trực tuyến!

C # (Trình biên dịch tương tác Visual C #) , 41 byte

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

Hãy thử trực tuyến!

Yếu tố , 55 byte

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

Hãy thử trực tuyến!