Ersetze mich durch die Summe meiner zyklischen Nachfolger!

25

Diesmal habe ich eine einfache Herausforderung für dich. Ersetzen Sie bei einem gegebenen Array positiver Ganzzahlen A (oder dem Äquivalent in Ihrer Sprache) jeden Eintrag A i durch die Summe der nächsten A i -Elemente von A und fahren Sie von Anfang an zurück, wenn nicht genügend Elemente vorhanden sind.

Wie üblich können Sie in jeder Programmiersprache antreten und Eingaben und Ausgaben mit jeder Standardmethode und in jedem vernünftigen Format vornehmen. Beachten Sie jedoch, dass diese Lücken standardmäßig verboten sind. Optional können Sie auch die Größe von A als Eingabe verwenden. Dies ist Codegolf , daher gewinnt die kürzeste Übermittlung (in Bytes) für jede Sprache .

Beispiele / Testfälle

Gegeben [1,3,4,5], Code sollte eine Ausgabe [3,10,13,14], weil 1durch ersetzt wird 3, 3wird ersetzt durch 4+5+1=10( man beachte , wie es von Anfang an eingewickelt zurück), 4durch 5+1+3+4=13und 5durch 1+3+4+5+1=14.

Gegeben [3,2,1,9], Ihr Programm sollte produzieren [12,10,9,33], weil wir 3mit 2+1+9=12, 2mit 1+9=10, 1mit 9und 9mit ersetzen 3+2+1+9+3+2+1+9+3=33(beachten Sie, wie wir von Anfang an mehr als einmal zurückgebrochen haben).

Weitere Testfälle zur Auswahl:

[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 
— Mr. Xcoder
quelle

Antworten:

8

MATL , 10 9 Bytes

"G@:X@+)s

Probieren Sie es online!

	% 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
quelle
6

Python , 55 Bytes

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

Probieren Sie es online!

— Jonathan Allan
quelle
nicht allzu vertraut mit python kannst du den teil in parens nach summe erklären?
— Jonah
2
Erstens ist der ~Operator ein bitweises nicht, es ist effektiv eine Abkürzung für -1-v, also -~veine Abkürzung für -(-1-v)die gerade ist 1+v(aber Klammern wie vermeidet (1+v)*a). Zweitens kann man in Python eine Liste mit einer ganzen Zahl multiplizieren, um sie zu wiederholen (zB ['a','b']*3ist ['a','b','a','b','a','b']). Das -~v*akönnte durch a+v*adasselbe Byte ersetzt werden. Zuletzt [i:i+v]ist dies eine Slice-Indizierung, bei der Elemente nur imit i+v-1(0-Indizierung) versehen werden.
— Jonathan Allan
6

J, 33 Bytes

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

ungolfed

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

Erläuterung

Bildbeschreibung hier eingeben

Probieren Sie es online!

— Jona
quelle
Lust auf Erklärung: o
— Conor O'Brien
1
Cooles Bild da drüben, aber ich empfehle, die Erklärung auch in Textform zu schreiben, da die Bilder möglicherweise nicht ewig halten. ;)
— Erik der Outgolfer
7
Das sieht aus wie ein schurkenhaftes Spiel.
— Aschepler
Was ist die Punktzahl, wenn Sie meine K- Lösung in J umschreiben ?
— Streetster
6

Haskell, 50 47 44 Bytes

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

Probieren Sie es online!

                    -- <*> 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
quelle
Gute Arbeit! Eigentlich ist scanr (:) [] Schwänze
— Damien
@ Damien: Schwänze. Recht! Vielen Dank!
— Nimi
4

05AB1E , 8 7 Bytes

εL¾+èO¼

Probieren Sie es online!

Erläuterung

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

K4 / K (oK) , 20 19 Bytes

Lösung:

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

Probieren Sie es online!

Beispiele:

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

Erläuterung:

Formen Sie die Eingabe um, lassen Sie sie zuerst fallen, nehmen Sie jeweils die x-Länge und addieren Sie sie.

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

Attache , 26 Bytes

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

Probieren Sie es online!

Erläuterung

Dies ist eine Gabelung von zwei Funktionen:

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

Dies bedeutet, dass der rechte Strich Iotaauf das Argument angewendet xund als zweites Argument an den mittleren Strich (die erste Funktion) übergeben wird. Also wird dies für die Eingabe x:

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

Ersetzen der in _und _2:

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

Iota[x]gibt ein Array der Indizes von zurück x. Es ist gleichbedeutend mit 0...#x. #xist eine kurze Beschreibung der Größe von xoder Size[x]. Im Wesentlichen ordnet diese Funktion die SumFunktion dem zweiten Ausdruck zu:

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

Das äußere x[...]Bit bedeutet, dass ...eine Reihe von Indizes generiert wird, aus denen ausgewählt werden kann x. Der wichtigste Teil bei der Erstellung der Indizes ist:

Iota[x] + 1:x

Dieser Ausdruck verwendet ein wenig Vektorisierung. Nehmen wir zur Veranschaulichung an, die Eingabe ist x := [1, 3, 4, 5]. Dann ist dieser Ausdruck äquivalent zu:

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

Dies ist eine Liste von Indizes, die die nächsten NElemente in xmod darstellen #x. Um sie für den Abruf sicher zu machen, verwenden wir diesen Array-Mod #x:

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

Dies gibt uns die richtigen Indizes, die dann erhalten werden x und jedes Array wird summiert, was die richtigen Ergebnisse ergibt.

Andere Versuche

36 Bytes: {Sum@_&Get=>((_2+1.._2+_)%#_)}#Iota - Ich habe die x[...]Vektorisierung komplett vergessen , so dass:

30 bytes: {Sum=>_[(_2+1.._2+_)%#_]}#Iota - aber dann wurde mir klar, dass der _2+innere Bereich herausgerechnet werden konnte, was bedeutet, dass wir Klammern sparen konnten , indem wir :anstelle von ..die aktuelle Version gaben.

— Conor O'Brien
quelle
3

R , 89 64 Bytes

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

Probieren Sie es online!

Hauptidee, um einen ausreichend langen Zyklusindexvektor zu generieren, mit dem Sie die erforderlichen Elemente aus dem Eingabevektor abrufen können.

Originalfassung:

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

Probieren Sie es online!

— ngm
quelle
Da es erlaubt ist, die Länge als zusätzliches Argument zu nehmen ... 75
— JayCe
1
69 lustig ich hatte etwas ähnliches angefangen aber mit cum und bin dabei verloren gegangen ... nette lösung!
— JayCe
66 (unter Verwendung von Map. Die Ausgabe ist ein bisschen hässlich, so dass der TIO-Link sie nicht auflistet. Ich denke, ein volles Programm wäre noch kürzer!
— JayCe
— JayCe
— JayCe
3

R , 62 58 Bytes

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

Probieren Sie es online!

Eine Alternative zur anderen R-Lösung . In den Kommentaren erwähnte JayCe,cumsum was etwas in meinem Gehirn auslöste, um diffinvMatrix-Recycling statt zu verwenden rep.

Erläuterung:

Gegebenes Eingabearray a lassen M=max(a)und l=length(a).

Beachten Sie, dass M+ldie maximal mögliche Index wir Zugang bräuchten, und das M+l<=M*l+1, denn wenn M,l>1, M+l<=M*l(mit Gleichheit nur dann , wennM=l=2 ) und wenn l==1oder M==1, dann M+l==M*l+1.

Beispielhaft sei gesagt a=c(4,3,2,1). Dann M=l=4.

Wir konstruieren die M*l+1 x lMatrix in R durch matrix(a,max(a)*l+1,l). Da R ain der Hauptreihenfolge der Spalten recycelt wird, erhalten wir eine Matrix, die die Elemente von wiederholta als solche :

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

Jede Spalte ist der zyklische Nachfolger jedes Elements von a , mit aüber die erste Zeile; Dies liegt an der Art und Weise, wie R seine Argumente in einer Matrix wiederverwendet.

Als nächstes nehmen wir die inverse "Ableitung" diffinv, im wesentlichen die kumulative Summe jeder Spalte mit einer zusätzlichen 0als erste Zeile, die die Matrix erzeugt

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

In der ersten Spalte ist der Eintrag 6=4+2gleich 14=4 + (3+2+1+4), dh die zyklische Nachfolgesumme (CSS) plus eine führende 4. In ähnlicher Weise ist der Eintrag in der zweiten Spalte 5=3+2gleich 10=3 + (4+1+2)und so weiter.

In der Spalte iist der a[i]+2nd-Eintrag also gleich CSS(i)+a[i]. Daher nehmen wir Zeilen, die durch indiziert sind a+2, und ergeben eine quadratische Matrix:

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

Die Einträge entlang der Diagonale sind gleich den zyklischen Nachfolgersummen plus a, also extrahieren wir die Diagonale und subtrahieren aund geben das Ergebnis als zyklische Nachfolgersummen zurück.

— Giuseppe
quelle
Ich kann die Erklärung kaum erwarten!
— JayCe
@JayCe hinzugefügt! Wie so oft führte das Erklären zu einem anderen Golf; Ich empfehle immer, eine Erklärung hinzuzufügen, damit Sie oder andere, die dahinter stehen, einen anderen Ansatz finden können, obwohl ich nicht immer Zeit habe, dies zu tun, haha.
— Giuseppe,
1
Beiden Lösungen gemeinsam ist die effiziente Generierung einer ausreichend langen Wiederverwendung des Index oder der Elemente selbst, da Sprachen mit einem Index die modulare Arithmetik nicht ordnungsgemäß verwenden können, um zum Anfang des Arrays zurückzukehren.
— ngm
@ngm ja, sicher. Ich mag deine Verwendung vonMap , und ursprünglich war dies wie 68 Bytes, bevor ich herausfand, dass ich lals Eingabe nehmen könnte !
— Giuseppe,
2

Pyth, 13 11 Bytes

.esm@Q+dkSb

2 Bytes gespart dank Mr. Xcoder.
Probieren Sie es hier aus

Erläuterung

.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.
— Mr. Xcoder
2

Kohle , 12 Bytes

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

Probieren Sie es online!Link ist eine ausführliche Version des Codes. Erläuterung:

  θ             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
— Neil
quelle
2

JavaScript ES6, 65 Byte

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

Einfache Lösung. Ungolfed:

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

Die JavaScript- map()Funktion ist perfekt für den Job. Sie führt den angegebenen Rückruf für jedes Element aus und ersetzt ihn durch das Ergebnis des Rückrufs. Der Rückruf empfängt zwei Parameter, der erste xist der Wert und der zweite yist der Index. Durch Ermitteln des Moduls können i % a.lengthwir das Array bei Bedarf problemlos mehrmals durchlaufen.

Testschnipsel

(Setzen Sie die Eingabe als JSON-Notation)

Code-Snippet anzeigen

— Pedro A
quelle
2

Java 8, 87 Bytes

Ein Curry-Lambda ohne Inhalt, das eine int[]Liste und eine intLänge annimmt .

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

Probieren Sie es online . Beachten Sie, dass ich System.outin diesem Programm einen Shadow erstellt habe , um die Ergebnisse für einen schöneren Ausdruck zu erhalten.

— Jakob
quelle
2

Julia 0,6 , 63 55 53 Bytes

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

Probieren Sie es online!

Ältere Lösung:

Julia 0,6 , 65 Bytes

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

Probieren Sie es online!

Eine andere Lösung. Von bytecount nicht besonders gut, aber ich mag es und es ist wahrscheinlich effizienter als die anderen beiden, besonders wenn der Eingang große Zahlen enthält.

Julia 0,6 , 69 Bytes

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

Probieren Sie es online!

— Sundar - Setzen Sie Monica wieder ein
quelle
1

Canvas , 10 Bytes

²Ｘ｛ｘ＋⁸＠］∑］

Probieren Sie es hier aus!

Erläuterung:

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

QBasic 1.1 , 115 Bytes

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

Erste Eingabe ist die Länge L , dann L nachfolgende Eingaben sind die Elemente in der Reihenfolge. L Ausgaben repräsentieren das resultierende Array mit den Elementen in der Reihenfolge, in der sie dargestellt werden.

— Erik der Outgolfer
quelle
1

APL + WIN, 37 Bytes

Eingabeaufforderungen:

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

Probieren Sie es online! Mit freundlicher Genehmigung von Dyalog Classic

Erläuterung:

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
quelle
1

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

Golf gespielt

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

ungolfed

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

Probieren Sie es online!

Ich bin neu in dieser Codegolf-Sache!

*aktualisiert! Dank der nützlichen Links in den Kommentaren konnte ich die Größe auf 65 Bytes reduzieren!

— ArashSM79
quelle
Willkommen auf der Seite. Es gibt verschiedene Möglichkeiten, dies zu verbessern. Sie können einzelne Zeichenvariablennamen verwenden und Leerzeichen entfernen. (Bediener müssen nicht von Leerzeichen umgeben sein.)
— Weizen-Assistent
Abgesehen von den Tipps von Cat Wizard haben wir eine Sammlung von Tipps zum Golfen in JavaScript . Wie Sie sagen, Sie sind neu im Golfsport, können Sie auch die generischen Tipps für das Golfen in <allen Sprachen> interessant finden .
— Manatwork
Sie sollten die Golf-Version vor der nicht-Golf-Version hinzufügen
— Sefa
Sie gehen davon aus, dass dem Array eine vordefinierte Variable zugewiesen ist (n ) , die wir nicht zulassen. Willkommen bei PPCG :)
— Shaggy
Hier ist ein 59-Byte-Version .
— Shaggy
0

Pip -rn , 14 Bytes

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

Nimmt Eingabenummern in aufeinanderfolgenden Zeilen von stdin an; gibt Ausgangsnummern in aufeinanderfolgenden Zeilen von stdout aus.Probieren Sie es online!

Erläuterung

             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)

Oder anhand eines Beispiels:

             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
quelle
0

Perl 6 , 50 32 Bytes

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

Probieren Sie es online!

Ich bin neu beim Golfen in Perl 6, daher bin ich mir sicher, dass dies kürzer sein kann. Nicht mehr neu und zurück zum Golfen!

— Scherzen
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.