14

您的任务是，给定两个正整数 $x$ 和，返回增量范围序列中的前数字。 $n$ $x$

增量范围序列首先生成一个从1到含）的范围。例如，如果为，它将生成列表。然后，它将重复的以递增的最后值附加到现有列表中，然后继续。 $n$ $n$ $3$ $[1,2,3]$ $n$ $1$

输入例如： $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]

测试用例：

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]

— 小马同志
source

8

Python 2，39个字节

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

在线尝试！

— 乔纳森·艾伦
source

在Python 3还与更换/用//

— 尼克·肯尼迪

7

果冻，4 字节

Ḷd§‘

双向链接x在左侧和n右侧接受两个正整数，这将产生一个正整数列表。

在线尝试！

怎么样？

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

— 乔纳森·艾伦
source

3

等等...那是divmod吗？聪明！而我当时却在努力挣扎p……

— 乡下人埃里克（Erik）

6

R，33个字节

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

在线尝试！

移植Jonathan Allan的Python解决方案。

R，36个字节

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

在线尝试！

我原来的解决方案；生成一个 $n\times x$ 矩阵，每一列为增量，即 $1 \ldots n, 2\ldots n+1,\ldots$ ，然后获取前 $x$ 个条目（沿着列向下移动）。

— 朱塞佩
source

6

05AB1E，6 个字节

L<s‰O>

@JonathanAllan的Jelly答案端口，因此请确保对他进行投票！

第一个输入是 $x$ ，第二个输入是 $n$ 。

在线尝试或验证所有测试用例。

说明：

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)

我自己的初始方法是8 个字节：

LI∍εN¹÷+

第一个输入是 $n$ ，第二个输入是 $x$ 。

在线尝试或验证所有测试用例。

说明：

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)

— 凯文·克鲁伊森
source

4

Perl 6、18个字节

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

在线尝试！

咖喱函数f(x)(n)。

说明

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

— 恩韦恩霍夫
source

4

Brain-Flak，100字节

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

带有注释和格式：

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

在线尝试！

— 詹姆士
source

4

J，¹³ 12字节

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

在线尝试！

怎么样

我们以x左边的arg为准n。让我们x = 8和n = 3这个例子：

+/&i.：通过创建整数范围来转换两个arg i.，即，左侧arg变为0 1 2 3 4 5 6 7，右侧arg变为0 1 2。现在，我们+/从这两个表创建一个“加法表” ：
```
 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 +：将此表的每个元素加1：

[: ,：展平它,：

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

[ $：调整形状，$使其具有与原始的未变形的左arg相同数量的元素[，即x：
```
 1 2 3 2 3 4 3 4 
```

— 约拿
source

1

真好！我的12字节替代文件

— Galen Ivanov，

4

八度，25字节

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

输入数字n和的匿名函数x，并输出行向量。

在线尝试！

怎么运行的

考虑n=3和x=13。

该代码(1:n)'给出了列向量

1
2
3

然后(0:x)给出行向量

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

加法(1:n)'+(0:x)是逐个元素进行广播的，因此它给出了具有所有和对的矩阵：

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

索引为，以列主要线性顺序（从下到上，以跨列）(1:x)检索x此矩阵的第一个元素，作为行向量：

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

— 路易斯·门多
source

3

Haskell，31个字节

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

在线尝试！

这可能是我最喜欢的一种递归。我们从1到n的值开始，然后（通过自引用）将那些相同的值+1连接在一起。然后我们只取第一个x值。

— 用户1472751
source

2

第四（gforth），34个字节

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

在线尝试！

代码说明

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

2

MATL，16，10个字节

:!i:q+2G:)

在线尝试！

感谢Guiseppe和Luis Mendo，节省了-6个字节！

说明：

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

— 詹姆士
source

@LuisMendo谢谢！显然，我对自己的MATL感到非常生疏：）

— 詹姆斯

2

盖亚 8字节

…@┅+‡t_<

在线尝试！

与Octave和MATL回答基本相同。

— 朱塞佩
source

1

果冻，5个字节

+þẎḣ’

在线尝试！

— 暴民埃里克
source

1

红宝石，32字节

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

在线尝试！

— 价值墨水
source

1

Japt `-m`， 12 7字节

Jonathan的Python解决方案端口。

取x作为第一输入。

%VÄ+UzV

尝试一下

— 毛茸茸
source

1

JavaScript，36个字节

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

在线试用！

— 毛茸茸
source

使用alert或print代替返回数组可以将其减少到34个字节：n=>g=x=>x&&print(g(--x)|1+x%n+x/n)

— tsh

1

Perl `-na` 5，43个字节

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

在线尝试！

— Xcali
source

1

K（oK），17 16字节

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

在线尝试！

— 加伦·伊万诺夫（Galen Ivanov）
source

1

Stax，6 个字节

⌐çYæ▄9

运行并调试

打开包装并说明：

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

— 浪费
source

0

炼金术士，77字节

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

在线尝试！

递增并输出一个计数器n次，然后在重复之前减去n-1。

— 硝化龙
source

0

木炭，18字节

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

在线尝试！链接是详细版本的代码。我曾梦想过将索引范围为零的列表作为种子，然后再次将其切片，但实际上要长2个字节。说明：

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

— 尼尔
source

0

JS，54个字节

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

在线尝试！

— 用户名
source

欢迎使用PPCG ：）由于这不是递归函数，因此您无需计算f=。您可以通过使用参数（n=>x=>）保存一个字节，而通过扩展和映射数组（[...Array(x)].map()）保存另一个字节。

— 毛茸茸的

0

Haskell，34 33字节

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

在线尝试！

— 妮米
source

0

Perl 5，39个字节

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

在线尝试！

— Kjetil S.
source

0

C（gcc），49 44字节

使用递归来保存一些字节。

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

在线尝试！

— 埃里克·F
source

0

APL + WIN，29 23 16字节

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

索引原点= 0，并提示输入n和x

在线尝试！由Dyalog Classic提供

— 格雷厄姆
source

0

C（clang），843字节

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

— 太空竞赛
source

2

嗨，欢迎来到PPCG！这个挑战标记为[code-golf]，这意味着您必须以尽可能少的字节/字符完成挑战。您可以删除空白负载，并将变量名称更改为代码中的单个字符（argc，argv和ranges）。同样，无需添加任何警告消息。.您可以假定输入有效，除非挑战另有说明。

— 凯文·克鲁伊森

0

图标，48字节

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

在线尝试！

— 加伦·伊万诺夫（Galen Ivanov）
source

0

C＃（Visual C＃交互式编译器），41字节

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

在线尝试！

— 过期数据
source

0

因子，55字节

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

在线尝试！

— 加伦·伊万诺夫（Galen Ivanov）
source

增量范围！

Python 2，39个字节

果冻，4 字节

怎么样？

R，33个字节

R，36个字节

05AB1E，6 个字节

Perl 6、18个字节

说明

Brain-Flak，100字节

J，13 12字节

怎么样

八度，25字节

怎么运行的

Haskell，31个字节

第四（gforth），34个字节

代码说明

MATL，16，10个字节

盖亚 8字节

果冻，5个字节

红宝石，32字节

Japt -m， 12 7字节

JavaScript，36个字节

Perl -na 5，43个字节

K（oK），17 16字节

Stax，6 个字节

炼金术士，77字节

木炭，18字节

JS，54个字节

Haskell，34 33字节

Perl 5，39个字节

C（gcc），49 44字节

APL + WIN，29 23 16字节

C（clang），843字节

图标，48字节

C＃（Visual C＃交互式编译器），41字节

因子，55字节

J，¹³ 12字节

Japt `-m`， 12 7字节

Perl `-na` 5，43个字节