Terinspirasi oleh ini

Dalam tantangan yang ditautkan, kami diminta untuk menerapkan tambahan pada elemen asli dan kebalikan dari array input. Dalam tantangan ini, kita akan membuatnya sedikit lebih sulit, dengan memperkenalkan operasi matematika dasar lainnya.

Diberikan array bilangan bulat, siklus melalui +, *, -, //, %, ^, di mana //divisi bilangan bulat dan ^eksponen, sambil menerapkannya ke kebalikan dari array. Atau, dengan kata lain, terapkan salah satu fungsi di atas untuk setiap elemen array, dengan argumen kedua adalah kebalikan dari array, dengan fungsi yang diterapkan bersepeda melalui daftar di atas. Ini mungkin masih membingungkan, jadi mari kita bekerja melalui contoh.

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]

jadi output untuk [1, 2, 3, 4, 5, 6, 7, 8, 9]menjadi[10, 16, -4, 0, 0, 1296, 10, 16, 8]

Untuk menutup kasus sudut, input tidak akan pernah berisi 0, tetapi dapat berisi bilangan bulat lain dalam kisaran dari infinity negatif hingga infinity positif. Anda dapat mengambil input sebagai daftar string yang mewakili digit jika Anda mau.

Uji kasus

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]

Ini adalah kode-golf sehingga kode terpendek (dalam byte) menang!

Jelly, 10 byte ( garpu )

+×_:%*6ƭ"Ṛ

Saya baru saja mengerjakan implementasi quick untuk ini beberapa hari yang lalu, jadi cukup mengejutkan melihat penggunaannya begitu cepat. Itu masih hanya ada sebagai garpu, jadi Anda tidak dapat mencobanya online.

Output sampel

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

Penjelasan

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

Sekam , 16 byte

Tantangan ini mendukung bahasa yang dapat membuat daftar fungsi yang tak terbatas. Mungkin tidak, evalFTW

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

Cobalah online!

Bagaimana?

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

Alternatif solusi 17 byte:

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

05AB1E , 18 byte

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

Cobalah online!

Penjelasan

                    # 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

Utilitas Bash + GNU, 53

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

Script ini menggunakan nama file sebagai parameter baris perintah.

Cobalah online .

Yang menyenangkan di sini adalah paste -dmemungkinkan daftar pemisah untuk diberikan, yang digunakan secara siklis. Sisanya hanya mendapatkan input ke format yang tepat untuk melakukan ini.

Jelly , 15 byte

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

Cobalah online! atau lihat test-suite .

Bagaimana?

żṚ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 byte

-3 bytes terima kasih kepada ovs.

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

Cobalah online!

Python 2 , 95 byte

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

Cobalah online!

evalitu jahat ... tapi mungkin lebih golf. : P

JavaScript (ES7), 68 67 byte

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 byte

Disimpan 1 byte berkat @nwellnhof.

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

Cobalah online!

Solusi yang sangat tidak imajinatif (dan mungkin buruk). Ritsleting argumen dengan dirinya sendiri terbalik. Daftar yang dihasilkan kemudian dipetakan dengan blok yang EVALmerupakan string a (operator) b. Operator dipilih dari daftar string <+ * - div % **>menggunakan variabel bebas state(pikirkan staticdalam C - nilainya tetap di seluruh panggilan blok)$ . Ini dibuat untuk setiap blok secara terpisah dan diatur ke 0. Anda dapat melakukan apa pun yang Anda suka dengannya, tetapi Anda dapat $merujuknya hanya sekali (masing-masing kejadian merujuk ke variabel lain, sebenarnya). Jadi $++%6sebenarnya 0 selama panggilan pertama, 1 selama yang kedua, ... 5 selama 6, 0 selama 7 dan seterusnya.

Saya awalnya mencoba melakukannya tanpa EVAL. Para operator sebenarnya hanya subs (= fungsi), tetapi nama mereka sangat ungolfy ( &infix:<+>dan sebagainya) sehingga saya harus melupakan pendekatan itu.

Haskell , 74 117 105 byte

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

Cobalah online!

Disimpan 12 byte berkat @nimi

Tentunya ada cara yang lebih baik untuk mencapai ini.

EDIT 1. Eksponen tetap untuk bilangan bulat; 2. Pasti ada cara yang lebih baik, lihat komentar di bawah: 95 91 byte

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

Cobalah online!

Python 2 , 71 byte

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

Cobalah online!

Disimpan 2 byte berkat ovs!

J, ₄₄ 42 byte

Dicoret 44, yada yada ...

-2 byte terima kasih kepada @ ConorO'Brien

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

Cobalah online!

Begitu banyak paren dan sisipan ... Tentunya ada cara yang lebih baik untuk melakukan ini (mungkin menggunakan insert daripada infix?)

Penjelasan

_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

Beberapa catatan:

J tidak memiliki divisi integer, jadi kami menulis %-divisi dengan >.-floor. Mod J ( |) melakukan urutan terbalik dari apa yang kita harapkan, jadi kita harus membalikkan urutannya menggunakan ~-reflexive.

Meskipun kita bergerak dengan interval 2, kita harus menggunakan /-insert untuk memasukkan kata kerja agar bisa digunakan secara dua arah karena itulah cara \-infiks bekerja.

Ruby , 63 57 byte

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

Tidak ada yang mewah, sungguh. Lakukan iterate pada array, gunakan indeks sebagai reverse iterator, gabung ke string menggunakan operator yang tepat, evaluasi, bilas dan ulangi.

Cobalah online!

k , 40 byte

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

Cobalah 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 byte

-4 byte terima kasih kepada @LuisMendo

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

Cobalah online!

Penjelasan:

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 byte

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

Cobalah online!

Mengambil input sebagai daftar angka yang dipisahkan ruang.

R , 74 byte

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

Cobalah online!

Ini adalah jawaban terakhir yang saya temukan. Ini mengembalikan daftar panjanglength(l) mana setiap elemen adalah daftar yang mengandung elemen yang sesuai. Agak jelek tapi mereka semua ada di sana. Jika itu tidak dapat diterima, salah satu dari itu Mapdapat diganti dengan mapplysebesar +3 byte.

Karena operator R adalah semua fungsi (notasi infiks hanya menjadi gula sintaksis), saya mencoba untuk memilih satu dari daftar; misalnya, solusi 94 byte di bawah ini.

Untuk mencoba dan menghilangkan loop, saya mencoba sapply, tetapi itu hanya berfungsi dengan satu fungsi dan daftar input. Lalu saya ingat bentuk multivariat mapply,, yang n-aryberfungsi FUNdan nargumen yang berhasil, berlaku FUNuntuk elemen pertama, kedua, ..., dari setiap argumen, daur ulang jika perlu . Ada juga fungsi pembungkus untuk mapply,Map yang "tidak berusaha menyederhanakan hasil" . Karena pendeknya tiga byte, ini adalah peluang golf yang bagus.

Jadi saya mendefinisikan fungsi trinary (seperti pada solusi 80 byte di bawah) yang mengambil fungsi sebagai argumen pertama, dan menerapkannya pada yang kedua dan ketiga. Namun, saya menyadarinyaMap adalah fungsi yang mengambil fungsi sebagai argumen pertama dan menerapkannya pada yang berurutan. Rapi!

Akhirnya, kami bagian di akhir untuk memastikan kami hanya mengembalikan yang pertama length(l) .

R , 80 byte

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

Cobalah online!

Yang ini tidak berfungsi, karena akan mengembalikan 6 nilai untuk daftar dengan kurang dari 6 elemen.

R , 94 byte

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

Cobalah online!

Penjelasan (agak tidak diserap):

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
}

Karena masing-masing fungsi adalah vektor, kita dapat mengindeks di akhir ( res[i]). Ini lebih baik daripada evalpendekatan di bawah ini.

R , 100 byte

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

Cobalah online!

Ini adalah evalpendekatan terpendek yang bisa saya temukan; karena kita harus mengumpulkan hasil menjadi satu vektor, kita perlu pastesebuah c( )sekitar semua ekspresi, yang menambahkan satu ton byte yang tidak perlu

Casio-Basic, 108 byte

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

Itu menyakitkan. Terutama karena mod(x,y)kembali xketika sebenarnya tidak seharusnya, yang berarti saya harus membuat fungsi mod saya sendiri : karenanyax-int(x/y)y .

Loop idari 0 hingga length(l)-1, mengambil elemen berurutan dalam odaftar dan melamar l[i]untuk xdan l[-i]untuk y. (Indeks negatif tidak berfungsi, jadi saya kurangii dari panjang daftar dan mengambil indeks itu.)

107 byte untuk fungsi, +1 byte untuk ditambahkan ldi kotak parameter.

Java 8, 336 byte

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

Coba di sini.

Huh ..
Masukan sebagaiint[] , output asjava.math.BigInteger[] .

Tanpa aturan " Untuk menutupi kasus sudut, input tidak akan berisi 0, tetapi mungkin mengandung bilangan bulat lainnya dalam kisaran dari infinity negatif ke positif tak terhingga. ", Menggunakan bilangan bulat dalam kisaran -2147483648untuk 2147483647, itu akan menjadi 186 byte (input sebagai int[], dan tidak ada output karena ia memodifikasi input-array ini untuk menghemat byte):

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

Coba di sini.

Penjelasan:

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