[Question]
  [
*Inspired by [this](https://codegolf.stackexchange.com/questions/135417/reverse-array-sum)*
In the linked challenge, we are asked to apply addition to the elements of the original and the reverse of the input array. In this challenge, we are going to make it slightly more difficult, by introducing the other basic math operations.
Given an array of integers, cycle through `+, *, -, //, %, ^`, where `//` is integer division and `^` is exponent, while applying it to the reverse of the array. Or, in other words, apply one of the above functions to each element of an array, with the second argument being the reverse of the array, with the function applied cycling through the above list. This may still be confusing, so lets work through an example.
```
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]
```
so the output for `[1, 2, 3, 4, 5, 6, 7, 8, 9]` would be `[10, 16, -4, 0, 0, 1296, 10, 16, 8]`
To cover the corner cases, the input will never contain a 0, but may contain any other integer in the range from negative infinity to positive infinity. You may take input as a list of strings representing digits if you want.
## Test cases
```
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]
```
This is a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so shortest code (in bytes) wins!
  
[Answer]
# Jelly, 10 bytes ([fork](https://github.com/miles-cg/jelly/tree/tie))
```
+×_:%*6ƭ"Ṛ
```
I was just working on implementing a quick for this the other day, so it's quite surprising to see a use for it so soon. It still only exists as a fork, so you cannot try it online.
## Sample output
```
$ ./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]
```
## Explanation
```
+×_:%*6ƭ"Ṛ  Input: array
      6ƭ    Tie 6 dyads
+             Addition
 ×            Multiplication
  _           Subtraction
   :          Integer division
    %         Modulo
     *        Power
        "   Vectorize with
         Ṛ  Reverse
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), 16 bytes
~~This challenge favours languages that can create infinite lists of functions.~~ Maybe not, `eval` FTW
```
zF¢+ë+*-÷e%^Ṡze↔
```
[Try it online!](https://tio.run/##ATMAzP9odXNr//96RsKiK8OrKyotw7dlJV7huaB6ZeKGlP///1sxLDIsMyw0LDUsNiw3LDgsOV0 "Husk – Try It Online")
### How?
```
  ¢+ë+*-÷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      ]
```
Alternative 17 byte solution:
```
ṠozIzI¢+ë+*-÷e%^↔
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 18 bytes
```
Â"+*-÷%m"Ig×)øε`.V
```
[Try it online!](https://tio.run/##MzBNTDJM/f//cJOStpbu4e2quUqe6Yenax7ecW5rgl7Y///RhoY6CiY6CrqG5joKhqY6CkY6CsZmQDEQ0yIWAA "05AB1E – Try It Online")
**Explanation**
```
Â                    # 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
```
[Answer]
# Bash + GNU utilities, 53
```
tac $1|paste -d, $1 -|tr ',
' '
;'|paste -sd+*-/%^|bc
```
This script takes a filename as a command-line parameter.
[Try it online](https://tio.run/##Rck7CoQwFEbh/l/FLZSAekd8Owy4FCFGQRsJkytYZO/RRizPdybt1mC00EDbbg/5yClwixDzC0G0oajwVjtZiOfsDmIvf1IZFCn81PPcnCacx6OfTAgFSlSo0aBFhx5fXA).
The nice thing here is that `paste -d` allows a list of separators to be given, which are used cyclically. The rest it just getting the input into the right format to do this.
[Answer]
# [Python 2](https://docs.python.org/2/), 67 bytes
*-3 bytes thanks to ovs.*
```
lambda l:[eval(j+'*+*-/%*'[-~i%6::6]+l[~i])for i,j in enumerate(l)]
```
[Try it online!](https://tio.run/##RY/LDoIwEEX3/YrZmPKMaRXEJnxJ7QJjiSXlEagmbvh1ZNCUWZzFPO69M3zcs@/4Upe3xVbt/VGBFVK/Kxs0MY3iKD0eIirT2RxyIXIVWzkbFdb9CCZpwHSgu1erx8rpwIZqcXpyE5QgCawlKaMJUI44Ic6IDJEjLogCcaUq@Z9kfnvbYT/4MffNYm8y5tVTtqmybHfOmbfl6xFRhGwPYPwtsIBhNJ2DOjDh8gU "Python 2 – Try It Online")
## [Python 2](https://docs.python.org/2/), 95 bytes
```
lambda l:[[add,mul,sub,div,mod,pow][i%6](v,l[~i])for i,v in enumerate(l)]
from operator import*
```
[Try it online!](https://tio.run/##Fcq9CsIwGAXQ3ae4i9DKXaz/gk8SM6SkwUCSL8S04uKrR7oeTv7Wl6ShucezBRNHaxDuShlrGefA9zzS@oVRLLN8tPLbs@4WBvXzundS4LnAJ0xpjlMxdepCrzeuSITkFdYSs5S6a7n4VOE6tScG4kAciRNxJi7Elbjpvv0B "Python 2 – Try It Online")
`eval` is evil... but perhaps more golfy. :P
[Answer]
# [Haskell](https://www.haskell.org/), ~~74~~ ~~117~~ 105 bytes
```
x#y=fromIntegral.floor$x/y
x%y=x-x#y
f u=[o a b|(o,a,b)<-zip3(cycle[(+),(*),(-),(#),(%),(**)])u(reverse u)]
```
[Try it online!](https://tio.run/##VYtBDoIwEEXXcopJgKTFgkEUMZEDeAbSRdGixEJJAQPGu9fBHcm8ZOb9P0/Rv6RS1k7unFdGN9d2kA8jVFQprY037WZn8ud8CrHgVDDmhQYB5ZdoJlhJL@Gn7hJym29KFmRLGQmQEHERf7kDyulIjHxL00sYKbeNqFvI4a7B2XSmbgfwoIIijqIzX5kjg4RByiDGWUf7v8zWMkZ1YBDGJ0zxGUtJim5ZM25/ "Haskell – Try It Online")
*Saved 12 bytes thanks to @nimi*
There is certainly a better way to achieve this.
**EDIT** 1. Fixed exponent for integers; 2. There's definitely a better way, see comment below: ~~95~~ 91 bytes
```
x#y=fromIntegral.floor$x/y
x%y=x-x#y
f=zipWith3($)(cycle[(+),(*),(-),(#),(%),(**)])<*>reverse
```
[Try it online!](https://tio.run/##VYtBDoIwEEXXcopJgIRiwSCKmFj3nsCFYUGwlcZCSSGmePk6uCOZl8y8/6etxzdXyjnrz0wY3d36ib9MrVKhtDaB3c2eDWdmEyx4gn3lcJdTm0cBiZq5UfwRbQmNYiRBfCRc7phU5BJfDf9wM3LX1bIHBk8N3mYwsp8gAAGPLE3P1cocKeQUCgoZzjra/2W5lhmqA4UkO2GKz1jKC3TLWlbuBw "Haskell – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 15 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
żṚj"“+×_:%*”ṁ$V
```
**[Try it online!](https://tio.run/##AT4Awf9qZWxsef//xbzhuZpqIuKAnCvDl186JSrigJ3huYEkVv///1sxLCAyLCAzLCA0LCA1LCA2LCA3LCA4LCA5XQ "Jelly – Try It Online")** or see the [test-suite](https://tio.run/##y0rNyan8///onoc7Z2UpPWqYo314eryVqtajhrkPdzaqhAFlDrc/alpzdNLDnTOANBBlgaiGOQq2dgpAVZH//0dHG@ooGOkoGOsomOgomOoomOkomOsoWOgoWMbqcClEm4KlgIJAZYZgESMw2wLMNjQEa9M1BGoxNIUYZGYINsfIIjYWAA "Jelly – Try It Online").
### How?
```
żṚ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]
```
[Answer]
# JavaScript (ES7), ~~68~~ 67 bytes
```
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]
```
[Answer]
# [Perl 6](https://perl6.org), ~~67~~ 66 bytes
*Saved 1 byte thanks to @nwellnhof.*
```
{map {EVAL ".[0] {<+ * - div % **>[$++%6]} .[1]"},zip $_,.reverse}
```
[Try it online!](https://tio.run/##FcxNC4IwHAfgu5/ihyjo/G9kL1ZYQYedKj0EQQwJoQVCgmwklPjZF16fw9Np887cx2pcyuIk7/wqJS9KLm/Hc@61XwQv7N3Q1h2GyeALNasw7BIwcDybHiEYO6ggScKsGiFUWvkj/ZoOwYOE0b02Vo8u92w9bVGUEuaEBWFJWBEywpqwIWzjOHd/ "Perl 6 – Try It Online")
Very unimaginative (and probably bad) solution. Zips the argument with itself reversed. The resulting list is then mapped with the block that `EVAL`s the string `a (operator) b`. The operator is chosen from the list of strings `<+ * - div % **>` using the free `state` (think `static` in C — the value persists across the calls of the block) variable `$`. This is created for each block separately and set to 0. You can do anything you like with it, but you may reference it only once (each occurence of `$` refers to another variable, actually). So `$++%6` is actually 0 during the first call, 1 during the second, ... 5 during the 6th, 0 during the 7th and so on.
I at first tried to do without an `EVAL`. The operators are in fact just subs (= functions), but their names are so extremely ungolfy (`&infix:<+>` and so on) that I had to forgo that approach.
[Answer]
# [Desmos](https://desmos.com/calculator), ~~107~~ 104 bytes
```
k=l.length
L=mod([1...k],6)
R=l[k...1]
f(l)=\{L=1:l+R,L=2:lR,L=3:l-R,L=4:\floor(l/R),L=5:\mod(l,L),l^R\}
```
Very straightforward implementation of the challenge, can probably be golfed further.
[Try It On Desmos!](https://www.desmos.com/calculator/owt7vdmr2i)
[Try It On Desmos! - Prettified](https://www.desmos.com/calculator/mfgbvpqvcc)
[Answer]
# [Factor](https://factorcode.org/) + `sequences.repeating`, 69 bytes
```
[ dup reverse { + * - /i mod ^ } over length cycle [ execute ] 3map ]
```
[Try it online!](https://tio.run/##Rc27DoIwGEDhnac4s0aM4t0HMC4uxolo0tQfJJZSSzES4rOjcXE5yzecTOlQ@f503B92G@7irRhqeTRitdSUKtx@ibPG6lBUtv5r7MWJCoXNcV5CaJ0vbGAbRR0TpiTMmLNgyYo17z7l2ji8PMXXQseQASPGBWV15cKb6isYsfl3qltthBR5iW6CcCYplePca2UMcf8B "Factor – Try It Online")
## How?
```
                    ! { 1 2 3 4 5 6 7 8 9 }
dup                 ! { 1 2 3 4 5 6 7 8 9 } { 1 2 3 4 5 6 7 8 9 }
reverse             ! { 1 2 3 4 5 6 7 8 9 } { 9 8 7 6 5 4 3 2 1 }
{ + * - /i mod ^ }  ! { 1 2 3 4 5 6 7 8 9 } { 9 8 7 6 5 4 3 2 1 } { + * - /i mod ^ }
over                ! { 1 2 3 4 5 6 7 8 9 } { 9 8 7 6 5 4 3 2 1 } { + * - /i mod ^ } { 9 8 7 6 5 4 3 2 1 }
length              ! { 1 2 3 4 5 6 7 8 9 } { 9 8 7 6 5 4 3 2 1 } { + * - /i mod ^ } 9
cycle               ! { 1 2 3 4 5 6 7 8 9 } { 9 8 7 6 5 4 3 2 1 } { + * - /i mod ^ + * - }
[ execute ] 3map    ! { 10 16 -4 0 0 1296 10 16 8 }
```
[Answer]
# [Python 2](https://docs.python.org/2/), 71 bytes
```
lambda l:[eval(y+'+*-/%*'[x%6]*-~(x%6>4)+l[~x])for x,y in enumerate(l)]
```
[Try it online!](https://tio.run/##FcXdCoIwGADQV/kYiPtRIjPLoF5k7WLRRsKcMmZsN7766rs5Z83xs/iu2PuzOD2/3hrcTZqvdjSLWvD2UPFapmpQvN3p/0fPhJN7UswuAVKTYfJg/DaboKOhjqmyhslHaqkkR9IA6ZAT0iNnZEAuyBUZiWKs/AA "Python 2 – Try It Online")
Saved 2 bytes thanks to ovs!
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~63~~ 57 bytes
```
->a{t=0;a.map{|x|eval [x,a[t-=1]]*%w(** % / - * +)[t%6]}}
```
Nothing fancy, really. Just iterate on the array, use an index as reverse iterator, join into a string using the right operator, evaluate, rinse and repeat.
[Try it online!](https://tio.run/##NU5LCsIwFNz3FLMpaHxRXzWxIvUi4S0i2JVCkaiVtmePIaWzmy/zet9@sW2ivvohNPuL3z59N4z9eP/4B1xP3gXdsIgqvyulUGIHDYXN2oXSyjRFVyDBMaEiHAhHgiFYwolQE85Cc8BkN@kpyYtYZVovlDn3Nacum3nRch6sailkPhfGDq0LMsU/ "Ruby – Try It Online")
[Answer]
# [k](https://en.wikipedia.org/wiki/K_(programming_language)), 40 bytes
```
{_((#x)#(+;*;-;%;{y!x};{*/y#x})).'x,'|x}
```
[Try it online!](https://tio.run/##FYpBDoMgFAWv8hpiAJU2nwpi/2G6Y8Oi22@Qs1PcTDKZKe5Xes@f@jVGiVVm4ZkdT1zPhzSu8@tU0qx9aln1Ja1nbQgeb2wIiNiRcHAYHkEg9oOJiUZ2tIPC/UYar0@2/wE "K (oK) – Try It 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
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~27~~ 23 bytes
-4 bytes thanks to @LuisMendo
```
tP+1M*1M-IM&\w1M^v"@X@)
```
[Try it online!](https://tio.run/##y00syfn/vyRA29BXy9BX19NXLabc0DeuTMkhwkHz//9oQ0MdBRMdBV1Dcx0FQ1MdBSMdBWMzoBiIaRELAA "MATL – Try It Online")
### Explanation:
```
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
```
[Answer]
# J, ~~44~~ 42 bytes
Crossed out 44, yada yada...
-2 bytes thanks to @ConorO'Brien
```
_2+/`(*/)`(-/)`(<.@%/)`(|~/)`(^/)\[:,],.|.
```
[Try it online!](https://tio.run/##y/r/P03BVk8h3khbP0FDS18zQUMXRNjoOaiC6Jo6EBmnrxkTbaUTq6NXo8eVmpyRr5CmYGelkKlnCeMZGuoomOgoxBua6ygYmuooGOkoGJsBxUBMi///AQ)
So many parens and inserts... Surely there's a better way to do this (maybe using insert rather than infix?)
# Explanation
```
_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 multiplication
             -/                                 Insert subtraction
                  <.@%/                         Insert integer division
                          |~/                   Insert mod
                                ^/              Insert exponentiation
```
Some notes:
J doesn't have integer division, so we compose `%`-division with `>.`-floor. J's mod (`|`) does the reverse order of what we'd expect, so we have to invert its order using `~`-reflexive.
Even though we're moving over intervals of 2, we have to use `/`-insert to insert the verbs to have them be used dyadically since that's how `\`-infix works.
[Answer]
# [Perl 5](https://www.perl.org/), 68 + 1 (-p) = 69 bytes
```
print$",eval'int 'x($i%6==3).$_.qw|+ ** % / - *|[$i--%6].$F[$i]for@F
```
[Try it online!](https://tio.run/##DcZBCsIwEAXQq3wkoRqd2LE2uim46s4TSJEuKgRKE2NRFz27Y1bvxSGNtUhMfprVaje8@7HIRfFdK69d01Qbq@72@Vm2MAYaexDMclOeSLvOqja3e4R0aUWYcQTxCVzjgMoxsudfiLMP00voWtuSS6H@Dw "Perl 5 – Try It Online")
Takes input as space separated list of numbers.
[Answer]
# [R](https://www.r-project.org/), 74 bytes
```
function(l)Map(Map,c(`+`, `*`, `-`, `%/%`, `%%`,`^`),l,rev(l))[1:sum(l|1)]
```
[Try it online!](https://tio.run/##K/qfpmCj@z@tNC@5JDM/TyNH0zexQAOIdZI1ErQTdBQStECELohQ1VcFU0AyIS5BUydHpyi1DKhDM9rQqrg0VyOnxlAz9n@aRrKGkY6hjoWm5n8A "R – Try It Online")
This is the final answer I came up with. It returns a list of length `length(l)` where each element is a list containing the corresponding element. Kinda crappy but they're all there. If that's unacceptable, either of the `Map` can be replaced with `mapply` for +3 bytes.
Since R operators are all functions (the infix notation just being syntactic sugar), I tried to select one from a list; for example, the 94 byte solution below.
To try and get rid of the loop, I tried `sapply`, but that only works with a single function and input list. Then I remembered the multivariate form, `mapply`, which takes an `n-ary` function `FUN` and `n` succeeding arguments, applying `FUN` to the first, second, ..., elements of each of the arguments, *recycling if necessary*. There is also a wrapper function to `mapply`, `Map` that ["makes no attempt to simplify the result"](https://stat.ethz.ch/R-manual/R-devel/library/base/html/funprog.html). Since it's three bytes shorter, it's a good golfing opportunity.
So I defined a trinary function (as in the 80 byte solution below) that takes a function as its first argument, and applies it to its second and third ones. However, I realized that `Map` is a function that takes a function as its first argument and applies it to successive ones. Neat!
Finally, we subset at the end to ensure we only return the first `length(l)` values.
# [R](https://www.r-project.org/), 80 bytes
```
function(l)Map(function(x,y,z)x(y,z),c(`+`, `*`, `-`, `%/%`, `%%`,`^`),l,rev(l))
```
[Try it online!](https://tio.run/##K/qfpmCj@z@tNC@5JDM/TyNH0zexQAPOrdCp1KnSrNAAkTrJGgnaCToKCVogQhdEqOqrgikgmRCXoKmTo1OUWgY0Q/N/moahlaXmfwA "R – Try It Online")
This one doesn't work, as it will return 6 values for lists with less than 6 elements.
# [R](https://www.r-project.org/), 94 bytes
```
function(l){for(i in 1:sum(l|1))T[i]=switch(i%%6+1,`^`,`+`,`*`,`-`,`%/%`,`%%`)(l,rev(l))[i]
T}
```
[Try it online!](https://tio.run/##K/qfpmCj@z@tNC@5JDM/TyNHszotv0gjUyEzT8HQqrg0VyOnxlBTMyQ6M9a2uDyzJDlDI1NV1UzbUCchLkEnQRuItYBYF4hV9VVBpGqCpkaOTlFqGdAsTaA2rpDa/2kahlaWmv8B "R – Try It Online")
Explanation (mildly ungolfed):
```
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
}
```
Because each of the functions is vectorized, we can index at the end (`res[i]`). This is better than the `eval` approach below.
## [R](https://www.r-project.org/), 100 bytes
```
function(l)eval(parse(t=paste("c(",paste(l,c("+","*","-","%/%","%%","^"),rev(l),collapse=","),")")))
```
[Try it online!](https://tio.run/##JYxBCoAwDAS/IgEh0Yh4VPQrQikpCEFLW/1@jQg7y7CHTTU069DUcJ@@HNeJSvI4xehSFixbdLkIgkfgX5XNe2DojMFox/brr3YgTvLYB/tL1cUsm81kASKqAadlpvoC "R – Try It Online")
This is the shortest `eval` approach I could find; because we have to collect the results into one vector, we need to `paste` a `c( )` around all the expressions, which adds a ton of unnecessary bytes
[Answer]
# Casio-Basic, 108 bytes
```
{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)
```
That was painful. Especially because `mod(x,y)` returns `x` when it really shouldn't, which meant I had to make my *own* mod function: hence the `x-int(x/y)y`.
Loops `i` from 0 to `length(l)-1`, taking successive elements in the `o` list and applying `l[i]` for `x` and `l[-i]` for `y`. (negative indices don't work though, so instead I subtract `i` from the length of the list and take that index.)
107 bytes for the function, +1 byte to add `l` in the parameters box.
[Answer]
# Java 8, ~~336~~ 332 bytes
```
import java.math.*;a->{int b[]=a.clone(),l=b.length,i=l/2,s,t;for(;i-->0;b[i]=b[l+~i],b[l+~i]=t)t=b[i];BigInteger r[]=new BigInteger[l],u,v;for(;++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;}
```
-4 bytes thanks to *@ceilingcat*.
[Try it here.](https://tio.run/##rVFNb9swDL37VxAFBkiLrNRpk3V13GEDdtgh2LDeFvgg20qiTP6ATLkIAu@vZ7RdbEOv64ngI/n4@HhUnQrrRlfH4ufFlE3tEI6EyVLhQb6NAWA@h2@K4HoHeNCQnVCHee0rDILcqraFjTLVGSAAMBVqt1O5hs2ZUoBPZv@FsL122xRyRnWKisdU7INxpEWFJocNlJDARYUPZ2qCbJsmSua2rjTjwiaZtLra40GYxM4XohUY72rHYhOGD9dxtjVpkm3t7JdJxXNMkGMyFOK/GoBUJJV@@leWTYUX3cQ2m5m1jacx0b3oZDi7uuLCDbtYm5g3K76OPnipioJ1/L5dLygpvUXT2NOE3BDS@gydynFCbgkpTGcKPeVLyp0uycCCNhCE62uCfnz@/vXey6Z@Ysi5f6lEkYZBTOw0eleBi/tLHJCZjc8smfnsaVebAgZu9ojOVPvR@ukvj6cWdSlrj7KhEtqKjV/3aKz86Jw6tRLraYyVMmeDgvF750jAQsCNgFsBSwErAe8E3Al433M@Pva/2JcjNZHSmuhVGBcj192rcEXReHYY0cnRcjJiFY0@LP5s6IP@8hs)
Sigh..  
Input as `int[]`, output as `java.math.BigInteger[]`.
Without the rule "*To cover the corner cases, the input will never contain a 0, but may contain any other integer in the range from negative infinity to positive infinity.*", using integers in the range `-2147483648` to `2147483647`, it would be **~~186~~ 182 bytes** instead (input as `int[]`, and no output because it modifies this input-array instead to save bytes):
```
a->{int b[]=a.clone(),l=b.length,i=l/2,t,u,v;for(;i-->0;b[i]=b[l+~i],b[l+~i]=t)t=b[i];for(;++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];}
```
[Try it here.](https://tio.run/##vVG7bsIwFN35irtUSopjmvAoJZio6gwLI2JwggFT46DkOgih9NepnVB16VqWHOX4Xp@HD7ziQX4S@rD5vGWKlyXMudTXDoDUKIotzwQs3C9AlcsNZJ7lV2vgfmzJumM/JXKUGSxAA4MbD2ZXOwLpas04zVSuhecTxVKqhN7hnkimehFBYkgVb/PCi2UQzF7idCXXLF2p7pdckzsy9JG5g3aw25VTFVcNQ7ib95DJp5E/DRPTrSY4jRLz7LCfmMDhIDE9h8PEPFUTZ92fc9zTU372rL7vG@buietb7JKcTKpsknugJu/RtuEtsZB616Ruq2g7QFHiBy@Fja3FuSWvIYGIQJ/AgMCQwIjAK4Exgbc6blY1zbyfRb@llpcSxZHmBunJCqHS3sG@CzUoFX0vCn4pKeatid/d@/KfJoaNA6tt3YSPFI4ayfEjJcOw6ToIbc/hsG1/FDblR/9jpO7Ut28)
**Explanation:**
```
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
      l=b.length,              //  Length of the input
      i=l/2,                   //  Index-integer, starting at halve the length
      s,t;                     //  Temp integers
  for(;i-->0;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<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
  return r;}                   //  After the loop, return the result BigInteger-array
```
]