음수가 아닌 정수의 비어 있지 않은 목록이 주어지면 다음과 같은 경우 산술 문제로 다시 작성하십시오.

• +왼쪽에서 오른쪽으로 증가하는 숫자 쌍 사이에 더하기 부호 ( )가 삽입됩니다 (일명 목록의 시작에서 끝까지).
• -왼쪽에서 오른쪽으로 감소하는 숫자 쌍 사이에 빼기 부호 ( )가 삽입됩니다.
• 곱셈 부호 ( *)는 동일한 숫자 쌍 사이에 삽입됩니다.

다른 방법으로 말하면 모든 하위 목록 a,b은 a+bif a<b, a-bif a>b및 a*bif a==b입니다.

예를 들어, 목록

[12, 0, 7, 7, 29, 10, 2, 2, 1]

표현이 될 것입니다

12 - 0 + 7*7 + 29 - 10 - 2*2 - 1

로 평가됩니다 75 .

이러한 목록을 가져 와서 평가, 인쇄 또는 결과 반환하는 프로그램 또는 함수를 작성하십시오.

• 작업 순서가 중요합니다. 곱하기는 더하기 또는 빼기 전에 수행해야합니다.
• 입력 목록에 하나의 숫자가 있으면 그것이 평가되는 것이어야합니다. 예를 들면 [64]제공해야합니다 64.
• 의 사용 eval또는 exec유사한 구조가 허용됩니다.

몇 가지 추가 예는 다음과 같습니다.

[list]
expression
value

[0]
0
0

[1]
1
1

[78557] 
78557
78557

[0,0]
0*0
0

[1,1]
1*1
1

[2,2]
2*2
4

[0,1]
0+1
1

[1,0]
1-0
1

[1,2]
1+2
3

[2,1]
2-1
1

[15,4,4]
15-4*4
-1

[9,8,1]
9-8-1
0

[4,2,2,4]
4-2*2+4
4

[10,9,9,12]
10-9*9+12
-59

[1,1,2,2,3,3]
1*1+2*2+3*3
14

[5,5,4,4,3,3]
5*5-4*4-3*3
0

[3,1,4,1,5,9,2,6,5,3,5,9]
3-1+4-1+5+9-2+6-5-3+5+9
29

[7637,388,389,388,387,12,0,0,34,35,35,27,27,2]
7637-388+389-388-387-12-0*0+34+35*35-27*27-2
7379

바이트 단위의 가장 짧은 코드가 이깁니다. Tiebreaker가 이전 답변입니다.

파이썬 2, 63 바이트

p=s='print-'
for x in input():s+='*+-'[cmp(x,p)]+`x`;p=x
exec s

eval표현식 문자열을 구성하고 s합니다. 산술 기호는 이전 숫자 p와 현재 숫자 를 비교하여 선택됩니다 x. 기호 뒤에 현재 번호가 추가됩니다.

첫 번째 숫자는 Sp3000의 영리한 속임수로 처리됩니다. 의 초기 값은 p문자열로 설정되며, 이는 임의의 숫자보다 크므로 -첫 번째 숫자 앞에옵니다. 그러나, s초기화됩니다 print-와 결과 시작하게 같은 시간에 print--(로 초기화하여 2 바이트를 저장하는 xsot 덕분에 print.)

Pyth, 31 26 19 17 16 15 바이트

를 사용한 표현식 *은 온라인으로 평가되지 않지만 이론적으로는 작동합니다.

Maltysen 덕분에 2 바이트.

vsm+@"*-+"._-~k

테스트 스위트 (평가 포함).

다른 경우 (평가없이).

역사

• 31 바이트 : M+G@"*-+"->GH<GHv+sgMC,JsMQtJ\x60e
• 26 바이트 : M+G@"*-+"->GH<GHv+sgVQtQ\x60e
• 19 바이트 : vtssVm@"*-+"->Zd<~Z
• 17 바이트 : vtssVm@"*-+"._-~Z
• 16 바이트 : vssVm@"*-+"._-~k
• 15 바이트 : vsm+@"*-+"._-~k

젤리 , 18 16 15 14 바이트

I0;ð1g×⁹⁸œṗP€S

내장 평가를 사용하지 않습니다. 온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

I0;ð1g×⁹⁸œṗP€S  Main link. Input: A (list)

I               Increments; compute the deltas of all adjacent items of A.
 0;             Prepend a 0.
   ð            Begin a new, dyadic chain.
                Left argument: D (0 plus deltas). Right argument: A
    1g          Compute the GCD of 1 and each item in D.
                This yields 1 for non-negative items, -1 for negative ones.
      ×⁹        Multiply each 1 or -1 with the corresponding item of A.
                This negates every item in A that follows a - sign.
        ⁸œṗ     Partition the result by D. This splits at occurrences of non-zero
                values of D, grouping items with identical absolute value.
           P€   Take the product of each group.
             S  Sum; add the results.

MATL , 12 바이트

Y'^l6MdZSh*s

이것은 @aditsu의 실행 길이 인코딩에 대한 아주 좋은 아이디어 를 사용합니다.

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

설명

       % Take input vector implicitly
Y'     % RLE. Produces two vectors: values and lengths
^      % Rise each value to the number of consecutive times it appears. This
       % realizes the product of consecutive equal values
l      % Push 1
6M     % Push vector of values again
d      % Consecutive differences
ZS     % Sign function. Gives 1 or -1 (no 0 in this case)
h      % Concatenate horizontally with previous 1
*      % Multiply. This gives plus or minus depending on increasing character
s      % Sum of vector. This realizes the additions or subtractions
       % Display implicitly

CJam, 20

q~e`{~_W-g\:W@#*}%:+

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

설명:

q~       read and evaluate the input (array of numbers)
e`       RLE encode, obtaining [count number] pairs
{…}%     map each pair
  ~_     dump the count and number on the stack, and duplicate the number
  W-     subtract the previous number (W is initially -1 by default)
  g      get the sign of the result
  \      swap with the other copy of the number
  :W     store it in W (for next iteration)
  @#     bring the count to the top, and raise the number to that power
  *      multiply with the sign
:+       add all the results together

자바 스크립트 (ES6), 54

p=>eval(0+p.map(v=>x+='*-+'[(p>v)+2*(p<v)]+(p=v),x=1))

eval 쉼표로 구분 된 표현식 목록을 수신하고 마지막 값을 리턴합니다.

테스트

f=p=>eval(0+p.map(v=>x+='*-+'[(p>v)+2*(p<v)]+(p=v),x=1))

t=p=>(0+p.map(v=>x+='*-+'[(p>v)+2*(p<v)]+(p=v),x=1))

function Test() {
  var a=I.value.match(/\d+/g).map(x=>+x) // convert input to a numeric array
  
  var x=f(a),y=t(a)
  O.textContent='Value '+x+'\n(no eval '+y+')'
}  

Test()

#I { width:80%}

<input value='12, 0, 7, 7, 29, 10, 2, 2, 1' id=I>
<button onclick='Test()'>Test</button>
<pre id=O></pre>

줄리아, 76 57 바이트

!x=[[" ""-*+"[2+sign(diff(x))]...] x]'|>join|>parse|>eval

내가 처음으로 Julia를 골프를 쳤기 때문에 아마도 분명한 개선이있을 것입니다. 온라인으로 사용해보십시오!

Dennis는 많은 바이트를 절약했습니다.

Pyth- 23 22 20 바이트

케니와 마찬가지로 곱셈은 온라인으로 작동하지 않습니다.

vs.i+\+@L"*+-"._M-Vt

eval없이 테스트 스위트 .

R, 92 바이트

여기서 할 수있는 좋은 골프가 여전히있을 것입니다.

eval(parse(t=paste(i<-scan(),c(ifelse(d<-diff(i),ifelse(d>0,"+","-"),"*"),""),collapse="")))

언 골프 드 :

i = scan()                # Read list from stdin
d = diff(i)               # Calculate difference between each element of list
s = ifelse(d,             # If d!=0
             ifelse(d>0,  # And if d>1
                    "+",  # Return plus
                    "-"), # Else return minus
             "*")         # Else (i.e. d==0) return multiply.
s = c(s,"")               # Pad the list s with an empty string, so it's the same
                          # length as i
p = paste(i,s,collapse="")# Paste the elements of i and s into one long string.
eval(parse(t=p))          # Evaluate the string as a language object.

Brachylog , 34 32 바이트

~b≜ḅ⟨h⟨h≡^⟩l⟩ᵐs₂ᶠ{zh>₁&ttṅ|tt}ᵐ+

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

TI-BASIC, 146 바이트

모바일이 아닌 경우 멋지게 포맷하겠습니다. 수면이 나를 탈출하므로 이걸 얻습니다. 즐겨.

Prompt L₁
"(→Str1
For(A,1,dim(L₁
{0,1→L₂
{0,L₁(A→L₃
LinReg(ax+b) L₁,L₃,Y₁
Equ►String(Y₁,Str2
sub(Str2,1,-1+inString(Str2,"X→Str2
If A>1
Then
L₁(A-1
2+(Ans>L₁(A))-(Ans<L₁(A
Str1+sub("+*-",Ans,1→Str1
End
Str1+Str2→Str2
End
expr(Str1

자바 스크립트 ES6, 64 62 자

a=>eval(a.map((x,i)=>x+('*+-'[x<a[++i]|(x>a[i])*2])).join``+1)

자바, 384 바이트

int s(int[]l){int n=l[0],m;for(int i=0;i<l.length-1;i++)if(l[i]<l[i+1])if(i<l.length-2&&l[i+1]!=l[i+2])n+=l[i+1];else{m=l[i+1];while(i<l.length-2&&l[i+1]==l[i+2])m*=l[(i++)+1];n+=m;}else if(l[i]>l[i+1])if(i<l.length-2&&l[i+1]!=l[i+2])n-=l[i+1];else{m=l[i+1];while(i<l.length-2&&l[i+1]==l[i+2])m*=l[(i++)+1];n-=m;}else{m=l[i];while(i<l.length-1&&l[i]==l[i+1])m*=l[i++];n+=m;}return n;}

Ungolfed 온라인 시도

int s(int[] l)
{
    int n=l[0], m;

    for(int i=0; i<l.length-1; i++)
    {
        if(l[i] < l[i+1])
        {
            if (i<l.length-2 && l[i+1]!=l[i+2])
            {
                n += l[i+1];
            }
            else
            {
                m = l[i+1];
                while(i<l.length-2 && l[i+1]==l[i+2]) m *= l[(i++)+1];
                n += m;
            }
        }
        else if(l[i] > l[i+1])
        {
            if (i<l.length-2 && l[i+1]!=l[i+2])
            {
                n -= l[i+1];
            }
            else
            {
                m = l[i+1];
                while(i<l.length-2 && l[i+1]==l[i+2]) m *= l[(i++)+1];
                n -= m;
            }
        }
        else
        {
            m = l[i];
            while(i<l.length-1 && l[i]==l[i+1]) m *= l[i++];
            n += m;
        }
    }

    return n;
}

자바 스크립트 ES6, 79 자

a=>eval(`${a}`.replace(/(\d+),(?=(\d+))/g,(m,a,b)=>a+('*+-'[+a<+b|(+a>+b)*2])))

펄, 49 바이트

48 바이트 코드 + 1 -p

s/\d+ (?=(\d+))/$&.qw(* - +)[$&<=>$1]/ge;$_=eval

용법

perl -pe 's/\d+ (?=(\d+))/$&.qw(* - +)[$&<=>$1]/ge;$_=eval' <<< '12 0 7 7 29 10 2 2 1'
75

노트

나는 조금 직관적 (비록 당신이 PCRE에서 내다을 캡처 할 수 있다고 여기 배운 (?=(\d+))대신이 ((?=\d+))). 읽기 후 길이가 0 인 일치 (룩어 헤드)를 캡처하고 대신에 일치하는 것을 캡처하므로 읽기 후에는 의미가 있습니다.

8 바이트를 절약 한 @ninjalj 에게 감사 합니다!

실제로 30 바이트

;2@VpXdX`i-su"+*-"E`M' @o♀+εj≡

불행하게도, eval ( ≡) 명령은 TIO에서 리터럴 만 평가하므로이 프로그램은 TIO에서 작동하지 않습니다.

설명:

;2@VpXdX`i-su"+*-"E`M' @o♀+εj≡
;                               duplicate input
 2@V                            overlapping sublists of length <= 2
    pXdX                        discard first and last element (length-1 sublists)
        `i-su"+*-"E`M           map: for each pair of elements
         i-su                     flatten, subtract, sign, increment (results in a 0 if b < a, 1 if b == a, and 2 if b > a)
             "+*-"E               select the correct operation
                     ' @o       put a space at the beginning of the list to pad it properly
                         ♀+     pairwise addition (since addition is not defined for strings and integers, this just zips the lists and flattens the result into a single flat list)
                           εj   join with empty string
                             ≡  eval

R , 120 44 바이트

r=rle(scan());c(1,sign(diff(r$v)))%*%r$v^r$l

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

알고리즘은 이 답변 과 유사 하지만 내 답변을 코딩 한 후에 만 ​​알았습니다. 사용했던 원래의 답변보다 훨씬 낫습니다 eval(parse).

R의 벡터화 된 연산을 완벽하게 활용 합니다. 먼저이 벡터를 사용하여 (-로 표시 ) 이 제품을 *사용 rle(x)$values ^ rle(x)$lenghts하고 내적 합니다.sign( diff( rle(x)$values ) )1

05AB1E (레거시) , 17 16 15 바이트

ü.S…*-+sè‚ζJJ.E

@Emigna 덕분에 -2 바이트 .

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

ü                  # Pair-wise loop over the (implicit) input-list
                   #  i.e. [12,0,7,7] → [[12,0],[0,7],[7,7]]
 .S                # Calculate the signum of the pair (-1 for a<b; 0 for a==b; 1 for a>b)
                   #  i.e. [[12,0],[0,7],[7,7]] → [1,-1,0]
   …*-+sè          # Index over "*-+" (with wrap-around)
                   #  i.e. [1,-1,0] → ['-','+','*']
         ‚ζ        # Zip the two lists together (appending the operands to the numbers)
                   #  i.e. [12,0,7,7] and ['-','+','*','+']
                   #   → [[12,'-'],[0,'+'],[7,'*'],[7,' ']]
           JJ      # Join them together
                   #  [[12,'-'],[0,'+'],[7,'*'],[7,' ']] → '12-0+7*7 '
             .E    # Evaluate as Python code
                   #  i.e. '12-0+7*7' → 61

PHP, 103 바이트

깔끔한 도전. 예상보다 오래 걸렸습니다. array_map익명 함수는 PHP에서 여전히 비싸기 때문에 또는 비슷한 것을 사용 하면 바이트 수가 향상되지 않는다고 생각 합니다.

foreach(fgetcsv(STDIN)as$v)(0<=$p?$o.=$p.('*-+'[($p>$v)+2*($p<$v)]):_)&&$p=$v;echo eval("return$o$v;");

명령 행에서 실행되며 다음과 같이 쉼표로 구분 된 목록을 프롬프트합니다.

php array_to_math.php
12, 0, 7, 7, 29, 10, 2, 2, 1

PowerShell v2 +, 62 바이트

-join($args|%{"$o"+'*+-'[($o-lt$_)+2*($o-gt$_)];$o=$_})+$o|iex

공백으로 구분 된 명령 줄 인수로 입력을 가져 와서 자동 배열로 변환 $args합니다. $o이전 항목이 무엇인지 기억하기 위해 각 반복 변수를 사용하여 각 요소를 반복합니다. 우리는 (이전 항목이 작은 경우 예는 암시 적으로 변환 된 부울 값에 수학을 수행하여 완료 적절한 연산자를 꺼내하는 인덱스 문자열을 사용하여 []평가 1+2*0때문에이 '*+-'[1]이 의미 +선택).

연결된 문자열은 파이프 라인에 남아 있습니다. 우리는 (예를 들어, 함께 그 조각을 모두 수집 3-, 1+, 4-로모그래퍼 등) -join운영, CONCATENATE (암시 적으로 문자열로 변환) 마지막 수에, 및 파이프 그것에 iex(별칭 Invoke-Expression과 유사 eval).

Japt , 25 바이트

짧게 줄이려고하지만 평가가 적은 버전을 만들 수 없었습니다.

S+Uä!- ®"*+-"gZÎì)íU
OxU

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

apt -x , 21 19 바이트

änJ f mÎí*Uò¦ ®ÎpZÊ

시도 해봐

설명

                        :Implicit input of array U
  J                     :Prepend -1
än                      :Get deltas
    f                   :Filter (remove 0s)
      m                 :Map
       Î                : Signs
        í               :Interleave
          U             :  Original input
           ò            :  Partition on
            ¦           :   Inequality
              ®         :  Map each sub-array Z
               Î        :    Get first element
                p       :    Raise to the power of
                 ZÊ     :     Length of Z
         *              :Reduce each pair of elements by multiplcation
                        :Implicitly reduce by addition and output