Lấy cảm hứng từ điều này

Trong thử thách được liên kết, chúng tôi được yêu cầu áp dụng bổ sung cho các yếu tố của bản gốc và đảo ngược của mảng đầu vào. Trong thử thách này, chúng tôi sẽ làm cho nó khó khăn hơn một chút, bằng cách giới thiệu các hoạt động toán học cơ bản khác.

Cho một mảng các số nguyên, chu kỳ xuyên qua +, *, -, //, %, ^, trong đó //phân chia số nguyên và ^là số mũ, trong khi áp dụng nó cho đảo ngược của mảng. Hay nói cách khác, áp dụng một trong các hàm trên cho từng phần tử của mảng, với đối số thứ hai là đảo ngược của mảng, với hàm được áp dụng theo chu kỳ thông qua danh sách trên. Điều này có thể vẫn còn gây nhầm lẫn, vì vậy hãy làm việc qua một ví dụ.

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]

nên đầu ra cho [1, 2, 3, 4, 5, 6, 7, 8, 9]sẽ là[10, 16, -4, 0, 0, 1296, 10, 16, 8]

Để bao quát các trường hợp góc, đầu vào sẽ không bao giờ chứa 0, nhưng có thể chứa bất kỳ số nguyên nào khác trong phạm vi từ vô cực âm đến vô cực dương. Bạn có thể lấy đầu vào làm danh sách các chuỗi biểu thị các chữ số nếu bạn muốn.

Các trường hợp thử nghiệm

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]

Đây là một mã golf để mã ngắn nhất (tính bằng byte) thắng!

Jelly, 10 byte ( ngã ba )

+×_:%*6ƭ"Ṛ

Tôi vừa mới thực hiện một cách nhanh chóng cho việc này vào một ngày khác, vì vậy thật đáng ngạc nhiên khi thấy việc sử dụng nó sớm như vậy. Nó vẫn chỉ tồn tại như một ngã ba, vì vậy bạn không thể thử trực tuyến.

Sản lượng mẫu

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

Giải trình

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

Husk , 16 byte

Thách thức này ủng hộ các ngôn ngữ có thể tạo danh sách chức năng vô hạn. Có lẽ không, evalFTW

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

Hãy thử trực tuyến!

Làm sao?

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

Giải pháp thay thế 17 byte:

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

05AB1E , 18 byte

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

Hãy thử trực tuyến!

Giải trình

                    # 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

Tiện ích Bash + GNU, 53

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

Kịch bản lệnh này lấy tên tệp làm tham số dòng lệnh.

Hãy thử trực tuyến .

Điều tốt đẹp ở đây là paste -dcho phép một danh sách các dải phân cách được đưa ra, được sử dụng theo chu kỳ. Phần còn lại nó chỉ nhận đầu vào đúng định dạng để làm điều này.

Thạch , 15 byte

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

Hãy thử trực tuyến! hoặc xem bộ thử nghiệm .

Làm sao?

żṚ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 byte nhờ vào các lò nướng.

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

Hãy thử trực tuyến!

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*

Hãy thử trực tuyến!

evallà xấu xa ... nhưng có lẽ nhiều golf hơn. : 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

Đã lưu 1 byte nhờ @nwellnhof.

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

Hãy thử trực tuyến!

Giải pháp rất không tưởng tượng (và có thể là xấu). Zips đối số với chính nó đảo ngược. Danh sách kết quả sau đó được ánh xạ với khối đó EVALlà chuỗi a (operator) b. Toán tử được chọn từ danh sách các chuỗi <+ * - div % **>sử dụng biến miễn phí state(nghĩ statictheo C - giá trị vẫn tồn tại trong các cuộc gọi của khối) $. Điều này được tạo riêng cho từng khối và được đặt thành 0. Bạn có thể làm bất cứ điều gì bạn thích với nó, nhưng bạn chỉ có thể tham chiếu nó một lần (thực tế mỗi lần tham chiếu $đến một biến khác). Vì vậy, $++%6thực sự là 0 trong cuộc gọi đầu tiên, 1 trong lần thứ hai, ... 5 trong lần thứ 6, 0 trong lần thứ 7, v.v.

Lúc đầu tôi đã cố gắng làm mà không có EVAL. Các toán tử trên thực tế chỉ là subs (= hàm), nhưng tên của chúng cực kỳ vô nghĩa ( &infix:<+>vân vân) đến nỗi tôi phải từ bỏ cách tiếp cận đó.

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

Hãy thử trực tuyến!

Đã lưu 12 byte nhờ @nimi

Chắc chắn có một cách tốt hơn để đạt được điều này.

EDIT 1. Đã sửa số mũ cho số nguyên; 2. Chắc chắn có một cách tốt hơn, xem bình luận bên dưới: 95 91 byte

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

Hãy thử trực tuyến!

Python 2 , 71 byte

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

Hãy thử trực tuyến!

Đã lưu 2 byte nhờ vào ovs!

J, ₄₄ 42 byte

Vượt qua 44, yada yada ...

-2 byte nhờ @ ConorO'Brien

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

Hãy thử trực tuyến!

Vì vậy, nhiều parens và chèn ... Chắc chắn có cách nào tốt hơn để làm điều này (có thể sử dụng insert chứ không phải infix?)

Giải trình

_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

Một số lưu ý:

J không có phân chia số nguyên, vì vậy chúng tôi soạn thảo phân chia %với >.-floor. J 'mod ( |) thực hiện thứ tự ngược lại với những gì chúng ta mong đợi, vì vậy chúng ta phải đảo ngược thứ tự của nó bằng cách sử dụng ~-reflexive.

Mặc dù chúng tôi đang di chuyển trong khoảng thời gian 2, chúng tôi phải sử dụng /-insert để chèn các động từ để chúng được sử dụng một cách tự nhiên vì cách đó \-infix hoạt động.

Ruby , 63 57 byte

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

Không có gì lạ mắt, thực sự. Chỉ cần lặp lại trên mảng, sử dụng một chỉ mục như là trình vòng lặp ngược, nối vào một chuỗi bằng cách sử dụng toán tử đúng, đánh giá, rửa và lặp lại.

Hãy thử trực tuyến!

k , 40 byte

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

Hãy thử trực tuyến!

{                                      } /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 nhờ @LuisMendo

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

Hãy thử trực tuyến!

Giải trình:

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

Hãy thử trực tuyến!

Lấy đầu vào là không gian ngăn cách danh sách các số.

R , 74 byte

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

Hãy thử trực tuyến!

Đây là câu trả lời cuối cùng tôi nghĩ ra. Nó trả về một danh sách độ dài length(l)trong đó mỗi phần tử là một danh sách chứa phần tử tương ứng. Kinda crappy nhưng tất cả đều ở đó. Nếu điều đó không được chấp nhận, một trong hai Mapcó thể được thay thế bằng mapply+3 byte.

Vì các toán tử R là tất cả các hàm (ký hiệu trung gian chỉ là đường cú pháp), tôi đã cố gắng chọn một từ danh sách; ví dụ, giải pháp 94 byte dưới đây.

Để thử và thoát khỏi vòng lặp, tôi đã thử sapply, nhưng nó chỉ hoạt động với một chức năng duy nhất và danh sách đầu vào. Sau đó, tôi nhớ dạng đa biến mapply, trong đó có một n-aryhàm FUNvà nthành công các đối số, áp dụng FUNcho các phần tử thứ nhất, thứ hai, ..., của mỗi đối số, tái chế nếu cần . Ngoài ra còn có một chức năng wrapper để mapply, Maprằng "làm cho không có nỗ lực để đơn giản hóa các kết quả" . Vì nó ngắn hơn ba byte, đó là một cơ hội chơi gôn tốt.

Vì vậy, tôi đã định nghĩa một hàm nhị phân (như trong giải pháp 80 byte bên dưới) lấy một hàm làm đối số đầu tiên của nó và áp dụng nó cho hàm thứ hai và thứ ba của nó. Tuy nhiên, tôi nhận ra rằng đó Maplà một hàm lấy một hàm làm đối số đầu tiên của nó và áp dụng nó cho các hàm kế tiếp nhau. Khéo léo!

Cuối cùng, chúng tôi tập hợp con ở cuối để đảm bảo chúng tôi chỉ trả về các length(l)giá trị đầu tiên .

R , 80 byte

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

Hãy thử trực tuyến!

Cái này không hoạt động, vì nó sẽ trả về 6 giá trị cho các danh sách có ít hơn 6 phần tử.

R , 94 byte

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

Hãy thử trực tuyến!

Giải thích (nhẹ nhàng vô duyên):

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
}

Bởi vì mỗi hàm được vector hóa, chúng ta có thể lập chỉ mục ở cuối ( res[i]). Điều này là tốt hơn so với evalcách tiếp cận dưới đây.

R , 100 byte

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

Hãy thử trực tuyến!

Đây là evalcách tiếp cận ngắn nhất tôi có thể tìm thấy; vì chúng tôi phải thu thập các kết quả vào một vector, chúng ta cần pastemột c( )xung quanh tất cả các biểu thức, có thêm một tấn byte không cần thiết

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)

Điều đó thật đau đớn. Đặc biệt là vì mod(x,y)trả về xkhi thực sự không nên, điều đó có nghĩa là tôi phải tự thực hiện chức năng mod của mình : từ đó x-int(x/y)y.

Vòng itừ 0 đến length(l)-1, lấy yếu tố liên tiếp trong odanh sách và áp dụng l[i]cho xvà l[-i]cho y. (các chỉ số phủ định không hoạt động, vì vậy thay vào đó tôi trừ đi iđộ dài của danh sách và lấy chỉ số đó.)

107 byte cho hàm, +1 byte để thêm lvào hộp tham số.

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

Hãy thử nó ở đây.

Thở dài ..
Đầu vào như int[], đầu ra là java.math.BigInteger[].

Nếu không có quy tắc " Để bao quát các trường hợp góc, đầu vào sẽ không bao giờ chứa 0, nhưng có thể chứa bất kỳ số nguyên nào khác trong phạm vi từ vô cực âm đến vô cực dương. ", Sử dụng các số nguyên trong phạm vi -2147483648tới 2147483647, nó sẽ là 186 byte (đầu vào như int[]và không có đầu ra vì nó thay đổi mảng đầu vào này thay vào đó để lưu 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];}

Hãy thử nó ở đây.

Giải trình:

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