แรงบันดาลใจจากสิ่งนี้

ในความท้าทายที่เชื่อมโยงเราจะขอให้เพิ่มองค์ประกอบของต้นฉบับและสิ่งที่ตรงกันข้ามของอาร์เรย์อินพุต ในความท้าทายนี้เราจะทำให้มันยากขึ้นเล็กน้อยโดยการแนะนำการดำเนินการทางคณิตศาสตร์ขั้นพื้นฐานอื่น ๆ

รับอาร์เรย์ของจำนวนเต็มวนไปเรื่อย ๆ โดย+, *, -, //, %, ^ที่การ//หารจำนวนเต็มและ^เลขชี้กำลังขณะที่ใช้มันกับด้านหลังของอาร์เรย์ หรือกล่าวอีกนัยหนึ่งให้ใช้หนึ่งในฟังก์ชั่นด้านบนกับแต่ละองค์ประกอบของอาเรย์โดยอาร์กิวเมนต์ที่สองนั้นเป็นสิ่งที่ตรงกันข้ามกับอาเรย์ สิ่งนี้อาจยังคงสับสนดังนั้นให้ลองทำตามตัวอย่าง

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

Husk , 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 ไบต์ขอบคุณ ovs

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]

เพิร์ล 6 ,67 66 ไบต์

บันทึกแล้ว 1 ไบต์ขอบคุณ @nwellnhof

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

ลองออนไลน์!

วิธีแก้ปัญหา (และอาจไม่ดี) ที่ไร้ความปราณี รหัสไปรษณีย์กลับอาร์กิวเมนต์ด้วยตัวเองกลับรายการ รายการส่งผลให้ถูกแมปแล้วกับบล็อกที่EVALs a (operator) bสตริง ผู้ประกอบการได้รับการแต่งตั้งจากรายการของสตริง<+ * - div % **>ใช้ฟรี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

มีวิธีที่ดีกว่าในการบรรลุเป้าหมายนี้อย่างแน่นอน

แก้ไข 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, yada yada ...

-2 ไบต์ต้องขอบคุณ @ ConorO'Brien

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

ลองออนไลน์!

parens และ inserts จำนวนมาก ... แน่นอนว่ามีวิธีที่ดีกว่าในการทำสิ่งนี้ (อาจใช้ insert แทนการใช้ infix?)

คำอธิบาย

_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 ไม่มีการหารจำนวนเต็มดังนั้นเราจึงเขียน%-division กับ>.-floor J's mod ( |) ทำสิ่งที่ตรงกันข้ามตามที่เราคาดหวังดังนั้นเราจึงต้องกลับคำสั่งโดยใช้~-reflexive

ถึงแม้ว่าพวกเรากำลังจะย้ายมากกว่าช่วงเวลาของ 2 เราจะต้องใช้/-insert แทรกคำกริยาจะมีพวกเขาถูกนำมาใช้ตั้งแต่ dyadically ว่าวิธี\-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)ที่แต่ละองค์ประกอบเป็นรายการที่มีองค์ประกอบที่สอดคล้องกัน kinda เส็งเคร็ง แต่พวกเขาทั้งหมดอยู่ที่นั่น หากไม่เป็นที่ยอมรับก็Mapสามารถแทนที่ได้ด้วยmapply+3 ไบต์

เนื่องจากโอเปอเรเตอร์ R เป็นฟังก์ชันทั้งหมด (สัญกรณ์ของ infix ที่เพิ่งเป็นน้ำตาล syntactic) ฉันจึงพยายามเลือกหนึ่งรายการจากรายการ ตัวอย่างเช่นโซลูชัน 94 ไบต์ด้านล่าง

ในการพยายามกำจัดลูปฉันพยายามsapplyแต่ก็ใช้ได้กับฟังก์ชั่นเดียวและรายการอินพุตเท่านั้น จากนั้นฉันจำรูปแบบหลายตัวแปรmapplyซึ่งใช้n-aryฟังก์ชันFUNและnประสบความสำเร็จในการขัดแย้งการประยุกต์ใช้FUNกับครั้งแรกที่สอง ... องค์ประกอบของแต่ละข้อโต้แย้ง, การรีไซเคิลในกรณีที่จำเป็น นอกจากนี้ยังมีฟังก์ชั่นเสื้อคลุมไปmapply, Mapว่า"ทำให้ความพยายามที่จะลดความซับซ้อนของผลที่ได้ไม่" เนื่องจากสั้นกว่าสามไบต์จึงเป็นโอกาสในการเล่นกอล์ฟที่ดี

ดังนั้นฉันจึงกำหนดฟังก์ชัน trinary (เช่นเดียวกับในโซลูชัน 80 byte ด้านล่าง) ที่ใช้ฟังก์ชันเป็นอาร์กิวเมนต์แรกและใช้กับฟังก์ชันที่สองและสาม อย่างไรก็ตามฉันตระหนักว่า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}

ลองออนไลน์!

คำอธิบาย (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
}

เนื่องจากแต่ละฟังก์ชั่นนั้นถูกทำให้เป็นเวกเตอร์เราสามารถทำดัชนีที่จุดสิ้นสุด ( 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เมื่อมันไม่ควรซึ่งหมายความว่าฉันต้องทำเองฟังก์ชั่น mod: 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 ไบต์ (input เป็น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