Zainspirowany przez tym

W połączonym wyzwaniu jesteśmy proszeni o zastosowanie dodatku do elementów oryginału i rewersu tablicy wejściowej. W tym wyzwaniu nieco utrudnimy, wprowadzając inne podstawowe operacje matematyczne.

Biorąc pod uwagę tablicę liczb całkowitych, przechodź przez +, *, -, //, %, ^, gdzie //jest dzielenie liczb całkowitych i ^wykładnik, jednocześnie stosując je do odwrotnej strony tablicy. Lub innymi słowy, zastosuj jedną z powyższych funkcji do każdego elementu tablicy, przy czym drugi argument jest odwrotnością tablicy, a funkcja zastosowana przewija się przez powyższą listę. Może to nadal być mylące, więc przejrzyjmy przykład.

Input:   [1, 2, 3, 4, 5, 6, 7, 8, 9]
Reverse: [9, 8, 7, 6, 5, 4, 3, 2, 1]

         [ 1,  2,  3,  4,  5,    6,  7,  8,  9]
Operand:   +   *   -   /   %     ^   +   *   -
         [ 9,  8,  7,  6,  5,    4,  3,  2,  1]

Result:  [10, 16, -4,  0,  0, 1296, 10, 16,  8]

więc wyjściem [1, 2, 3, 4, 5, 6, 7, 8, 9]byłoby[10, 16, -4, 0, 0, 1296, 10, 16, 8]

Aby uwzględnić przypadki narożne, dane wejściowe nigdy nie będą zawierać 0, ale mogą zawierać dowolną liczbę całkowitą z zakresu od ujemnej nieskończoności do dodatniej nieskończoności. Jeśli chcesz, możesz wprowadzić dane jako listę ciągów znaków reprezentujących cyfry.

Przypadki testowe

input => output

[1, 2, 3, 4, 5, 6, 7, 8, 9]     => [10, 16, -4, 0, 0, 1296, 10, 16, 8]
[5, 3, 6, 1, 1]                 => [6, 3, 0, 0, 1]
[2, 1, 8]                       => [10, 1, 6]
[11, 4, -17, 15, 2, 361, 5, 28] => [39, 20, -378, 7, 2, 3.32948887119979e-44, 9, 308]

To jest golf golfowy, więc wygrywa najkrótszy kod (w bajtach)!

Galaretka, 10 bajtów ( widelec )

+×_:%*6ƭ"Ṛ

Pracowałem nad szybkim wdrożeniem tego drugiego dnia, więc dość zaskakujące jest, że tak szybko go wykorzystam. Nadal istnieje tylko jako widelec, więc nie możesz wypróbować go online.

Próbka wyjściowa

$ ./jelly eun '+×_:%*6ƭ"Ṛ' '[1,2,3,4,5,6,7,8,9]'
[10, 16, -4, 0, 0, 1296, 10, 16, 8]
$ ./jelly eun '+×_:%*6ƭ"Ṛ' '[5,3,6,1,1]'
[6, 3, 0, 0, 1]
$ ./jelly eun '+×_:%*6ƭ"Ṛ' '[2,1,8]'
[10, 1, 6]
$ ./jelly eun '+×_:%*6ƭ"Ṛ' '[11,4,-17,15,2,361,5,28]'
[39, 20, -378, 7, 2, 3.32948887119979e-44, 9, 308]

Wyjaśnienie

+×_:%*6ƭ"Ṛ  Input: array
      6ƭ    Tie 6 dyads
+             Addition
 ×            Multiplication
  _           Subtraction
   :          Integer division
    %         Modulo
     *        Power
        "   Vectorize with
         Ṛ  Reverse

Łuska , 16 bajtów

To wyzwanie preferuje języki, które mogą tworzyć nieskończone listy funkcji. Może nie, evalFTW

zF¢+ë+*-÷e%^Ṡze↔

Wypróbuj online!

W jaki sposób?

  ¢+ë+*-÷e%^         The infinite list [+,*,-,÷,%,^,+,*,-,...
    ë+*-÷            The list [+,*,-,÷]
         e%^         The list [%,^]
   +                 Concatenated
  ¢                  Then repeated infinitely
               ↔     The input reversed e.g [9,8,7,6,5,4,3,2,1]
            Ṡze      Zipped with itself     [[9,1],[8,2],[7,3],[6,4],[5,5],[4,6],[3,7],[2,8],[1,9]]
zF                   Zipwith reduce, the list of functions and the list of lists.
                     [F+[9,1],F*[8,2],F-[7,3],F÷[6,4],F%[5,5],F^[4,6],F+[3,7],F*[2,8],F-[1,9]]
                     [10     ,16     ,-4     ,0      ,0      ,1296   ,10     ,16     ,8      ]

Alternatywne rozwiązanie 17-bajtowe:

ṠozIzI¢+ë+*-÷e%^↔

05AB1E , 18 bajtów

Â"+*-÷%m"Ig×)øε`.V

Wypróbuj online!

Wyjaśnienie

                    # push a reversed copy of the input
 "+*-÷%m"            # push the list of operators
         Ig×         # repeat it input times
            )ø       # zip together
              ε      # apply to each triplet
               `     # push separately to stack
                .V   # evaluate

Narzędzia Bash + GNU, 53

tac $1|paste -d, $1 -|tr ',
' '
;'|paste -sd+*-/%^|bc

Ten skrypt przyjmuje nazwę pliku jako parametr wiersza polecenia.

Wypróbuj online .

Dobrą rzeczą jest to, że paste -dpozwala podać listę separatorów, które są używane cyklicznie. Reszta po prostu wprowadza dane wejściowe we właściwym formacie, aby to zrobić.

Galaretka , 15 bajtów

żṚj"“+×_:%*”ṁ$V

Wypróbuj online! lub zobacz zestaw testowy .

W jaki sposób?

żṚj"“+×_:%*”ṁ$V - Link: list of numbers, a       e.g. [5, 3, 6, 1, 1]
 Ṛ              - reverse a                           [1, 1, 6, 3, 5]
ż               - interleave                          [[5,1],[3,1],[6,6],[1,3],[1,5]
             $  - last two links as a monad:
    “+×_:%*”    -   literal list of characters        ['+','×','_',':','%','*']
            ṁ   -   mould like a                      ['+','×','_',':','%']
   "            - zip with the dyad:
  j             -   join                              ["5+1","3×1","6_6","1:3","1%5"]
              V - evaluate as Jelly code (vectorises) [6, 3, 0, 0, 1]

Python 2 , 67 bajtów

-3 bajty dzięki ovs.

lambda l:[eval(j+'*+*-/%*'[-~i%6::6]+l[~i])for i,j in enumerate(l)]

Wypróbuj online!

Python 2 , 95 bajtów

lambda l:[[add,mul,sub,div,mod,pow][i%6](v,l[~i])for i,v in enumerate(l)]
from operator import*

Wypróbuj online!

evaljest zły ... ale może bardziej golfowy. : P

JavaScript (ES7), 68 67 bajtów

a=>[...a].map((v,i)=>(x=a.pop(),o='+*-/%'[i%6])?eval(v+o+x)|0:v**x)

let f =

a=>[...a].map((v,i)=>(x=a.pop(),o='+*-/%'[i%6])?eval(v+o+x)|0:v**x)

console.log(JSON.stringify(f([1, 2, 3, 4, 5, 6, 7, 8, 9]    ))) // [10, 16, -4, 0, 0, 1296, 10, 16, 8]
console.log(JSON.stringify(f([5, 3, 6, 1, 1]                ))) // [6, 3, 0, 0, 1]
console.log(JSON.stringify(f([2, 1, 8]                      ))) // [10, 1, 6]
console.log(JSON.stringify(f([11, 4, -17, 15, 2, 361, 5, 28]))) // [39, 20, -378, 7, 2, 3.32948887119979e-44, 9, 308]

Perl 6 ,67 66 bajtów

Zaoszczędzono 1 bajt dzięki @nwellnhof.

{map {EVAL ".[0] {<+ * - div % **>[$++%6]} .[1]"},zip $_,.reverse}

Wypróbuj online!

Bardzo niewyobrażalne (i prawdopodobnie złe) rozwiązanie. Zamyka argument z samym sobą. Wynikowa lista jest następnie odwzorowywana na blok, który EVALjest ciągiem a (operator) b. Operator jest wybierany z listy ciągów <+ * - div % **>za pomocą zmiennej free state(pomyśl staticw C - wartość utrzymuje się w wywołaniach bloku) $. Jest on tworzony dla każdego bloku osobno i ustawiany na 0. Możesz z nim robić, co tylko chcesz, ale możesz odwoływać się do niego tylko raz (w rzeczywistości każde wystąpienie $odnosi się do innej zmiennej). Tak $++%6naprawdę wynosi 0 podczas pierwszego połączenia, 1 podczas drugiego, ... 5 podczas 6, 0 podczas 7 i tak dalej.

Na początku próbowałem obejść się bez EVAL. Operatory to w rzeczywistości tylko napisy (= funkcje), ale ich nazwy są tak bardzo nieżyczliwe ( &infix:<+>i tak dalej), że musiałem zrezygnować z takiego podejścia.

Haskell , 74 117 105 bajtów

x#y=fromIntegral.floor$x/y
x%y=x-x#y
f u=[o a b|(o,a,b)<-zip3(cycle[(+),(*),(-),(#),(%),(**)])u(reverse u)]

Wypróbuj online!

Zaoszczędzono 12 bajtów dzięki @nimi

Jest na pewno lepszy sposób na osiągnięcie tego.

EDYCJA 1. Naprawiono wykładnik liczb całkowitych; 2. Jest zdecydowanie lepszy sposób, patrz komentarz poniżej: 95 91 bajtów

x#y=fromIntegral.floor$x/y
x%y=x-x#y
f=zipWith3($)(cycle[(+),(*),(-),(#),(%),(**)])<*>reverse

Wypróbuj online!

Python 2 , 71 bajtów

lambda l:[eval(y+'+*-/%*'[x%6]*-~(x%6>4)+l[~x])for x,y in enumerate(l)]

Wypróbuj online!

Zaoszczędzono 2 bajty dzięki ovs!

J, ₄₄ 42 bajty

Przekreślony 44, yada yada ...

-2 bajty dzięki @ ConorO'Brien

_2+/`(*/)`(-/)`(<.@%/)`(|~/)`(^/)\[:,],.|.

Wypróbuj online!

Tyle paren i wkładek ... Z pewnością jest lepszy sposób na zrobienie tego (być może zamiast wstawiania zamiast wstawiania?)

Wyjaśnienie

_2(+/)`(*/)`(-/)`(<.@%/)`(|~/)`(^/)\[:,],.|.  Input: a
                                       ],.|.  Join a with reverse(a)
                                      ,       Ravel (zip a with reverse(a))
_2                                 \          To non-overlapping intervals of 2
  (+/)`(*/)`(-/)`(<.@%/)`(|~/)`(^/)           Apply the cyclic gerund
   +/                                           Insert addition
        */                                      Insert subtraction
             -/                                 Insert division 
                  <.@%/                         Insert integer division
                          |~/                   Insert mod
                                ^/              Insert exponentiation

Niektóre uwagi:

J nie ma podziału na liczby całkowite, więc komponujemy %-division z -floor >.. J's mod ( |) wykonuje odwrotną kolejność, niż byśmy się spodziewali, więc musimy odwrócić jego kolejność używając ~-reflexive.

Mimo że poruszamy się w odstępach 2, musimy użyć opcji /-insert, aby wstawić czasowniki, aby były używane w sposób dyadyczny, ponieważ tak \działa -infix.

Rubin , 63 57 bajtów

->a{t=0;a.map{|x|eval [x,a[t-=1]]*%w(** % / - * +)[t%6]}}

Naprawdę nic szczególnego. Wystarczy wykonać iterację w tablicy, użyć indeksu jako iteratora wstecznego, połączyć w ciąg za pomocą odpowiedniego operatora, ocenić, przepłukać i powtórzyć.

Wypróbuj online!

k , 40 bajtów

{_((#x)#(+;*;-;%;{y!x};{*/y#x})).'x,'|x}

Wypróbuj online!

{                                      } /function(x)
                                     |x  /reverse x
                                  x,'    /zip concat with x
        ( ; ; ; ;     ;       )          /list of operations
         + * - %                         /add, mult, sub, div
                 {y!x}                   /mod (arguments need to be reversed)
                       {*/y#x}           /pow (repeat and fold multiply)
  ((#x)#                       )         /resize operations to length of x
                                .'       /zip apply
 _                                       /floor result

MATL ,27 23 bajty

-4 bajty dzięki @LuisMendo

tP+1M*1M-IM&\w1M^v"@X@)

Wypróbuj online!

Wyjaśnienie:

tP         % duplicate and flip elements
+          % push array of sums (element-wise)
1M*        % push array of products (element-wise)
1M-        % push array of subtractions (element-wise)
IM&\w      % push array of divisions and modulo (element-wise)
1M^        % push array of power (element-wise)
v          % vertically concatenate all arrays
"@X@)    % push to stack values with the correct index based on operator
           % (implicit) convert to string and display

Perl 5 , 68 + 1 (-p) = 69 bajtów

print$",eval'int 'x($i%6==3).$_.qw|+ ** % / - *|[$i--%6].$F[$i]for@F

Wypróbuj online!

Pobiera dane wejściowe jako listę liczb oddzieloną spacjami.

R , 74 bajty

function(l)Map(Map,c(`+`, `*`, `-`, `%/%`, `%%`,`^`),l,rev(l))[1:sum(l|1)]

Wypróbuj online!

To jest ostatnia odpowiedź, na którą wpadłem. Zwraca listę długości, length(l)gdzie każdy element jest listą zawierającą odpowiedni element. Trochę kiepski, ale wszyscy tam są. Jeśli jest to niedopuszczalne, jeden z nich Mapmożna zastąpić mapplyznakiem +3 bajtów.

Ponieważ operatory R są wszystkimi funkcjami (notacja infiksowa jest po prostu cukrem syntaktycznym), próbowałem wybrać jedną z listy; na przykład 94 bajtowe rozwiązanie poniżej.

Aby spróbować pozbyć się pętli, próbowałem sapply, ale działa to tylko z jedną funkcją i listą wejść. Potem przypomniałem sobie formę wielowymiarową mapply, która przyjmuje n-aryfunkcję FUNi nkolejne argumenty, odnosząc FUNsię do pierwszego, drugiego ... elementów każdego z argumentów, w razie potrzeby poddając recyklingowi . Istnieje również funkcja otoki mapply,Map która „nie próbuje uprościć wyniku” . Ponieważ jest o trzy bajty krótszy, jest to dobra okazja do gry w golfa.

Zdefiniowałem więc funkcję trójrzędną (jak w poniższym 80-bajtowym rozwiązaniu), która bierze funkcję za swój pierwszy argument i stosuje ją do drugiej i trzeciej. Jednak zdałem sobie z tego sprawęMap jest to funkcja, która przyjmuje funkcję jako pierwszy argument i stosuje ją do kolejnych. Schludny!

Na koniec dokonujemy podzbioru na końcu, aby upewnić się, że zwracamy tylko pierwsze length(l)wartości.

R , 80 bajtów

function(l)Map(function(x,y,z)x(y,z),c(`+`, `*`, `-`, `%/%`, `%%`,`^`),l,rev(l))

Wypróbuj online!

Ten nie działa, ponieważ zwróci 6 wartości dla list zawierających mniej niż 6 elementów.

R , 94 bajty

function(l){for(i in 1:sum(l|1))T[i]=switch(i%%6+1,`^`,`+`,`*`,`-`,`%/%`,`%%`)(l,rev(l))[i]
T}

Wypróbuj online!

Objaśnienie (lekko nie golfa):

function(l){
 for(i in 1:length(l)){
  fun <- switch(i%%6+1,`^`,`+`,`*`,`-`,`%/%`,`%%`) # select a function
  res <- fun(l,rev(l))                             # apply to l and its reverse
  T[i] <- res[i]                                   # get the i'th thing in the result
 }
 T                                                 # return the values
}

Ponieważ każda z funkcji jest wektoryzowana, możemy indeksować na końcu ( res[i]). Jest to lepsze niż evalponiższe podejście.

R , 100 bajtów

function(l)eval(parse(t=paste("c(",paste(l,c("+","*","-","%/%","%%","^"),rev(l),collapse=","),")")))

Wypróbuj online!

To jest najkrótsze evalpodejście, jakie udało mi się znaleźć; ponieważ musimy zebrać wyniki w jeden wektor, musimy rozejrzeć pastesię c( )wokół wszystkich wyrażeń, co dodaje tonę niepotrzebnych bajtów

Casio-Basic, 108 bajtów

{x+y,x*y,x-y,int(x/y),x-int(x/y)y,x^y}⇒o
dim(l)⇒e
Print seq(o[i-int(i/6)6+1]|{x=l[i+1],y=l[e-i]},i,0,e-1)

To było bolesne. Zwłaszcza, że mod(x,y)powraca, xgdy tak naprawdę nie powinno, co oznaczało, że musiałem stworzyć własną funkcję mod: stąd x-int(x/y)y.

Pętle iod 0 do length(l)-1, biorąc kolejne elementy na oliście i ubiegając się l[i]o xi l[-i]dla y. (indeksy ujemne nie działają, więc zamiast tego odejmujęi od długości listy i biorę ten indeks).

107 bajtów dla funkcji, +1 bajt do dodania lw polu parametrów.

Java 8, 336 bajtów

import java.math.*;a->{int b[]=a.clone(),i=0,l=b.length,s,t;for(;i<l/2;b[i]=b[l+~i],b[l+~i++]=t)t=b[i];BigInteger r[]=new BigInteger[l],u,v;for(i=-1;++i<l;t=b[i],v=new BigInteger(t+""),r[i]=(s=i%6)<1?u.add(v):s<2?u.multiply(v):s<3?u.subtract(v):s<4?u.divide(v):s<5?u.remainder(v):t<0?u.ZERO:u.pow(t))u=new BigInteger(a[i]+"");return r;}

Wypróbuj tutaj.

Westchnienie.
Wejście jako int[], wyjście jako java.math.BigInteger[].

Bez reguły „ Aby uwzględnić przypadki narożne, dane wejściowe nigdy nie będą zawierać 0, ale mogą zawierać dowolną liczbę całkowitą z zakresu od ujemnej nieskończoności do dodatniej nieskończoności. ”, Przy użyciu liczb całkowitych z zakresu -2147483648do 2147483647, będzie to 186 bajtów (dane wejściowe as int[]i brak danych wyjściowych, ponieważ zamiast tego modyfikuje tablicę wejściową, aby zapisać bajty):

a->{int b[]=a.clone(),i=0,l=b.length,t,u,v;for(;i<l/2;b[i]=b[l+~i],b[l+~i++]=t)t=b[i];for(i=-1;++i<l;v=b[i],a[i]=(t=i%6)<1?u+v:t<2?u*v:t<3?u-v:t<4?u/v:t<5?u%v:(int)Math.pow(u,v))u=a[i];}

Wypróbuj tutaj.

Wyjaśnienie:

import java.math.*;            // Required import for BigInteger

a->{                           // Method with int[] parameter and BigInteger[] return-type
  int b[]=a.clone(),           //  Make a copy of the input-array
      i=0,                     //  Index-integer
      l=b.length,              //  Length of the input
      s,t;                     //  Temp integers
  for(;i<l/2;b[i]=b[l+~i],b[l+~i++]=t)t=b[i];
                               //  Reverse the input-array and store it in `b`
  BigInteger r[]=new BigInteger[l],
                               //  Result-array
             u,v;              //  Temp BigIntegers
  for(i=-1;                    //  Reset `i` to -1
      ++i<l;                   //  Loop over the array(s):
                               //    After every iteration:
      t=b[i],                  //     Set the current item of `b` in `t`
      v=new BigInteger(t+""),  //     And also set it in `v` as BigInteger
      r[i]=(s=i%6)<1?          //   If the index `i` modulo-6 is 0:
            u.add(v)           //    Add the items with each other
           :s<2?               //   Else-if index `i` modulo-6 is 1:
            u.multiply(v)      //    Multiply the items with each other
           :s<3?               //   Else-if index `i` modulo-6 is 2:
            u.subtract(v)      //    Subtract the items with each other
           :s<4?               //   Else-if index `i` modulo-6 is 3:
            u.divide(v)        //    Divide the items with each other
           :s<5?               //   Else-if index `i` modulo-6 is 4:
            u.remainder(v)     //    Use modulo for the items
           :                   //   Else (index `i` modulo-6 is 5):
            t<0?               //    If `t` is negative:
             u.ZERO            //     Simply use 0
            :                  //    Else:
             u.pow(t))         //     Use the power of the items
    u=new BigInteger(a[i]+""); //  Set the current item of `a` to `u` as BigInteger
                               //  End of loop (implicit / single-line body)
  return r;                    //  Return the result BigInteger-array
}                              // End of method