이것에 의해 영감을

연결된 도전에서, 우리는 원본의 요소와 입력 배열의 역에 추가를 적용하도록 요청받습니다. 이 과제에서 우리는 다른 기본 수학 연산을 도입하여 약간 더 어렵게 만들 것입니다.

정수 배열이 주어지면를 통해 순환합니다 +, *, -, //, %, ^. 여기서 //정수 나누기와 ^지수는 배열의 반대에 적용됩니다. 즉, 위의 함수 중 하나를 배열의 각 요소에 적용합니다. 두 번째 인수는 배열의 반대이며 함수는 위의 목록을 순환하면서 적용됩니다. 여전히 혼란 스러울 수 있으므로 예제를 통해 작업 할 수 있습니다.

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

배쉬 + 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]

파이썬 2 , 67 바이트

ovs 덕분에 -3 바이트

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

온라인으로 사용해보십시오!

파이썬 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사악하지만 ... 아마도 더 골프입니다. :피

자바 스크립트 (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 바이트

@nwellnhof 덕분에 1 바이트를 절약했습니다.

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

온라인으로 사용해보십시오!

매우 상상력이 좋지 않은 (아마도 나쁜) 솔루션입니다. 인수 자체를 반대로 뒤집습니다. 그런 다음 결과 목록이 EVAL문자열 인 블록으로 매핑됩니다 a (operator) b. 연산자는 <+ * - div % **>free state( staticC에서 생각 -값은 블록의 호출에서 지속됨) 변수를 사용하여 문자열 목록에서 선택됩니다 $. 이것은 각각의 블록에 대해 개별적으로 생성되고 0으로 설정됩니다. 원하는 것은 무엇이든 할 수 있지만 한 번만 참조 할 수 있습니다 (각 항목은 $실제로 다른 변수 를 나타냄). 그래서 $++%67 등 중 6 일 0시 두 번째 ... 5시에 실제로 0 첫 번째 호출, 1시입니다.

나는 처음에없이 시도했다 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 bytes

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

온라인으로 사용해보십시오!

파이썬 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+/`(*/)`(-/)`(<.@%/)`(|~/)`(^/)\[:,],.|.

온라인으로 사용해보십시오!

너무 많은 parens와 inserts ... 확실히 이것을하는 더 좋은 방법이 있습니다 (infix 대신 insert를 사용하는 것일까 요?)

설명

_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가 \작동 하는 방식이기 때문에 -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 연산자는 모두 함수이기 때문에 (접두어 표기법은 구문 설탕 임) 목록에서 하나를 선택하려고했습니다. 예를 들어, 아래 94 바이트 솔루션입니다.

루프를 제거하고 제거하기 위해 시도 sapply했지만 단일 함수 및 입력 목록에서만 작동합니다. 그런 다음 다변량 형식을 기억했습니다. mapply이 n-ary함수 는 함수 FUN와 n후속 인수 를 취하여 각 인수 FUN의 첫 번째, 두 번째, ..., 요소에 적용 하고 필요한 경우 재활용합니다 . 에 래퍼 함수도 있습니다 mapply, Map것을 "결과를 단순화하려는 시도를하지 않습니다" . 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}

온라인으로 사용해보십시오!

설명 (약간 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( )모든 표현식 주위에 필요하며 많은 불필요한 바이트가 추가됩니다.

카시오 기본, 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 바이트 l, 매개 변수 상자 에 추가 할 +1 바이트

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

여기에서 시도하십시오.

Sigh ..로
입력하고 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