Zastąp mnie sumą moich cyklicznych następców!

25

Tym razem mam dla ciebie proste wyzwanie. Biorąc pod uwagę tablicę dodatnich liczb całkowitych A (lub odpowiednika w Twoim języku), zamień każdy wpis A i na sumę kolejnych elementów A i A , cofając się od początku, jeśli nie ma wystarczającej liczby pozycji.

Jak zwykle, możesz konkurować w dowolnym języku programowania i możesz przyjmować dane wejściowe i dostarczać dane wyjściowe za pomocą dowolnej standardowej metody i w dowolnym rozsądnym formacie, zwracając uwagę, że te luki są domyślnie zabronione. Opcjonalnie możesz również przyjąć wielkość A jako dane wejściowe. To jest , więc wygrywa najkrótsze przesłanie (w bajtach) dla każdego języka .

Przykłady / przypadki testowe

Biorąc pod uwagę [1,3,4,5], twój kod powinien wypisać [3,10,13,14], ponieważ 1jest zastąpiony przez 3, 3jest zastąpiony przez 4+5+1=10(zauważ, jak jest zawijany od początku), 4przez 5+1+3+4=13i 5przez 1+3+4+5+1=14.

Biorąc pod uwagę [3,2,1,9], Twój program powinien produkować [12,10,9,33], bo zastąpił 3z 2+1+9=12, 2z 1+9=10, 1z 9oraz 9z 3+2+1+9+3+2+1+9+3=33(Zauważ jak owinięty powrotem od początku więcej niż raz).

Kilka innych przypadków testowych do wyboru:

[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]
Pan Xcoder
źródło

Odpowiedzi:

8

MATL , 10 9 bajtów

"G@:X@+)s

Wypróbuj 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
źródło
6

Galaretka , 6 bajtów

ṙJṁS¥"

Wypróbuj online!

Erik the Outgolfer
źródło
... ah ninja'd :(
Jonathan Allan
@JonathanAllan TBF, już tak jakby kłamałem przez minutę lub dwie, kiedy opublikowałeś swoją (myślałem, że sama liczba całkowita również musi być uwzględniona, więc z dodatkową +na końcu). Poza tym, może następnym razem będziesz mnie ninja. :)
Erik the Outgolfer
6

Python , 55 bajtów

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

Wypróbuj online!

Jonathan Allan
źródło
niezbyt zaznajomiony z pytonem, czy potrafisz wyjaśnić tę część w parens po sumie?
Jonah
2
Po pierwsze, ~operator nie jest odrobinę bitowy, jest skutecznie skrócony -1-v, więc -~vjest skrócony, dla -(-1-v)którego jest po prostu 1+v(ale unika nawiasów takich jak (1+v)*a). Po drugie, w Pythonie można pomnożyć listę przez liczbę całkowitą, aby ją powtórzyć (np. ['a','b']*3Jest ['a','b','a','b','a','b']). -~v*aMożna zastąpić a+v*adla tej samej liczby bajtów. Wreszcie [i:i+v]jest indeksowanie plaster, zachowując elementy ido i+v-1(0-indeksowane) tylko.
Jonathan Allan
6

J, 33 bajty

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

bez golfa

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

wyjaśnienie

enter image description here

Wypróbuj online!

Jonasz
źródło
fantazyjne wyjaśnienie: o
Conor O'Brien
1
Fajny obraz tam, ale zalecam również umieszczenie wyjaśnienia w formie tekstowej, ponieważ obrazy mogą nie trwać wiecznie. ;)
Erik the Outgolfer
7
To wygląda jak gra typu roguelike.
aschepler
Jaki jest wynik, jeśli przepiszesz moje rozwiązanie K w J?
streetster
6

C (gcc) , 86 85 bajtów

  • Zaoszczędził bajt dzięki Jakobowi .
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]);}

Wypróbuj online!

Jonathan Frech
źródło
-1 bajt:for(k=i=0;i++<y[l];)k+=y[(l+i)%c];
Jakob
1
Mam głos za C(y,c,l,i,k).
Jonas Schäfer
6

Haskell, 50 47 44 bajtów

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

Wypróbuj 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
źródło
Dobra robota! W rzeczywistości, scanr (:) [] to reszka
Damien
@Damien: ogony. Dobrze! Dzięki!
nimi
4

05AB1E , 8 7 bajtów

εL¾+èO¼

Wypróbuj online!

Wyjaśnienie

ε        # 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
źródło
4

K4 / K (oK) , 20 19 bajtów

Rozwiązanie:

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

Wypróbuj online!

Przykłady:

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

Wyjaśnienie:

Przekształć dane wejściowe, upuść najpierw, weź x długość każdego, podsumuj.

+/'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
źródło
3

Attache , 26 bajtów

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

Wypróbuj online!

Wyjaśnienie

Oto rozwidlenie dwóch funkcji:

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

Oznacza to, że odpowiedni Iotaargument jest stosowany do argumentu xi jest przekazywany jako drugi argument do środkowego palca (pierwsza funkcja). Staje się to dla danych wejściowych x:

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

Zamieniając je na _i _2:

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

Iota[x]zwraca tablicę indeksów x. Jest to równoważne z 0...#x. #xto krótki sposób określenia wielkości xlub Size[x]. Zasadniczo ta funkcja mapuje Sumfunkcję na drugie wyrażenie:

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

x[...]Bit zewnętrzny oznacza, że ...wygeneruje serię wskaźników do wyboru x. Najważniejsza część generowania indeksów to:

Iota[x] + 1:x

To wyrażenie używa trochę wektoryzacji. Aby to zwizualizować, załóżmy, że dane wejściowe są x := [1, 3, 4, 5]. Następnie to wyrażenie jest równoważne z:

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

To jest lista indeksów, które reprezentują indeksy kolejnych Nelementów w xmodzie #x. Aby zabezpieczyć je przed odzyskaniem, bierzemy ten mod tablicy #x:

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

To daje nam odpowiednie wskaźniki, które są następnie uzyskiwane z x każdej tablicy i sumowane, dając odpowiednie wyniki.

Inne próby

36 bajtów: {Sum@_&Get=>((_2+1.._2+_)%#_)}#Iota - Zapomniałem x[...]całkowicie wektoryzacji, więc staje się:

30 bajtów: {Sum=>_[(_2+1.._2+_)%#_]}#Iota - ale potem zdałem sobie sprawę, że _2+wewnętrzny zakres może być rozłożony na czynniki, co oznacza, że ​​możemy zapisać nawiasy, używając :zamiast .., dając nam bieżącą wersję.

Conor O'Brien
źródło
3

R , 89 64 bajtów

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

Wypróbuj online!

Główny pomysł, aby wygenerować wystarczająco długi wektor wskaźnika cyklicznego, którego można użyć, aby uzyskać potrzebne elementy z wektora wejściowego.

Orginalna wersja:

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

Wypróbuj online!

ngm
źródło
Ponieważ można potraktować tę
kwestię
1
69 śmieszne Zacząłem coś podobnego, ale używając sumy i zgubiłem się w tym procesie ... fajne rozwiązanie!
JayCe
66 (przy użyciu Map. Wyjście jest trochę brzydkie, więc link TIO un wyświetla go. Myślę, że pełny program byłby jeszcze krótszy!
JayCe
to jest
JayCe
63 bajty
JayCe,
3

R , 62 58 bajtów

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

Wypróbuj online!

Alternatywą dla innego rozwiązania R . W komentarzach JayCe wspomniał o tym,cumsum co uruchomiło w moim mózgu coś do użycia diffinvi zamiast recyklingu matrycy rep.

Wyjaśnienie:

Biorąc pod uwagę tablicę wejściową a, let M=max(a)i l=length(a).

Zauważ, że M+ljest to maksymalny możliwy indeks, do którego musielibyśmy uzyskać dostęp, i że M+l<=M*l+1, jeśli M,l>1, M+l<=M*l(z równością tylko wtedy, gdy M=l=2) i jeśli l==1lub M==1, to M+l==M*l+1.

Na przykład niech a=c(4,3,2,1). Potem M=l=4.

Konstruujemy M*l+1 x lmacierz w R przez matrix(a,max(a)*l+1,l). Ponieważ R poddaje się recyklingowi aw porządku głównym kolumny, otrzymujemy macierz powtarzającą elementy ajako takie:

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

Każda kolumna jest cyklicznym następcą każdego elementu a, z aw pierwszym rzędzie; wynika to ze sposobu, w jaki R przetwarza swoje argumenty w macierzy.

Następnie bierzemy odwrotną „pochodną” z diffinvzasadniczo skumulowaną sumą każdej kolumny z dodatkowym 0jako pierwszy wiersz, generując macierz

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

W pierwszej kolumnie wpis 6=4+2jest równy 14=4 + (3+2+1+4), czyli suma następcy cyklicznego (CSS) plus wiodąca 4. Podobnie w drugiej kolumnie wpis 5=3+2jest równy 10=3 + (4+1+2)i tak dalej.

Więc w kolumnie iThe a[i]+2nd pozycja jest równa CSS(i)+a[i]. Dlatego bierzemy wiersze indeksowane a+2, uzyskując macierz kwadratową:

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

Wpisy wzdłuż przekątnej są równe cyklicznym sumom następcy plus a, więc wyodrębniamy przekątną i odejmujemy a, zwracając wynik jako sumy cyklicznego następcy.

Giuseppe
źródło
Nie mogę się doczekać wyjaśnienia!
JayCe
@JayCe dodane! jak to często bywa, wyjaśnienie doprowadziło do kolejnego golfa; Zawsze zalecam dodanie wyjaśnienia, abyście ty lub inni podążający za nim mogli znaleźć inne podejście, chociaż nie zawsze mam na to czas, haha.
Giuseppe,
1
Wspólnym elementem obu rozwiązań jest wydajne generowanie wystarczająco długiego recyklingu indeksu lub samych elementów, ponieważ języki 1-indeksowane nie mogą z wdziękiem używać arytmetyki modułowej, aby wrócić do początku tablicy.
ngm
@ngm tak, na pewno. Podoba mi się twoje użycie Mapi pierwotnie było to jak 68 bajtów, zanim zorientowałem się, że mogę wziąć ljako dane wejściowe!
Giuseppe,
2

Pyth, 13 lat 11 bajtów

.esm@Q+dkSb

Zaoszczędzono 2 bajty dzięki Mr. Xcoder.
Wypróbuj tutaj

Wyjaśnienie

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

źródło
11 bajtów .
Pan Xcoder,
2

Węgiel drzewny , 12 bajtów

IEθΣEι§θ⊕⁺κλ

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

  θ             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
źródło
2

JavaScript ES6, 65 bajtów

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

Proste rozwiązanie. Nie golfowany:

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

map()Funkcja JavaScript jest idealna do zadania, uruchamia określone wywołanie zwrotne dla każdego elementu i zastępuje go wynikiem wywołania zwrotnego. Oddzwonienie otrzymuje dwa parametry, pierwszy xto wartość, a drugi yto indeks. Biorąc moduł i % a.length, możemy z łatwością zapętlić tablicę, w razie potrzeby wielokrotnie.

Testowy fragment kodu

(Wprowadź dane wejściowe jako notację JSON)

Pedro A.
źródło
2

Java 8, 87 bajtów

Curled pustka lambda biorąc int[]listę i intdługość.

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

Wypróbuj online . Zwróć uwagę, że śledziłem System.outten program w celu pobrania wyników dla ładniejszego drukowania.

Jakob
źródło
2

Julia 0,6 , 63 55 53 bajtów

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

Wypróbuj online!


Starsze rozwiązanie:

Julia 0.6 , 65 bajtów

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

Wypróbuj online!


Inne rozwiązanie. Pod względem liczby bajtów nie jest świetny, ale podoba mi się i prawdopodobnie jest bardziej wydajny niż pozostałe dwa, zwłaszcza jeśli dane wejściowe mają duże liczby.

Julia 0.6 , 69 bajtów

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

Wypróbuj online!

sundar - Przywróć Monikę
źródło
1

Płótno , 10 bajtów

²X{x+⁸@]∑]

Wypróbuj tutaj!

Wyjaśnienie:

{         ] 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
źródło
1

QBasic 1.1 , 115 bajtów

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

Pierwsze wejście to długość L , następnie L kolejne wejścia to elementy w kolejności. Wyjścia L reprezentują wynikową tablicę z elementami w kolejności, w jakiej są prezentowane.

Erik the Outgolfer
źródło
1

APL + WIN, 37 bajtów

Monity o wprowadzenie:

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

Wypróbuj online! Dzięki uprzejmości Dyalog Classic

Wyjaśnienie:

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
źródło
1

JavaScript, 65 bajtów 3̶0̶0̶ ̶b̶y̶t̶e̶s̶

grał w golfa

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

bez golfa

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

Wypróbuj online!

(wersja bez golfisty powyżej) Jestem nowy w tej grze w golfa!


* zaktualizowano! dzięki przydatnym linkom podanym w komentarzach udało mi się zmniejszyć rozmiar do 65 bajtów!

ArashSM79
źródło
Witamy na stronie. Można to poprawić na kilka sposobów. Możesz użyć nazw zmiennych jednoznakowych i możesz usunąć spacje. (operatorzy nie muszą być otoczeni spacjami.)
Wheat Wizard
Oprócz wskazówek Cat Wizard, mamy kolekcję porad dotyczących gry w golfa w JavaScript . Jak mówisz, że dopiero zaczynasz grać w golfa, możesz również zainteresować się ogólnymi wskazówkami dotyczącymi gry w golfa w <wszystkich językach> .
manatwork
Powinieneś dodać wersję golfową przed nie golfową
Sefa
Zakładasz, że tablica ma przypisaną predefiniowaną zmienną ( n), na co nie zezwalamy. Witamy jednak w PPCG :)
Kudłaty
Oto wersja 59-bajtowa .
Kudłaty
0

Pip -rn , 14 bajtów

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

Pobiera liczby wejściowe w kolejnych liniach standardowego wejścia; podaje liczby wyjściowe w kolejnych liniach standardowego wyjścia. Wypróbuj online!

Wyjaśnienie

             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)

Lub korzystając z działającego przykładu:

             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
źródło
0

Perl 6 , 50 32 bajtów

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

Wypróbuj online!

Jestem nowym golfistą w Perlu 6, więc jestem pewien, że może być krótszy. Już nie nowe, i wróć do golfa!

Jo King
źródło