이 과제에서는 여기에 설명 된대로 합계와 숫자의 차이에 대해 제품을 배포 하는 데 사용합니다 .

예

  Input      |     Output
-------------|-------------
23(12+42)    | (23*12)+(23*42)
9(62-5)      | (9*62)-(9*5)
4(17+8-14)   | (4*17)+(4*8)-(4*14)
15(-5)       | -(15*5)
2(3)         | (2*3)
8(+18)       | +(8*18)
8(-40+18)    | -(8*40)+(8*18)

사양

입력은 n(_)단일 양의 부호없는 정수 n와 괄호로 묶은 표현식 이있는 형식의 문자열입니다 _. 이 표현식 _에 의해 분리 합보다 포지티브 정수 조건 중 하나의 차이가 구성된다 +및 -징후. 첫 번째 용어 앞에 +부호, -부호 또는 부호 없음이 있을 수 있습니다 .

결과에서 초기 값 n은 각 항에 곱하기 위해 분포되어야합니다. 각 항 에는 괄호 로 묶은 표현을 생성하기 위해 a곱한 값을 곱해야하며 ,이 새로운 항은 원래 항과 정확히 같은 방식으로 결합 하고 부호를 붙여야합니다.n(n*a)+-

유효하지 않은 입력

이들은 처리 할 필요가없는 입력의 예입니다.

3(5 plus 3)
6(5 13)
(5+8)(6+6)
(5+3)8

승리

이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이깁니다.

핍, 28 바이트

DQaUnxWa^'(xR`\d+`'(.n.`*&)`

설명:

                              a is first cmdline arg (implicit)
DQa                           Remove (DeQueue) the closing paren from a
   UnxWa^'(                   Unify n and x with a split on open paren--Python equivalent
                                n,x=a.split("(")
                              n is thus the number to be distributed, and x is the
                                addition/subtraction expression
           xR                 In x, replace...
             `\d+`            ... regex matching numbers...
                  '(.n.`*&)`  ... with the replacement pattern (n*&), where n is the
                                appropriate number and & substitutes the complete match
                              Print result (implicit)

Pip의 Pattern 객체는 대부분 Python 정규식 구문을 따르지만 &대체 패턴은 sed에서 빌려옵니다.

Github 리포지토리 에서 Pip에 대해 자세히 알아보십시오

자바 스크립트 65 바이트

s=>(q=s.split(/[()]/))[1].replace(/(\D?)(\d+)/g,`$1(${q[0]}*$2)`)

입력이 필요합니다. + 또는-를 찾은 다음 숫자를 올바른 순서로 바꾸십시오.

설명

s=>   // Function with argument "s"
  (q= // Set q to...
    s.split(/[()]/) // Splits on parenthesis, returns array
  )
  [1] // Gets second match or text inside brackets
  .replace(/ // Replaces string 
     (\D?)  // Try to match a non-digit, the +-/* (group 1)
     (\d+)  // Then match one or more digits (group 2)
  /,
      // $1 is group 1 and $2 is group 2 q[0] is the text before the parenthesis 
  `$1(${q[0]}*$2)`
  ) 

용법

이것은 Firefox 및 Safari Nightly maybe Edge 에서만 작동 합니까? ES6 기능을 사용하기 때문입니다. 다음을 통해 실행할 수 있습니다.

var t = s => (q = s.split (/ [()] /)) [1] .replace (/ (\ D?) (\ d +) / g,`$ 1 ($ {q [0]} * $ 2)`)

t ( "5 (-6 + 7 + 3-8 + 9)" ); //-(5 * 6) + (5 * 7) + (5 * 3)-(5 * 8) + (5 * 9)

파이썬 2.7, 110 108 바이트

import re
p=re.findall('([+-]?)(\d+)',raw_input())
print"".join("%s(%s*%s)"%(e[0],p[0][1],e[1])for e in p[1:])

이 프로그램은 stdin에서 입력을 받아 -regex와 일치하는 항목을 검색 ([+-]?)(\d+)하고 출력 문자열을 만듭니다.
그것을 테스트-

<< 23(12+42)
>> (23*12)+(23*42)

<< 9(62-5)
>> (9*62)-(9*5)

<< 4(17+8-14)
>> (4*17)+(4*8)-(4*14)

<< 15(-5)
>> -(15*5)

<< 2(3)
>> (2*3)

<< 8(+18)
>> +(8*18)

<< 8(-40+18)
>> -(8*40)+(8*18)

망막 , 40 바이트

+`(\d+)\((\D)?(\d+)
$2($1*$3)$1(
\d+..$
<empty line>

각 줄은 자체 파일로 이동해야하지만 -s플래그를 사용하여 코드를 하나의 파일로 실행할 수 있습니다 . 예 :

>echo -n "8(-40+18)"|retina -s distributing_numbers
-(8*40)+(8*18)

처음 두 줄은 예상 형식으로 모든 숫자 옆에 승수를 밀어 넣습니다.

8(-40+18)
-(8*40)8(+18)
-(8*40)+(8*18)8()

마지막 두 줄은 불필요한 후행 부분을 제거합니다.

-(8*40)+(8*18)8()
-(8*40)+(8*18)

sed, 105 바이트

이것이 sed로 수행 할 수 있는지 확인하고 싶었습니다.
조금 오래된 학교 일지 모르지만 작동합니다.

$ cat distnum.sed
s@\([0-9]*\)(\([0-9]*\)\([+-]*\)\([0-9]*\)\([+-]*\)\([0-9]*\))@(\1*\2)\3(\1*\4)\5(\1*\6)@
s@([0-9]*\*)@@g

$ cat distnum.txt
23(12+42)
9(62-5)
4(17+8-14)
15(-5)
2(3)
8(+18)
8(-40+18)

$ sed -f distnum.sed distnum.txt
(23*12)+(23*42)
(9*62)-(9*5)
(4*17)+(4*8)-(4*14)
-(15*5)
(2*3)
+(8*18)
-(8*40)+(8*18)

rs , 77 바이트

$$d=(?<!\))([+-]?)(\d+)
+$d\($d([+-])/\3(\1\2*\4)\5\1\2(
$d\($d\)/\3(\1\2*\4)

라이브 데모 및 모든 테스트 사례.

rs의 매크로가 실제로 사용 된 것은 이번이 처음입니다!

REGXY , 45 바이트

정규식 대체 기반 언어 인 REGXY를 사용합니다.

/(\d+)\((\D)?(\d+)/\2(\1*\3)\1(/
//
/\d+\(.//

펄, 36 바이트

35 바이트 코드 + 1 바이트 명령 행

($a,$_)=split/[()]/;s/\d+/($a*$&)/g

용법:

echo "4(17+8-14)" | perl -p entry.pl

Pyth, 39 38 바이트

끔찍한 정규식 솔루션 :

P:eJcz\("([+-]?)(\d+)"X"\\1(_*\\2)"3hJ

루비, 94 바이트

gets.scan(/(\d+)\(([[-+]?\d+]+)/){|a,b|b.scan(/([-+]?)(\d+)/).map{|c,d|$><<"#{c}(#{a}*#{d})"}}

CJam, 50 바이트

l__'(#_@<'*+@@)>);'+/'-f/\ff{1$'(@@++')+L?}'-f*'+*

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

CJam은 정규 표현식을 지원하지 않거나 표현식을 구문 분석하는 데 매우 편리한 문자열 검색 및 분할 이외의 것은 없습니다. 여기에는 약간의 노력이 필요합니다.

설명:

l__   Get input and push 2 copies for splitting.
'(#   Find index of '(.
_     Copy index, will be used twice.
@<    Get one copy of input to top, and slice to get first multiplier.
'*+   Append '* to first multiplier.
@@    Get another copy of input and '( index to top.
)>    Increment and slice to get everything after '(.
);    Remove trailing ').
'+/   Split at '+.
'-f/  Split each part at '-.
\     Swap first multiplier to top.
ff{   Apply block to nested list of second multipliers.
  1$    Copy term. Will use this copy as condition to skip empty second multipliers
        that result from unary + or -.
  '(    Opening parentheses.
  @@    Get first and second multiplier to top.
  ++    Concatenate it all.
  ')+   Concatenate closing parentheses.
  L     Push empty string for case where term is skipped.
  ?     Ternary if to pick term or empty string.
}     End of loop over list of second multipliers.
'-f*  Join sub-lists with '-.
'+*   Join list with '+.

개크 -60 58

$0=gensub(/(.*\()?(+|-)?([0-9]+))?/,"\\2("$0+0"*\\3)","G")

휴 ... 정말로 정규 표현식으로 작업하지 않았습니다.

펄 5, 70 60 55 44 바이트 + 1 페널티

split 및 1 정규식 만 사용하는 펄 솔루션입니다.
또한 더 긴 입력을 계산합니다.

($a,$_)=split/[()]/;s/(\D?)(\d+)/$1($a*$2)/g

테스트

$ echo "8(9-10+11-12+13-14)"|perl -p distnums.pl   
(8*9)-(8*10)+(8*11)-(8*12)+(8*13)-(8*14)

매개 변수를 취하는 버전

($a,$_)=split/[()]/,pop;s/(\D?)(\d+)/$1($a*$2)/g;print

정규식 만 사용하는 버전입니다.

s/(\d+)\((.*)\)/$2:$1/;s/(\D?)(\d+)(?=.*:(\d+)).*?/$1($3*$2)/g;s/:.*//

이것은 긍정적 인 예측과 게으른 일치 내의 캡처 그룹을 통해 작동합니다. 아마도 Perl 5가 지원한다면 긍정적 인 전망을 사용했을 것입니다. 이 종류의 일이 정규식으로 가능하다는 것을 알아 내기 위해 잠시 시간을 보냈습니다.

망막 , 50 51 43 바이트

나는 이것이 나의 첫번째 Retina 프로그램 일지도 모른다고 생각한다 . 그렇지 않다면,이 복잡한 (실제로 복잡한 것은 아닙니다) 첫 번째 Retina 프로그램입니다. 각 줄은 자체 파일에 들어갑니다.

+`(\d+)\((\D?)(\d+)
$1($'$2($1*$3)
.+?\)
$'

나는 실제로 이것을 Retina로 테스트하지 않았으며 정규식 대체 테스터를 여러 번 사용하여 테스트했지만 작동해야합니다.

첫 번째 예에 대한 설명 :

짝수 개의 파일이 있으므로 Retina는 바꾸기 모드를 사용합니다. 첫 번째 바꾸기 (처음 두 파일)는 배포 할 숫자를 제거하고 해당 배포 쌍 (23*12)을 끝에 추가하여을 제공 23(+42)(23*12)합니다. +`처음에는 패턴이 일치하지 않을 때까지 Retina에 반복적으로 교체하도록 지시하며, 다시 일치하므로 패턴이이를로 바꿉니다 23()(23*12)+(23*42). 더 이상 일치하지 않으므로 다음 두 파일이 다음 교체에 사용됩니다. 이번에는 단지를 제거합니다 23(). 이것은 잘 작동합니다 : 제품이 끝에 추가되기 때문에 숫자가 부호가없는 경우 이상한 일을 할 필요가 없습니다. 부호가없는 유일한 것은 첫 번째 숫자이기 때문입니다.

편집 : $'대체는 일치 후 문자열의 나머지 부분을 나타내므로 후행 (.*)s를 제거 할 수 있습니다 .

k, 98 바이트

골프는 아니었다.

{,/(*x){(s#y),("*"/:(x;(s:(*y)in"+-")_y))/:$"()"}/:1_x@:&~~#:'x:((0,&~x in .Q.n)_x){x_'x?'y}/"()"}

숫자가 아닌 숫자로 나누고, 괄호를 제거하고, 빈 문자열을 제거한 다음 x, 첫 번째 문자열로 상수 를 유지 하고, *나머지 각 문자열과 결합하고 y괄호로 묶고 존재하는 경우 기호를 처음으로 이동하십시오. 출력을 단일 문자열로 병합합니다.