用我的周期性继任者之和代替我！

25

这次，我对您有一个简单的挑战。给定一个正整数数组A（或您的语言中的等价整数），将每个条目A i替换为下一个A的总和我的元素一个，骑自行车从一开始就回来，如果没有足够的项目。

像往常一样，您可以使用任何编程语言进行竞争，并且可以通过任何标准方法并以任何合理的格式接受输入并提供输出，同时请注意，默认情况下会禁止这些漏洞。您也可以选择使用A的大小作为输入。这是代码高尔夫球，因此每种语言的最短提交（以字节为单位）将获胜。

示例/测试用例

考虑到[1,3,4,5]，你的代码应该输出[3,10,13,14]，因为1被替换3，3被替换4+5+1=10（注意它是如何从一开始就缠回），4通过5+1+3+4=13和5通过1+3+4+5+1=14。

鉴于[3,2,1,9]，你的程序产生[12,10,9,33]，因为我们替换3用2+1+9=12，2用1+9=10，1用9而9用3+2+1+9+3+2+1+9+3=33（注意我们是如何包裹从一开始就回一次以上）。

一些其他测试用例供您选择：

[4,3,2,1]                       -> [10,7,5,4]
[3,2,1,9]                       -> [12,10,9,33]
[1,3,4,5]                       -> [3,10,13,14]
[4,4,3,2,2]                     -> [11,11,8,6,8]
[3,5,3,2,1]                     -> [10,14,6,4,3]
[3,2,4,3,2,1,1]                 -> [9,7,7,4,2,1,3]
[7,8,6,5,4,3,2,1,5]             -> [29,33,20,15,11,8,6,5,30]
[28,2,4,2,3,2,3,4,5,3]          -> [137,6,10,5,9,7,12,38,39,34]
[1,2,3,4,5,4,3,2,1,2,3,4,3,2,1] -> [2,7,13,14,12,8,5,3,2,7,9,7,4,2,1]
code-golf  array-manipulation  integer 
— Xcoder先生
source

Answers:

8

MATL，10 9字节

"G@:X@+)s

在线尝试！

	% implicit input
"	% for loop, iterate over the input array 
G	% push input x
@	% push for loop index, x[i]
:	% range, push [1,...,x[i]]
X@	% push for loop index, i
+	% sum, so stack holds [i+1,...,i+x[i]]
)	% index, modularly, so gets the cyclic successors
s	% sum cyclic successors, leaving the sum on the stack
	% implicit end of for loop
	% implicit output of stack
— 朱塞佩
source
6

Python，55个字节

lambda a:[sum((-~v*a)[i:i+v])for i,v in enumerate(a,1)]

在线尝试！

— 乔纳森·艾伦
source
不太熟悉python，求和后可以解释一下括号中的部分吗？
— 约拿（Jonah）
2
首先，~运算符不是按位运算符，它实际上是的简写-1-v，所以-~v是-(-1-v)这是刚刚1+v（但避免了括号状(1+v)*a）。其次，在Python中，可以将列表乘以整数以重复它（例如['a','b']*3is ['a','b','a','b','a','b']）。将-~v*a可以被替代a+v*a为相同的字节数。最后，[i:i+v]是切片索引，仅将元素保留i为i+v-1（0索引）。
— 乔纳森·艾伦
6

Haskell，50 47 44字节

zipWith((sum.).take)<*>scanr(:)[].tail.cycle

在线尝试！

                    -- <*> in function context is Haskell's S combinator, i.e.
                    --     (zipWith ... <*> scanr ...) arg
                    -- resovles to
                    --     zipWith ... arg (scanr ... arg)
zipWith             -- so we zip
                    --   the input list and
 scanr(:)[]         --   the tails (tails of [1,2,3] are [[1,2,3],[2,3],[3],[]])
      tail          --   of the tail of
          cycle     --   and infinite cycle of the input list
                    -- with the function
 (sum.).take        --   take that many elements given by the element
                    --   of the input list from the list given by the inits
                    --   and sum it
— 妮米
source
不错的工作！实际上，scanr（：）[]是尾巴
— Damien
@Damien：尾巴。对！谢谢！
— nimi
4

05AB1E，8 7字节

εL¾+èO¼

在线尝试！

说明

ε        # apply to each element x of the input
 L       # push range [1 ... x]
  ¾+     # add counter to each (initially 0)
    è    # cyclically index into input with each
     O   # sum
      ¼  # increment counter
— 艾米尼亚
source
4

K4 / K（ok），20 19字节

解：

+/'x#'1_(1+2##x)#x:

在线尝试！

例子：

q)k)+/'x#'1_(1+2##x)#x:1 3 4 5
3 10 13 14
q)k)+/'x#'1_(1+2##x)#x:4 3 2 1
10 7 5 4
q)k)+/'x#'1_(1+2##x)#x:3 2 4 3 2 1 1
9 7 7 4 2 1 3
q)k)+/'x#'1_(1+2##x)#x:1 2 3 4 5 4 3 2 1 2 3 4 3 2 1
2 7 13 14 12 8 5 3 2 7 9 7 4 2 1

说明：

重塑输入，先放下，取每个x的长度，加起来。

+/'x#'1_(1+2##x)#x: / the solution
                 x: / store input as x
                #   / reshape
        (      )    / do this together
             #x     / count x
           2#       / duplicate (2-take)
         1+         / add 1
      1_            / 1 drop (_), remove first element
   x#'              / x take each-both
+/'                 / sum (+/) each
— 街头小贩
source
3

附件，26字节

{Sum=>_[(_2+1:_)%#_]}#Iota

在线尝试！

说明

这是两个功能的分支：

  • {Sum=>_[(_2+1:_)%#_]}
  • Iota

这意味着，将正确的尖齿Iota应用于参数，x并将其作为第二个参数传递给中心尖齿（第一个函数）。因此，对于输入x：

{Sum=>_[(_2+1:_)%#_]}[x, Iota[x]]

替换for _和_2：

Sum => x[(Iota[x] + 1:x) % #x]

Iota[x]返回索引为的数组x。等同于0...#x。#x是x或的大小的简短表示Size[x]。本质上，此函数将Sum函数映射到第二个表达式上：

x[(Iota[x] + 1:x) % #x]

外x[...]位表示...将生成一系列要从中选择的索引x。生成索引的最重要部分是：

Iota[x] + 1:x

此表达式使用了一些向量化。为了可视化，我们假设输入为x := [1, 3, 4, 5]。然后，此表达式等效于：

Iota[[1, 3, 4, 5]] + 1:[1, 3, 4, 5]
[0, 1, 2, 3] + [1:1, 1:3, 1:4, 1:5]
[0, 1, 2, 3] + [[1], [1, 2, 3], [1, 2, 3, 4], [1, 2, 3, 4, 5]]
[0 + [1], 1 + [1, 2, 3], 2 + [1, 2, 3, 4], 3 + [1, 2, 3, 4, 5]]
[[0 + 1], [1 + 1, 1 + 2, 1 + 3], [2 + 1, 2 + 2, 2 + 3, 2 + 4], [3 + 1, 3 + 2, 3 + 3, 3 + 4, 3 + 5]]
[[1], [2, 3, 4], [3, 4, 5, 6], [4, 5, 6, 7, 8]]

这是一个索引列表，表示mod中next N元素的索引。为了使它们安全地进行检索，我们采用以下数组mod ：x#x#x

(Iota[x] + 1:x) % #x

这为我们提供了适当的索引，然后可以从 x并对每个数组求和，得出适当的结果。

其他尝试

36个字节： {Sum@_&Get=>((_2+1.._2+_)%#_)}#Iota -我忘记了x[...]完全矢量化，因此变成：

30个字节： {Sum=>_[(_2+1.._2+_)%#_]}#Iota -但后来我意识到_2+可以将内部范围的因素排除在外，这意味着我们可以使用:代替来保存括号..，从而为我们提供当前版本。

— 科纳·奥布莱恩
source
3

R，89 64字节

j=rep(x<-scan(),max(x));Map(function(u,v)sum(j[v+1:u]),x,seq(x))

在线尝试！

生成足够长的循环索引向量的主要思想是，可以从输入向量中获取所需的元素。

原始版本：

function(x,i=seq(x),j=rep(i,max(x))){for(k in i){T=c(T,sum(x[j[(k+1):(k+x[k])]]))};T[-1]}

在线尝试！

— ngm
source
由于允许使用长度作为附加参数，所以可以... 75
— JayCe
1
69有趣的是，我开始了类似的工作，但使用了cumsum，但在过程中迷路了……不错的解决方案！
— JayCe
66（使用Map。输出有点难看，因此TIO链接未列出它。我想完整的程序会更短！
— JayCe
是
— JayCe
— JayCe
3

R，62 58字节

function(a,l)diag(diffinv(matrix(a,max(a)*l+1,l))[a+2,])-a

在线尝试！

其他R解决方案的替代方案。JayCecumsum在评论中提到了这触发了我大脑中的某些东西的使用diffinv和矩阵回收，而不是rep。

说明：

给定输入数组a，让M=max(a)和l=length(a)。

请注意，这M+l是我们需要访问的最大可能索引M+l<=M*l+1，因为if M,l>1，M+l<=M*l（仅当时等于M=l=2）和if l==1或M==1then M+l==M*l+1。

举例来说，让a=c(4,3,2,1)。然后M=l=4。

我们用构造M*l+1 x lR中的矩阵matrix(a,max(a)*l+1,l)。由于R a以列优先顺序回收，因此我们得到一个矩阵，该矩阵重复了a这样的元素：

      [,1] [,2] [,3] [,4]
 [1,]    4    3    2    1
 [2,]    3    2    1    4
 [3,]    2    1    4    3
 [4,]    1    4    3    2
 [5,]    4    3    2    1
 [6,]    3    2    1    4
 [7,]    2    1    4    3
 [8,]    1    4    3    2
 [9,]    4    3    2    1
[10,]    3    2    1    4
[11,]    2    1    4    3
[12,]    1    4    3    2
[13,]    4    3    2    1
[14,]    3    2    1    4
[15,]    2    1    4    3
[16,]    1    4    3    2
[17,]    4    3    2    1

每列是的每个元素的循环后继a，a在第一行中；这是由于R在矩阵中循环使用其参数的方式。

接下来，我们使用的反“导数” diffinv，本质上是将每一列的累加总和0作为第一行，从而生成矩阵

      [,1] [,2] [,3] [,4]
 [1,]    0    0    0    0
 [2,]    4    3    2    1
 [3,]    7    5    3    5
 [4,]    9    6    7    8
 [5,]   10   10   10   10
 [6,]   14   13   12   11
 [7,]   17   15   13   15
 [8,]   19   16   17   18
 [9,]   20   20   20   20
[10,]   24   23   22   21
[11,]   27   25   23   25
[12,]   29   26   27   28
[13,]   30   30   30   30
[14,]   34   33   32   31
[15,]   37   35   33   35
[16,]   39   36   37   38
[17,]   40   40   40   40
[18,]   44   43   42   41

在第一列中，输入 6=4+2等于14=4 + (3+2+1+4)，即循环后继和（CSS）加上前导4。同样，在第二列中，条目5=3+2等于10=3 + (4+1+2)，依此类推。

因此，在列中i，a[i]+2 nd项等于CSS(i)+a[i]。因此，我们采用以索引的行a+2，得到一个方矩阵：

     [,1] [,2] [,3] [,4]
[1,]   14   13   12   11
[2,]   10   10   10   10
[3,]    9    6    7    8
[4,]    7    5    3    5

沿对角线的项等于循环后继项和plus a，因此我们提取对角线并减去a，将结果作为循环后继项和返回。

— 朱塞佩
source
迫不及待的解释！
— JayCe
@JayCe添加了！经常发生，解释它导致了另一场高尔夫；我总是建议添加一个解释，以便您或后面的其他人可以找到另一种方法，尽管我并不总是有时间这样做，哈哈。
— 朱塞佩
1
这两种解决方案的共同元素是有效生成索引或元素本身的足够长的循环，因为1索引语言无法优雅地使用模块化算术返回数组的开头。
— ngm
@ngm是的，当然。我喜欢您对的使用Map，而在我确定可以将其l用作输入之前，最初的长度为68个字节！
— 朱塞佩
2

Pyth，13 11字节

.esm@Q+dkSb

多亏了Xcoder先生，节省了2个字节。
在这里尝试

说明

.esm@Q+dkSb
.e         Q   For each index k and value b in (implicit) input...
         Sb    ... get the list [1, ..., b]...
   m  +dk      ... add k to each...
    @Q         ... and index into the input...
  s            ... then take the sum.
— Xcoder先生18年
2

木炭，12字节

ＩＥθΣＥι§θ⊕⁺κλ

在线尝试！链接是详细版本的代码。说明：

  θ             Input array
 Ｅ              Map over elements
     ι          Current element
    Ｅ           Map over implicit range
           λ    Inner index
          κ     Outer index
         ⁺      Sum
        ⊕       Increment
       θ        Input array
      §         Cyclically index
   Σ            Sum
Ｉ               Cast to string
                Implicitly print on separate lines
— 尼尔
source
2

JavaScript ES6，65个字节

a=>a.map((x,y)=>{for(s=0,i=y;i<y+x;)s+=a[++i%a.length];return s})

简单的解决方案。取消高尔夫：

a => a.map((x,y) => {
    var s = 0;
    for (i = y; i < y + x; i++) {
        s += a[i % a.length];
    }
    return s;
});

JavaScript的map()功能非常适合这项工作，它针对每个元素运行给定的回调，并用回调的结果替换它。回调接收两个参数，第一个x是值，第二个y是索引。通过获取模数，i % a.length我们可以轻松遍历数组，如果需要的话可以多次。

测试片段

（将输入作为JSON表示法放置）

显示代码段

— 佩德罗A
source
2

Java 8，87字节

一个咖喱的空lambda，带有一个int[]列表和int长度。

l->s->{for(int i=-1,j,t;++i<s;System.out.println(t))for(j=t=0;j++<l[i];)t+=l[(i+j)%s];}

在线试用。请注意，System.out为了获得更漂亮的打印效果，我已经在该程序中添加了阴影。

— 雅各布
source
2

朱0.6，63个 55 53字节

A->[sum(repmat(A,v+1)[i+1:i+v])for(i,v)=enumerate(A)]

在线尝试！

较旧的解决方案：

朱莉娅0.6，65字节

A->(l=length(A);[sum(A[mod1(j,l)]for j∈i+1:i+A[i])for i∈1:l])

在线尝试！

另一个解决方案。从字节数上来说不是很好，但是我喜欢它，它可能比其他两个效率更高，尤其是在输入有大数字的情况下。

朱莉娅0.6，69字节

A->(l=length(A);[sum([A;A][i+1:i+A[i]%l])+A[i]÷l*sum(A)for i∈1:l])

在线尝试！

— sundar-恢复莫妮卡
source
1

画布，10 字节

²Ｘ｛ｘ＋⁸＠］∑］

在这里尝试！

说明：

{         ] map over the items in the input
 ²X           save this loops counter on X (because of a bad design choice..)
   {    ]     map over 1..current item
    x+          add to it X
      ⁸@        and index in the input using that
         ∑    sum the map
— 宰马
source
1

QBasic 1.1，115字节

INPUT L
DIM A(L)
FOR I=0TO L-1
INPUT C
A(I)=C
NEXT
FOR I=0TO L-1
S=0
FOR C=I+1TO I+A(I)
S=S+A(C MOD L)
NEXT
?S
NEXT

第一个输入是长度L，然后L个后续输入是按顺序排列的元素。L个输出表示结果数组，其元素按显示顺序排列。

— 暴民埃里克
source
1

APL + WIN，37个字节

输入提示：

+/¨v↑¨⊂[2](⍳⍴v)⌽((⍴v),⍴n)⍴n←(+/v)⍴v←⎕

在线尝试！由Dyalog Classic提供

说明：

n←(+/v)⍴v←⎕ prompts for input and creates a repeating vector of length max v

((⍴v),⍴n)⍴n converts n to a matrix of length v x length n

(⍳⍴v)⌽ rotates each row of n by the size of each element of v

⊂[2] converts each row of m to an element in a nested vector

+/¨v↑¨ selects the number of elements from each element of the nested vector according to v and sums
— 格雷厄姆
source
1

JavaScript，65个字节3̶0̶0̶b̶y̶t̶e̶s̶

打高尔夫球

n=>n.map((z,x)=>{for(s=0,i=x;i<z+x;)s+=n[++i%n.length];return s})

不打高尔夫球

     f = n=>n.map((z,x)=>{
            for(s=0,i=x;i<z+x;)s+=n[++i%n.length];
            return s
            }
        );
console.log(f(process.argv[2].slice(1, -1).split(", ").map(x=>+x)))

在线尝试！

（上面的取消版本）我是这个Codegolf的新手！

*更新！由于评论中提供了有用的链接，我设法将大小减小到65个字节！

— ArashSM79
source
欢迎来到该网站。有两种方法可以改进此方法。您可以使用单字符变量名称，也可以删除多余的空格。（操作员不必被空格包围。）
— Wheat Wizard
除了Cat Wizard的技巧外，我们还提供了一些关于JavaScript高尔夫技巧的集合。正如您所说的，您是打高尔夫球的新手，您也可能会发现有趣的通用高尔夫技巧，这些技巧都以<所有语言>出现。
— manatwork
您应该ungolfed一个前添加golfed版本
— 旋塞阀
您假设为数组分配了预定义变量（n），我们不允许这样做。欢迎来到PPCG ：）
— Shaggy
— 粗野的
0

点 -rn，14字节

$+g@(_+\,B)MEg

在标准输入的连续行上获取输入数字；在stdout的连续行上给出输出编号。在线尝试！

说明

             g  List of lines of stdin (from -r flag)
           ME   Enumerate and map this function to the (index, value) pairs:
       \,B       One-based range(value)
     _+          To each element, add the index of that value
  g@(     )      Use the resulting range to slice into the original list g
                 (cyclical indexing is built in)
$+               Sum the numbers in the slice
                Output the list of results one per line (from -n flag)

或者，使用一个可行的示例：

             g  [1 3 4 5]
           ME   
       \,B      [(1,2) (1,4) (1,5) (1,6)]
     _+         [(1,2) (2,5) (3,7) (4,9)]
  g@(     )     [[3] [4 5 1] [5 1 3 4] [1 3 4 5 1]]
$+              [3 10 13 14]
— DLosc
source
0

Perl 6的，50 32个字节

{$_>>.&{.[++$+ ^$^a X%+$_].sum}}

在线尝试！

我是Perl 6中打高尔夫球的新手，所以我相信这可以缩短。不再新鲜了，回到高尔夫！

— 乔·金
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.