J'ai un simple défi pour vous cette fois. Étant donné un tableau d'entiers positifs A (ou l'équivalent dans votre langue), remplacez chaque entrée A _i par la somme des éléments A _{i suivants} de A , en revenant depuis le début s'il n'y a pas assez d'éléments.

Comme d'habitude, vous pouvez concurrencer dans n'importe quel langage de programmation et pouvez prendre des entrées et fournir des sorties par n'importe quelle méthode standard et dans n'importe quel format raisonnable, tout en prenant note que ces failles sont interdites par défaut. Vous pouvez également prendre la taille de A comme entrée. Il s'agit de code-golf , donc la soumission la plus courte (en octets) pour chaque langue l' emporte.

Exemples / cas de test

Étant donné [1,3,4,5], votre code devrait sortir [3,10,13,14], car 1est remplacé par 3, 3est remplacé par 4+5+1=10(remarquez comment il a été renvoyé depuis le début), 4par 5+1+3+4=13et 5par 1+3+4+5+1=14.

Étant donné [3,2,1,9], votre programme devrait produire [12,10,9,33], car nous substituons 3avec 2+1+9=12, 2avec 1+9=10, 1avec 9et 9avec 3+2+1+9+3+2+1+9+3=33(notez comment nous avons bouclé depuis le début plus d'une fois).

Quelques autres cas de test parmi lesquels vous pouvez choisir:

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

MATL , 10 9 octets

"G@:X@+)s

Essayez-le en ligne!

	% 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

Gelée , 6 octets

ṙJṁS¥"

Essayez-le en ligne!

Python , 55 octets

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

Essayez-le en ligne!

J, 33 octets

[:({.+/@{.}.)"1 i.@#|."{($~>./*#)

non golfé

[: ({. +/@{. }.)"1 i.@# |."0 _ ($~ (>./ * #))

explication

Essayez-le en ligne!

C (gcc) , 86 85 octets

• Enregistré un octet grâce à Jakob .

C(y,c,l,i,k)int*y;{for(l=~0;++l<c;printf("%d,",k))for(k=i=0;i++<y[l];k+=y[(l+i)%c]);}

Essayez-le en ligne!

Haskell, 50 47 44 octets

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

Essayez-le en ligne!

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

05AB1E , 8 7 octets

εL¾+èO¼

Essayez-le en ligne!

Explication

ε        # 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

K4 / K (oK) , 20 19 octets

Solution:

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

Essayez-le en ligne!

Exemples:

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

Explication:

Remodeler l'entrée, déposer d'abord, prendre x longueur de chaque, résumer.

+/'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

Gelée , 7 octets

R+"Jị⁸§

Essayez-le en ligne!

Attaché , 26 octets

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

Essayez-le en ligne!

Explication

Il s'agit d'une fourchette de deux fonctions:

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

Cela signifie que la dent de droite Iotaest appliquée à l'argument xet transmise en tant que deuxième argument à la dent centrale (la première fonction). Cela devient donc, pour l'entrée x:

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

Remplacement de ceux de _et _2:

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

Iota[x]renvoie un tableau des indices de x. C'est équivalent à 0...#x. #xest un moyen court de dire la taille de x, ou Size[x]. En substance, cette fonction mappe la Sumfonction sur la deuxième expression:

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

Le x[...]bit externe signifie que ...va générer une série d'indices à sélectionner x. La partie la plus importante de la génération des indices est la suivante:

Iota[x] + 1:x

Cette expression utilise un peu de vectorisation. Pour visualiser cela, supposons que l'entrée soit x := [1, 3, 4, 5]. Ensuite, cette expression est équivalente à:

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

Ceci est une liste d'indices qui représentent les Néléments suivants des indices dans le xmod #x. Pour les rendre sûrs pour la récupération, nous prenons ce mod de tableau #x:

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

Cela nous donne les indices appropriés, qui sont ensuite obtenus à partir de x et chaque tableau est additionné, donnant les résultats appropriés.

D'autres tentatives

36 octets: {Sum@_&Get=>((_2+1.._2+_)%#_)}#Iota - j'ai oubliéx[...] vectoriser complètement, donc ça devient:

30 octets: {Sum=>_[(_2+1.._2+_)%#_]}#Iota - mais ensuite j'ai réalisé que _2+dans la plage interne pouvait être factorisé, ce qui signifie que nous pouvions enregistrer les parenthèses en utilisant :au lieu de .., en nous donnant la version actuelle.

R , 89 64 octets

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

Essayez-le en ligne!

Idée principale pour générer un vecteur d'index de cyclisme assez long que vous pouvez utiliser pour obtenir les éléments nécessaires à partir du vecteur d'entrée.

Version originale:

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

Essayez-le en ligne!

R , 62 58 octets

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

Essayez-le en ligne!

Une alternative à l' autre solution de R . Dans les commentaires, JayCe a mentionnécumsum ce qui a déclenché quelque chose dans mon cerveau à utiliser diffinvet à recycler la matrice rep.

Explication:

Étant donné le tableau d'entrée a, let M=max(a)et l=length(a).

Observez qu'il M+ls'agit de l'index maximum possible auquel nous aurions besoin d'accéder, et que M+l<=M*l+1, puisque si M,l>1, M+l<=M*l(avec égalité uniquement quand M=l=2) et si l==1ou M==1alors M+l==M*l+1.

À titre d'exemple, laissez a=c(4,3,2,1). Alors M=l=4.

Nous construisons la M*l+1 x lmatrice dans R par matrix(a,max(a)*l+1,l). Parce que R recycle adans l'ordre des colonnes, nous nous retrouvons avec une matrice répétant les éléments acomme tels:

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

Chaque colonne est les successeurs cycliques de chaque élément de a, avec à atravers la première ligne; cela est dû à la façon dont R recycle ses arguments dans une matrice.

Ensuite, nous prenons la "dérivée" inverse avec diffinv , essentiellement la somme cumulée de chaque colonne avec une additionnelle 0comme première ligne, générant la matrice

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

Dans la première colonne, entrée 6=4+2 est égale à 14=4 + (3+2+1+4), qui est la somme des successeurs cycliques (CSS) plus un interligne 4. De même, dans la deuxième colonne, l'entrée 5=3+2est égale à 10=3 + (4+1+2), etc.

Donc, dans la colonne i, lea[i]+2 nd entrée est égale à CSS(i)+a[i]. Par conséquent, nous prenons des lignes indexées par a+2, donnant une matrice carrée:

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

Les entrées le long de la diagonale sont égales aux sommes des successeurs cycliques plus a, donc nous extrayons la diagonale et soustrayons a, en renvoyant le résultat comme les sommes des successeurs cycliques.

Pyth, 13 11 octets

.esm@Q+dkSb

Enregistré 2 octets grâce à M. Xcoder.
Essayez-le ici

Explication

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

Fusain , 12 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

  θ             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

JavaScript ES6, 65 octets

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

Solution simple. Non golfé:

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

La map()fonction JavaScript est parfaite pour le travail, elle exécute le rappel donné contre chaque élément et le remplace par le résultat du rappel. Le rappel reçoit deux paramètres, le premier xest la valeur et le second yest l'index. En prenant le module, i % a.lengthnous pouvons facilement faire une boucle sur le tableau, plusieurs fois si nécessaire.

Extrait de test

(Mettez l'entrée en notation JSON)

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

<input id=I type="text" size=70 value="[4,3,2,1]"><button onclick="console.log(f(JSON.parse(I.value)))">Run</button>

Java 8, 87 octets

Un lambda vide au curry prenant une int[]liste et une intlongueur.

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];}

Essayez-le en ligne . Notez que j'ai suivi System.outce programme afin d'obtenir des résultats pour une impression plus jolie.

Julia 0,6 , 63 55 53 octets

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

Essayez-le en ligne!

Solution plus ancienne:

Julia 0,6 , 65 octets

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

Essayez-le en ligne!

Une autre solution. Pas génial par bytecount, mais j'aime ça, et c'est probablement plus efficace que les deux autres, surtout si l'entrée a de grands nombres.

Julia 0,6 , 69 octets

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

Essayez-le en ligne!

Toile , 10 octets

²Ｘ｛ｘ＋⁸＠］∑］

Essayez-le ici!

Explication:

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

QBasic 1.1 , 115 octets

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

La première entrée est la longueur L , puis les entrées suivantes L sont les éléments dans l'ordre. Les sorties L représentent le tableau résultant, avec les éléments dans l'ordre où ils sont présentés.

Japt, 7 octets

ËÆg°EÃx

Essayez-le ici

APL + WIN, 37 octets

Invite à saisir:

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

Essayez-le en ligne! Gracieuseté de Dyalog Classic

Explication:

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

Rubis , 38 octets

->a{w=0;a.map{|x|(a*-~x)[w+=1,x].sum}}

Essayez-le en ligne!

JavaScript, 65 octets 3̶0̶0̶ ̶b̶y̶t̶e̶s̶

golfé

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

non golfé

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

Essayez-le en ligne!

(version non golfée ci-dessus) Je suis nouveau dans ce truc de codegolf!

*mis à jour! grâce aux liens utiles fournis dans les commentaires, j'ai réussi à réduire la taille à 65 octets!

Perl 5 avec -M5.010, 42 octets

say sum+((@F,@F)x$_)[++$-..($-+$_-1)]for@F

Essayez-le en ligne!

JavaScript, 46 octets

a=>a.map(g=(x,y)=>x--&&a[++y%a.length]+g(x,y))

Essayez-le en ligne

Cjam, 23 octets

_ee{~,\)f+1$f=:+\}/;]S*

Essayez-le en ligne!

Pip -rn , 14 octets

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

Prend les numéros d'entrée sur les lignes successives de stdin; donne les numéros de sortie sur les lignes successives de sortie standard.Essayez-le en ligne!

Explication

             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)

Ou, en utilisant un exemple concret:

             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]

APL (Dyalog Classic) , 12 octets

+/¨⊢⍴¨⍳∘≢⌽¨⊂

Essayez-le en ligne!

les usages ⎕io←1

Perl 6 , 50 32 octets

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

Essayez-le en ligne!

Je suis nouveau au golf en Perl 6, donc je suis sûr que cela peut être plus court. Ce n'est plus nouveau, et revenons au golf!