Натхненний цим

У пов'язаному виклику нас просять застосувати доповнення до елементів оригіналу та реверсу вхідного масиву. У цьому виклику ми збираємось зробити це трохи складніше, ввівши інші основні математичні операції.

Задавши масив цілих чисел, проведіть цикл +, *, -, //, %, ^, де //є ціле ділення і ^є експонентом, застосовуючи його до зворотного боку масиву. Або, інакше кажучи, застосувати одну з перерахованих вище функцій до кожного елемента масиву, при цьому другий аргумент є зворотною стороною масиву, при цьому функція застосовується перемиканням по вищевказаному списку. Це все ще може заплутати, тому давайте працювати на прикладі.

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]

тому вихід для [1, 2, 3, 4, 5, 6, 7, 8, 9]буде[10, 16, -4, 0, 0, 1296, 10, 16, 8]

Для покриття кутових випадків вхід ніколи не буде містити 0, але може містити будь-яке інше ціле число в діапазоні від негативної нескінченності до позитивної нескінченності. Ви можете взяти введення як список рядків, що представляють цифри, якщо ви хочете.

Тестові справи

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]

Це кодовий гольф, тому найкоротший код (у байтах) виграє!

Желе, 10 байт ( виделка )

+×_:%*6ƭ"Ṛ

Я щойно працював над тим, щоб швидко реалізувати це для цього дня, тому досить дивно побачити використання для нього так скоро. Він все ще існує лише як виделка, тому ви не можете спробувати його в Інтернеті.

Вибірка зразка

$ ./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]

Пояснення

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

Лушпиння , 16 байт

Цей виклик сприяє мовам, які можуть створювати нескінченний перелік функцій. Можливо, ні, evalFTW

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

Спробуйте в Інтернеті!

Як?

  ¢+ë+*-÷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      ]

Альтернативне 17-байтне рішення:

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

05AB1E , 18 байт

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

Спробуйте в Інтернеті!

Пояснення

                    # 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

Утиліти Bash + GNU, 53

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

Цей скрипт приймає ім'я файлу як параметр командного рядка.

Спробуйте в Інтернеті .

Приємним є те, що paste -dдозволяє надати список роздільників, які використовуються циклічно. Решта - це просто отримання вводу в потрібному форматі для цього.

Желе , 15 байт

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

Спробуйте в Інтернеті! або побачити набір тестів .

Як?

żṚ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 байт

-3 байти завдяки ов.

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

Спробуйте в Інтернеті!

Python 2 , 95 байт

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

Спробуйте в Інтернеті!

evalє злом ... але, можливо, більш гофрованим. : P

JavaScript (ES7), 68 67 байт

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 байт

Збережено 1 байт завдяки @nwellnhof.

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

Спробуйте в Інтернеті!

Дуже немислене (і, мабуть, погане) рішення. Сперечає аргумент із самим собою зворотним. Потім отриманий список відображається з блоком, що містить EVALрядок a (operator) b. Оператор вибирається зі списку рядків <+ * - div % **>за допомогою змінної free state(подумайте staticна C - значення зберігається в межах викликів блоку) $. Це створюється для кожного блоку окремо і встановлюється 0. Ви можете робити все, що завгодно, з ним, але ви можете посилатися на нього лише один раз (кожне виникнення посилань $на іншу змінну, власне). Тож $++%6насправді 0 під час першого дзвінка, 1 під час другого, ... 5 під час 6-го, 0 під час 7-го тощо.

Я спершу намагався обійтися без EVAL. Оператори насправді є лише subs (= функціями), але їхні назви настільки надзвичайно незрозумілі ( &infix:<+>і так далі), що мені довелося відмовитися від такого підходу.

Haskell , 74 117 105 байт

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

Спробуйте в Інтернеті!

Збережено 12 байт завдяки @nimi

Звичайно, є кращий спосіб досягти цього.

EDIT 1. Фіксований показник для цілих чисел; 2. Однозначно є кращий спосіб, дивіться коментар нижче: 95 91 байт

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

Спробуйте в Інтернеті!

Python 2 , 71 байт

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

Спробуйте в Інтернеті!

Збережено 2 байти завдяки ovs!

J, ₄₄ 42 байти

Закреслено 44, яда яда ...

-2 байти завдяки @ ConorO'Brien

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

Спробуйте в Інтернеті!

Стільки паронів і вставок ... Звичайно, є кращий спосіб зробити це (можливо, використовуючи вставку, а не інфікс?)

Пояснення

_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

Деякі примітки:

J не має цілого поділу, тому ми складаємо %-ділення з >.-поверху. J's mod ( |) робить зворотний порядок того, що ми очікували, тому нам доведеться інвертувати його порядок за допомогою ~-reflexive.

Незважаючи на те, що ми рухаємось через інтервали у 2, ми повинні використовувати /-insert для вставки дієслів, щоб вони використовувались діадично, оскільки так \працює -infix.

Рубі , 63 57 байт

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

Нічого фантазійного, насправді. Просто повторіть масив, використовуйте індекс як зворотний ітератор, приєднайтесь до рядка за допомогою правого оператора, оцініть, промийте та повторіть.

Спробуйте в Інтернеті!

k , 40 байт

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

Спробуйте в Інтернеті!

{                                      } /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 байти

-4 байти завдяки @LuisMendo

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

Спробуйте в Інтернеті!

Пояснення:

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 байт

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

Спробуйте в Інтернеті!

Приймає введення як розділений пробілом список номерів.

R , 74 байти

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

Спробуйте в Інтернеті!

Це остаточна відповідь, яку я придумав. Він повертає список довжини, length(l)де кожен елемент є списком, що містить відповідний елемент. Якимось дурними, але вони всі там. Якщо це неприйнятно, будь-який із них Mapможна замінити mapplyна +3 байт.

Оскільки оператори R - це всі функції (нотатка інфікування є лише синтаксичним цукром), я спробував вибрати її зі списку; наприклад, рішення на байті 94 нижче.

Щоб спробувати позбутися циклу, я спробував sapply, але це працює лише з однією функцією та списком введення. Тоді я згадав багатоваріантну форму, mapplyяка приймає n-aryфункцію FUNі nвпорядковуючи аргументи, застосовуючи FUNдо першого, другого, ..., елементів кожного з аргументів, переробляючи при необхідності . Існує також функція обгортки дляmapply , Mapяка "не робить спроб спростити результат" . Оскільки на три байти коротше, це гарна можливість для гольфу.

Тому я визначив тринарну функцію (як у 80-байтному рішенні нижче), яка приймає функцію як перший аргумент і застосовує її до другого та третього. Однак я зрозумів, що Mapце функція, яка приймає функцію як перший аргумент і застосовує її до послідовних. Акуратно!

Нарешті, ми підмножимо в кінці, щоб переконатися, що ми повернемо лише перше length(l) значення.

R , 80 байт

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

Спробуйте в Інтернеті!

Цей не працює, оскільки поверне 6 значень для списків, що містять менше 6 елементів.

R , 94 байти

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

Спробуйте в Інтернеті!

Пояснення (м'яко невольф):

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
}

Оскільки кожна з функцій векторизована, ми можемо проіндексувати в кінці ( res[i]). Це краще, ніж evalпідхід нижче.

R , 100 байт

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

Спробуйте в Інтернеті!

Це найкоротший evalпідхід, який я міг знайти; тому що ми повинні зібрати результати в один вектор, нам потрібно pasteчерез c( )навколо всіх виразів, який додає масу непотрібних байтів

Casio-Basic, 108 байт

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

Це було боляче. Тим більше, що mod(x,y)повертається, xколи це насправді не повинно, а це означає, що я повинен був зробити власну функцію мода: отжеx-int(x/y)y .

Цикли iвід 0 до length(l)-1, беручи послідовні елементи у oсписку та подаючи заявки l[i]на xта l[-i]для y. (від'ємні показники не працюють, тому я замінюю iдовжину списку і беру цей індекс.)

107 байт для функції, +1 байт для додавання lу поле параметрів.

Java 8, 336 байт

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

Спробуйте тут.

Зіх ..
Введення як int[], вихід як java.math.BigInteger[].

Без правила " Для покриття кутових випадків вхід ніколи не буде містити 0, але може містити будь-яке інше ціле число в діапазоні від негативної нескінченності до позитивної нескінченності ", використовуючи цілі числа в діапазоні -2147483648до 2147483647, це буде 186 байт (вхід як int[]і немає виводу, оскільки замість цього він змінює цей масив вводу для збереження байтів):

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

Спробуйте тут.

Пояснення:

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