Remplacez-moi par la somme de mes successeurs cycliques!

25

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 , 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]
M. Xcoder
la source

Réponses:

8

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
Giuseppe
la source
6

Gelée , 6 octets

ṙJṁS¥"

Essayez-le en ligne!

Erik le Outgolfer
la source
... ah ninja'd :(
Jonathan Allan
@JonathanAllan TBF, j'ai déjà eu ce genre de mensonge pendant une minute ou deux lorsque vous avez publié le vôtre (je pensais que l'entier lui-même devait également être inclus, donc avec un extra +à la fin). Aussi, peut-être que vous me ninja la prochaine fois. :)
Erik the Outgolfer
6

Python , 55 octets

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

Essayez-le en ligne!

Jonathan Allan
la source
pas trop familier avec python pouvez-vous expliquer la partie en parens après somme?
Jonah
2
Premièrement, l' ~opérateur n'est pas au niveau du bit, c'est en fait un raccourci pour -1-v, donc -~vc'est un raccourci pour -(-1-v)ce qui est juste 1+v(mais évite les parenthèses comme (1+v)*a). Deuxièmement, en Python, on peut multiplier une liste par un entier pour la répéter (par exemple, ['a','b']*3est ['a','b','a','b','a','b']). Le -~v*apourrait être remplacé par a+v*apour le même nombre d'octets. Enfin, [i:i+v]c'est une indexation de tranche, en gardant les éléments ià i+v-1(indexés 0) uniquement.
Jonathan Allan
6

J, 33 octets

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

non golfé

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

explication

enter image description here

Essayez-le en ligne!

Jonas
la source
explication de fantaisie: o
Conor O'Brien
1
Image sympa là-bas, mais je recommande de mettre l'explication sous forme de texte aussi, car les images peuvent ne pas durer éternellement. ;)
Erik the Outgolfer
7
Cela ressemble à un jeu roguelike.
aschepler
Quel est le score si vous réécrivez ma solution K en J?
streetster
6

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!

Jonathan Frech
la source
-1 octet:for(k=i=0;i++<y[l];)k+=y[(l+i)%c];
Jakob
1
Ayez mon vote positif pour C(y,c,l,i,k).
Jonas Schäfer
6

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   
nimi
la source
Bon travail! En fait, scanr (:) [] est tails
Damien
@Damien: queues. Droite! Merci!
nimi
4

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
Emigna
la source
4

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
streetster
la source
3

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.

Conor O'Brien
la source
3

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!

ngm
la source
Puisqu'il est permis de prendre la longueur comme argument supplémentaire ... 75
JayCe
1
69 drôle j'avais commencé quelque chose de similaire mais en utilisant cumsum et je me suis perdu dans le processus ... belle solution!
JayCe
66 (en utilisant Map. La sortie est un peu moche donc le lien TIO le répertorie. Je suppose qu'un programme complet serait encore plus court!
JayCe
il est
JayCe
63 octets
JayCe
3

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.

Giuseppe
la source
Ne peut pas attendre l'explication!
JayCe
@JayCe ajouté! comme cela arrive souvent, l'expliquer a conduit à un autre golf; Je recommande toujours d'ajouter une explication afin que vous ou d'autres personnes suivant vous puissiez trouver une autre approche, bien que je n'aie pas toujours le temps de le faire, haha.
Giuseppe
1
L'élément commun aux deux solutions est la génération efficace d'un recyclage suffisamment long de l'index ou des éléments eux-mêmes, car les langages indexés 1 ne peuvent pas utiliser gracieusement l'arithmétique modulaire pour revenir au début du tableau.
ngm
@ngm ouais, c'est sûr. J'aime bien votre utilisation Map, et à l'origine c'était comme 68 octets avant de comprendre que je pouvais prendre lcomme entrée!
Giuseppe
2

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.

la source
11 octets .
M. Xcoder
2

Fusain , 12 octets

IEθΣEι§θ⊕⁺κλ

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

  θ             Input array
 E              Map over elements
     ι          Current element
    E           Map over implicit range
           λ    Inner index
          κ     Outer index
         ⁺      Sum
        ⊕       Increment
       θ        Input array
      §         Cyclically index
   Σ            Sum
I               Cast to string
                Implicitly print on separate lines
Neil
la source
2

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)

Pedro A
la source
2

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.

Jakob
la source
2

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 ji+1:i+A[i])for i1: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[il*sum(A)for i1:l])

Essayez-le en ligne!

Sundar - Rétablir Monica
la source
1

Toile , 10 octets

²X{x+⁸@]∑]

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
dzaima
la source
1

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.

Erik le Outgolfer
la source
1

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
Graham
la source
1

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!

ArashSM79
la source
Bienvenue sur le site. Il y a deux façons d'améliorer cela. Vous pouvez utiliser des noms de variables à caractère unique et vous pouvez supprimer les espaces extra-blancs. (les opérateurs n'ont pas besoin d'être entourés d'espaces.)
Wheat Wizard
Au-delà des conseils de Cat Wizard, nous avons une collection de conseils pour jouer au golf en JavaScript . Comme vous dites que vous êtes nouveau au golf, vous pouvez également trouver intéressant les conseils génériques pour le golf dans <toutes les langues> .
manatwork
Vous devez ajouter la version golfée avant la version non golfée
Sefa
Vous supposez que le tableau est affecté d'une variable prédéfinie ( n), ce que nous n'autorisons pas. Bienvenue à PPCG, cependant :)
Shaggy
Voici une version de 59 octets .
Shaggy
0

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]
DLosc
la source
0

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!

Jo King
la source