これに触発されて

リンクされたチャレンジでは、元の要素と入力配列の逆の要素に加算を適用するように求められます。この課題では、他の基本的な数学演算を導入することで、少し難しくします。

整数の配列が与えられた場合、を通過します+, *, -, //, %, ^。ここで、//は整数除算で、^指数です。配列の逆に適用します。または、言い換えると、上記の関数のいずれかを配列の各要素に適用します。2番目の引数は配列の逆で、適用される関数は上記のリストを循環します。これはまだわかりにくいかもしれませんので、例を見てみましょう。

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バイト（fork）

+×_:%*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バイト

ovsのおかげで-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バイト

@nwellnhofのおかげで1バイト節約されました。

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

オンラインでお試しください！

非常に想像力に欠ける（そしておそらく悪い）ソリューション。引数を逆順に圧縮します。結果のリストはEVAL、文字列であるブロックにマップされますa (operator) b。演算子は<+ * - div % **>、free state（staticCで考えてください-値はブロックの呼び出し間で持続します）変数を使用して、文字列のリストから選択されます$。これはブロックごとに個別に作成され、0に設定されます。好きなことを実行できますが、一度だけ参照できます（$実際に出現するたびに別の変数が参照されます）。したがって$++%6、実際には最初の呼び出しでは0、2番目の呼び出しでは1、6番目の呼び出しでは5、7番目の呼び出しでは0になります。

私は最初はなしでやろうとしましたEVAL。演算子は実際には単なるサブ（=関数）ですが、その名前は非常に手に負えない（&infix:<+>など）ので、そのアプローチを忘れなければなりませんでした。

ハスケル、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)]

オンラインでお試しください！

@nimiのおかげで12バイト節約

確かにこれを達成するより良い方法があります。

編集 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)]

オンラインでお試しください！

ovsのおかげで2バイト節約されました！

J、₄₄ 42バイト

44を消した、やだやだ...

@ ConorO'Brienのおかげで-2バイト

_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には整数除算がないため、%-floorで>.-division を構成します。Jのmod（|）は予想と逆の順序を~行うため、-reflexive を使用して順序を逆にする必要があります。

2の間隔で移動している場合/でも、動詞を挿入するために-insertを使用して、動詞を動的に使用する必要があります\。

ルビー、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バイト

@LuisMendoのおかげで-4バイト

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)各要素が対応する要素を含むリストである長さのリストを返します。ちょっと安っぽいですが、それらはすべてそこにあります。それが受け入れられない場合は、どちらかを+3バイトでMap置き換えることができmapplyます。

R演算子はすべて関数であるため（中置記法は単なる構文上の砂糖です）、リストから1つを選択しようとしました。たとえば、以下の94バイトのソリューション。

ループを取り除くために、私は試しましたがsapply、それは単一の関数と入力リストでのみ動作します。次にmapply、n-ary関数FUNとn後続の引数を取り、各引数FUNの最初、2番目、...の要素に適用し、必要に応じてリサイクルする多変量形式を思い出しました。ラッパー関数もありmapply、Mapという「結果を簡素化する試みません」。3バイト短いので、良いゴルフの機会です。

そこで、関数を最初の引数として取り、それを2番目と3番目の引数に適用する3次関数を定義しました（以下の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私が見つけることができる最短のアプローチです。結果を1つのベクトルに収集する必要があるため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ため、独自の mod関数を作成する必要がありましたx-int(x/y)y。

i0からまでループlength(l)-1し、oリスト内の連続する要素を取得し、l[i]for xおよびl[-i]for を適用しyます。（負のインデックスは機能しませんので、代わりにiリストの長さから減算してそのインデックスを取得します。）

関数用に107バイトl、パラメーターボックスに追加する+1バイト。

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バイト（入力as 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