문자 만 포함하는 홀수 길이 문자열에 걸리는 프로그램 작성 .및 :. 초기에 비어있는 stack 을 사용하여 다음과 같이이 문자열에서 숫자를 생성하십시오.

문자열의 모든 문자 c 에 대해 (왼쪽에서 오른쪽으로 이동) ...

• 경우 C는 인 .스택 미만 2 개 요소를 가지고, 스택 (1)을 누른다.
• 경우 C는 인 .스택은 둘 개 이상의 구성 요소를 가지고, 스택에서 두 최고 값을 팝업 스택에 그 합을 누른다.
• 경우 C는 인 :스택 미만 2 개 요소가 스택에 푸시 2.
• 경우 C는 인 :스택은 둘 개 이상의 구성 요소를 가지고, 스택에서 두 최고 값을 팝업 스택에 그들의 제품을 누른다.

결과 숫자는 스택 맨 위에있는 값입니다. 프로그램은이 번호를 stdout에 인쇄해야합니다 (선택적 후행 줄 바꿈).

(작은 분석에 따르면 문자열의 길이가 고르지 않는 한 하나의 숫자 만 남았으므로이를 무시하는 것입니다. 실제로 스택에는 두 개 이상의 요소가 없습니다.)

예를 들어의 수 ::...:.:.는 9입니다.

  2   1   2   2    /______ stack just after the character below is handled
2 2 4 4 5 5 7 7 9  \
: : . . . : . : .  <-- string, one character at a time

위생 검사로서 길이 1, 3 및 5의 모든 문자열에 대한 숫자는 다음과 같습니다.

. 1
: 2
... 2
..: 1
.:. 3
.:: 2
:.. 3
:.: 2
::. 4
::: 4
..... 3
....: 2
...:. 4
...:: 4
..:.. 2
..:.: 1
..::. 3
..::: 2
.:... 4
.:..: 3
.:.:. 5
.:.:: 6
.::.. 3
.::.: 2
.:::. 4
.:::: 4
:.... 4
:...: 3
:..:. 5
:..:: 6
:.:.. 3
:.:.: 2
:.::. 4
:.::: 4
::... 5
::..: 4
::.:. 6
::.:: 8
:::.. 5
:::.: 4
::::. 6
::::: 8

바이트 단위의 최단 프로그램이 이깁니다. Tiebreaker는 이전 게시물입니다.

• 당신은, 즉, 입력이 항상 유효한에만 포함 된 문자열을 가정 할 수 .와 :길이가 홀수입니다.
• 프로그램을 작성하는 대신 유효한 문자열을 받아서 생성 된 숫자를 인쇄하거나 반환하는 함수를 작성할 수 있습니다.

CJam, 27 24 23 22 바이트

q{i]_,+~3<-"1+2* "=~}/

꽤 직설적 인. 질문에 언급 된 스택으로 CJam의 스택을 사용합니다.)

연산

먼저 .및 의 ASCII 코드를 살펴 보겠습니다 :.

'.i ':ied

[46 58]

CJam에서는 인덱스가 둘러 싸여 있기 때문에 원하는 값을 직접 얻기 위해 이러한 값을 직접 사용할 수 있는지 살펴 보겠습니다.

'.i4% ':i4%ed

[2 2]

따라서 4 길이의 조작 문자열에서 ASCII 코드를 간단하게 사용할 수 없습니다. 다른 가치를 시험해 보자

'.i 10% ':i 10%ed

[6 8]

4 개 길이의 문자열에서

[2 0]

이 mod 10 작업을 사용할 수 있지만 비용은 2 바이트입니다. 다른 것을 시도 할 수 있습니다

'.i5% ':i5%ed

[1 3]

Nice !, 이제 스택 크기 조건에서 1을 빼서 인덱스를 가져 0, 1, 2 and 3오고 5길이 배열 ( "1+2* ")을 스위치 케이스로 사용합니다. 마지막 공간은 길이 5로 만들기위한 필러 일뿐입니다. 이것은 모딩 작업과 비교할 때 1 바이트 밖에되지 않습니다.

q{                  }/    e# parse each input character in this loop
  i]                      e# convert '. or ': into ASCII code and wrap everything
                          e# in stack in an array
    _,+                   e# Copy the stack array, take its length and add the length to
                          e# the stack array 
       ~3<                e# unwrap the stack array and check if stack size is less than 3
                          e# 3 because either . or : is also on stack
          -               e# subtract 0 or 1 based on above condition from ASCII code
           "1+2* "        e# string containing the operation to perform
                  =~      e# chose the correct operation and evaluate it

여기에서 온라인으로 사용해보십시오

cosechy 덕분에 1 바이트 절약

> <> (물고기) , 33 바이트

ib%1-i:1+?\~n;
5a*)?*+40.\b%1-0@i

약간의 트릭 / 최적화로 매우 간단합니다.

설명:

• 정보 : i= 입력 -1끝에 도달 한 경우 다음 입력 문자의 코드 포인트 ; a= 10; b= 11; )=>
• i첫 번째 입력 문자의 코드 포인트
• b%1- top_of_stack mod 11 - 1마스크 48 ('.') , 56 (':')에1 , 2
• i:1+?\~n; 입력의 끝에 도달하면 마지막 결과를 인쇄하고 종료
• 그렇지 않으면:
• b%1- 마스크 입력 1 , 2
• 0@0두 숫자 아래로 밀다
• i5a*)다음 입력을 읽고 0 , 1비교하기 위해 마스크50
• 스택 (0 개 제품)을 생성하는 상위 두 요소를 곱한 경우 1( ':')
• 항상 스택을 생성하는 두 가지 요소를 추가 [0 sum]하거나[0+product=product]
• 40.(4,0)우리의 요점 4인 위치로 다시 점프 (루프) 합니다 .i:1+?\~n;

하스켈, 73 65 바이트

스택에는 2 개 이상의 요소가 없다는 사실을 사용하는 간단한 솔루션입니다.

[x,y]#'.'=[x+y]
[x,y]#_=[x*y]
s#'.'=1:s
s#_=2:s
f=head.foldl(#)[]

C, 104 바이트

k[2],n;f(char*c){for(n=0;*c;)k[n]=*c++-58?n>1?n=0,*k+k[1]:1:n>1?n=0,*k*k[1]:2,k[1]=n++?k[1]:0;return*k;}

글쎄, 이것은 너무 길다.

Pyth, 25 24 바이트

eu?]?.xGHsGtG+GhHmqd\:zY

@isaacg의 솔루션을 연구하여 아이디어를 얻었습니다. 하지만 스택을 사용하고 있습니다.

온라인 데모 또는 테스트 스위트

설명

내가하는 첫 번째 일은 입력 문자열을 0과 1로 변환하는 것입니다. A "."는 a 0, a ":"로 변환됩니다 1.

mqd\:z   map each char d of input to (d == ":")

그런 다음이 숫자 목록을 줄입니다.

eu?]?.xGHsGtG+GhHmqd\:zY
 u                     Y   start with the empty stack G = []
                           for each H in (list of 0s and 1s), update G:
                              G = 
    ?.xGHsG                      product of G if H != 0 else sum of G
   ]                             wrapped in a list 
  ?        tG                 if G has more than 1 element else
             +GhH                G + (H + 1)
e                         take the top element of the stack

자바 스크립트 (ES6), 65

스택의 셀은 2 개만 사용합니다.

s [0]에 값을 입력하십시오.
그런 다음 입력 문자열의 각 홀수 위치 (0부터 계산)에서 s [1]에 값을 입력하십시오.
각 짝수 위치에서 계산을 실행하고 (더하기 또는 곱하기) 결과를 s [0]에 저장합니다.

따라서 스택을 잊고 두 개의 변수 a와 b 만 사용하십시오.

f=s=>[...s].map((c,i)=>(c=c>'.',i&1?b=1+c:i?c?a*=b:a+=b:a=1+c))|a

빠른 테스트

for(i=0;i<128;i++)
{
  b=i.toString(2).replace(/./g,v=>'.:'[v]).slice(1)
  if(b.length&1) console.log(b,f(b))
} 

산출

"." 1
":" 2
"..." 2
"..:" 1
".:." 3
".::" 2
":.." 3
":.:" 2
"::." 4
":::" 4
"....." 3
"....:" 2
"...:." 4
"...::" 4
"..:.." 2
"..:.:" 1
"..::." 3
"..:::" 2
".:..." 4
".:..:" 3
".:.:." 5
".:.::" 6
".::.." 3
".::.:" 2
".:::." 4
".::::" 4
":...." 4
":...:" 3
":..:." 5
":..::" 6
":.:.." 3
":.:.:" 2
":.::." 4
":.:::" 4
"::..." 5
"::..:" 4
"::.:." 6
"::.::" 8
":::.." 5
":::.:" 4
"::::." 6
":::::" 8

Pyth, 27 바이트

Jmhqd\:zu?*GhHteH+GhHctJ2hJ

스택? 스택이 필요한 사람

                       Implicit: z is the input string.
Jmhqd\:z               Transform the string into a list, 1 for . and 2 for :
                       Store it in J.
u            ctJ2hJ     Reduce over pairs of numbers in J, with the
                       first entry as initial value.
 ?    teH               Condition on whether the second number is 1 or 2.
  *GhH                  If 1, update running total to prior total times 1st num.
         +GhH           If 2, update running total to prior total plus 1nd num.

데모.

망막 , 105 75 73 바이트

나의 첫번째 Retina 프로그램! (처음으로 언어를 발명 한 것은 말할 것도없고 2 바이트를 절약 한 Martin Büttner에게 감사합니다.)

각 줄은 별도의 파일에 있어야합니다. 또는 파일을 모두 하나의 파일에 넣고 -s플래그를 사용할 수 있습니다 . <empty>표기법은 빈 파일 / 라인을 나타냅니다.

^(a+;)?\.
$1a;
^(a+;)?:
$1aa;
;(a+;)\.
$1
(a+);aa;:
$1$1;
)`;a;:
;
;
<empty>
a
1

mbomb007의 답변 에서 영감을 얻었 지만 다소 다른 접근법을 취합니다. 한 가지 큰 차이점은 스택의 상단이 오른쪽을 향하도록 dotty 문자열 앞에 스택을 작성한다는 것입니다. 이를 통해 심볼을 해당 숫자로 쉽게 변환 할 수 있습니다. 나는 a대신 1에 시퀀스를 모호하게 파싱하는 것을 피하기 위해 끝에 만 바꾸는 대신에를 사용 합니다 $1a. 같은 대답 aaaaaa이 단항으로 허용되는 경우 마지막 두 줄 / 파일을 제거하여 4 바이트를 절약 할 수 있습니다.

설명:

^(a+;)?\.
$1a;

스택 ( (a+;)?) 에 0 또는 1 개의 항목 이 있고 마침표 ( \.) 가 있으면 일치합니다 . 그렇다면 기간을로 바꿉니다 a;(즉, 1을 푸시합니다).

^(a+;)?:(.*)
$1aa;$2

스택에 0 개 또는 1 개의 항목이 있고 콜론이 있으면 일치합니다. 그렇다면 콜론으로 대체합니다 aa;(즉, 2를 누릅니다).

;(a+;)\.
$1

스택에 두 개의 항목이 있고 마침표가 있으면 일치합니다. 항목 사이의 기간과 세미콜론을 삭제하여 추가합니다.

(a+);aa;:
$1$1;

스택에 두 개의 항목이 있고 상단이 2이고 콜론이 오는 경우 일치합니다. 콜론과 2를 삭제하고 다른 숫자를 두 번 반복하여 2를 곱합니다.

)`;a;:
;

정규식은 스택에 두 개의 항목이있는 경우 일치하며 맨 위는 1이고 콜론이 뒤에옵니다. 콜론과 1을 삭제하고 다른 숫자는 변경하지 않습니다 (즉, 1을 곱한 값).

)`루프의 끝을 나타냅니다. 문자열을 변경 한 경우 제어는 프로그램 맨 위로 돌아가서 대체를 다시 실행합니다. 문자열 변경이 중지되면 모든 마침표와 콜론이 교체되고 남은 것은 정리입니다 ...

;
<empty>

남은 세미콜론을 삭제합니다.

a
1

모든 a를 1로 변환합니다. 단항 숫자에 기호를 사용할 수 있으면이 단계는 필요하지 않습니다.

녹, 170 자

fn f(s:String)->i32{let(mut a,mut b)=(-1,-1);for c in s.chars(){if b!=-1{a=match c{'.'=>a+b,':'=>a*b,_=>0};b=-1}else{b=match c{'.'=>1,':'=>2,_=>0};if a==-1{a=b;b=-1}};}a}

녹이 골프를 치르는 데 절대적으로 끔찍하다는 증거. 풀링되지 않은 코드 :

#[test]
fn it_works() {
    assert_eq!(dotty_ungolfed("::...:.:.".to_string()), 9);
    assert_eq!(f("::...:.:.".to_string()), 9);
}

fn dotty_ungolfed(program: String) -> i32 {
    let (mut a, mut b) = (-1, -1);
    for ch in program.chars() {
        if b != -1 {
            a = match ch { '.' => a + b, ':' => a * b, _ => panic!() };
            b = -1;
        } else {
            b = match ch { '.' => 1, ':' => 2, _ => panic!() };
            if a == -1 { a = b; b = -1; }
        }
    }
    a
}

fn f(s:String)->i32{let(mut a,mut b)=(-1,-1);for c in s.chars(){if b!=-1{a=match c{'.'=>a+b,':'=>a*b,_=>0};b=-1}else{b=match c{'.'=>1,':'=>2,_=>0};if a==-1{a=b;b=-1}};}a}

여기에 내가 사용한 재미있는 트릭이 있습니다. if / else 문에서 문자를 즉시 ​​버리는 값을 반환하여 문자를 제거 할 수 있습니다. 즉, 2 개 대신 하나의 세미콜론 만 필요합니다.

예를 들어

if foo {
    a = 42;
} else {
    doSomething(b);
}

로 변경할 수 있습니다

if foo {
    a = 42
} else {
    doSomething(b)
};

세미콜론을 제거하여 문자를 저장합니다.

하스켈, 88 81 79 바이트

(h:t)![p,q]|h=='.'=t![p+q]|1<2=t![p*q]
(h:t)!s|h=='.'=t!(1:s)|1<2=t!(2:s)
_!s=s

누군가가 Haskell 솔루션의 점수를 얻었을뿐만 아니라 솔루션이 내 것보다 짧습니다. 그것은 나쁘지만, 내가 생각해 낸 것을 게시하지 않을 이유가 없습니다.

APL (50)

APL은 스택 기반 언어가 아니기 때문에 여기서 큰 단점이 있습니다. 그래도 결국 프로그램을 단축하기 위해 축소를 남용해야했습니다.

{⊃{F←'.:'⍳⍺⋄2>⍴⍵:F,⍵⋄((⍎F⌷'+×')/2↑⍵),2↓⍵}/(⌽⍵),⊂⍬}

내부 함수는 왼쪽에서 '명령'과 오른쪽에서 스택을 가져 와서 적용하여 스택을 반환합니다. 외부 함수는 빈 스택부터 시작하여 문자열을 줄입니다.

설명:

• (⌽⍵),⊂⍬: 축소 할 초기 목록. ⊂⍬스택을 나타내는 박스형 빈 목록 (⌽⍵)은 입력의 반대입니다. (감소는 목록에서 오른쪽에서 왼쪽으로 적용되므로 문자열이 오른쪽에서 왼쪽으로 처리됩니다. 사전에 입력을 되 돌리면 문자가 올바른 순서로 적용됩니다.)

• {... }: 내부 기능. 오른쪽에있는 스택, 왼쪽에있는 문자를 가져와 수정 된 스택을 반환합니다.

  • F←'.:'⍳⍺: 문자열에서 문자의 색인 .:. 값에 따라 1 또는 2입니다.
  • 2>⍴⍵:F,⍵: 2가 현재 스택 크기보다 큰 경우 스택에 현재 값을 추가하십시오.
  • ⋄그렇지 않으면
    • 2↓⍵스택에서 맨 위 두 항목 제거
    • (... )/2↑⍵: 주어진 기능을 줄이고 스택에 추가합니다.
    • ⍎F⌷'+×': 기능이 +(가산) 또는 ×(곱셈) 중 하나로 선택됩니다 F.

• ⊃: 마지막으로 스택의 최상위 항목을 반환

루비-96 자

여기에 흥미로운 부분이 eval있습니다.

그 외에도 첫 번째 문자 뒤에 스택이 항상 2, math, 2, math, ...로 이동한다고 가정하고 있습니다. 이렇게하면 두 문자를 한 번에 잡아서 적은 코드를 사용할 수 있습니다. 문자가 수학인지 숫자인지를 나타냅니다. 위치 적입니다.

x,m=$<.getc>?.?2:1
(b,f=m.split //
b=b>?.?2:1
x=f ?eval("x#{f>?.??*:?+}b"):b)while m=gets(2)
p x

언 골프 드 :

bottom_of_stack = $<.getc > '.' ? 2 : 1 # if the first char is ., 1, else 2
two_dots = nil
while two_dots = gets(2) do # get the next 2 chars
  number_char, math_char = two_dots.split //
  number = number_char > '.' ? 2 : 1
  if math_char
    math = math_char > '.' ? '*' : '+'
    # so bottom_of_stack = bottom_of_stack + number ...
    # or bottom_of_stack = bottom_of_stack * number
    bottom_of_stack = eval("bottom_of_stack #{math} number")
  else
    # if there's no math_char, it means that we're done and 
    # number is the top of the stack
    # we're going to print bottom_of_stack, so let's just assign it here
    bottom_of_stack = number
  end
end
p bottom_of_stack  # always a number, so no need for `puts`

TI-BASIC, 78 73 70 69 66 바이트

Input Str1
int(e^(1=inString(Str1,":
For(A,2,length(Str1),2
Ans+sum({Ans-2,1,1,0},inString("::..:",sub(Str1,A,2
End
Ans

닫는 괄호는 선택 사항이므로 TI-BASIC은 한 줄짜리를 사용하는 것이 좋습니다. 반대로, 변수에 저장하는 데 2-4 바이트의 공간이 필요하기 때문에 여러 값을 저장해야하는 언어가 좋지 않습니다. 따라서 목표는 각 줄에 가능한 한 많이 쓰는 것입니다. TI-BASIC은 모든 종류의 문자열 조작에서 (토큰 화 된 언어의 경우) 끔찍합니다. 부분 문자열을 읽는 것조차 길다.

트릭에는 다음이 포함됩니다.

• int(e^([boolean]대신에 1+(boolean; 1 바이트를 절약
• 목록 슬라이싱 대신 목록의 부분 합계 (목록에 저장해야 함) : 3 바이트 저장

가기, 129 115 112 바이트

func m(s string){a,b:=0,0;for c,r:=range s{c=int(r/58);if b>0{a=a*b*c+(a+b)*(c^1);b=0}else{b,a=a,c+1}};print(a)}

(어떤) ungolfed :

func m(s string){
    // Our "stack"
    a, b := 0, 0
    // abusing the index asignment for declaring c
    for c, r := range s {
        // Ascii : -> 58, we can now use bit fiddeling
        c = int(r / 58)
        if b > 0 {
            // if r is :, c will be 1 allowing a*b to pass through, c xor 1 will be 0
            // if r is ., c xor 1 will be 1 allowing a+b to pass through
            a = a*b*c + (a+b)*(c^1)
            b = 0
        } else {
            b, a = a, c+1 // Since we already know c is 0 or 1
        }
    }
    print(a)
}

http://play.golang.org/p/B3GZonaG-y에서 온라인으로 사용해보십시오.

파이썬 3, 74

x,*s=[1+(c>'.')for c in input()]
while s:a,b,*s=s;x=[x*a,x+a][-b]
print(x)

먼저 입력 목록을 1과 2의 시퀀스로 변환하여 첫 번째 값을 초기 값으로 사용 x합니다. 그런 다음의 앞면에서 한 번에 두 개의 요소를 제거 s하여 첫 번째 숫자를 취하고 두 번째 숫자가 1인지 2인지에 따라 현재 숫자를 더하거나 곱합니다.

음, 이것은 매우 쉬운 조작이며 op에 의해 정교합니다 (의도적으로)

그건 그저 ...

괄호로 묶은 표현식은 접두사 * / + 연산으로 변환됩니다.

코드 : C (80 바이트)

int f(char*V){return*(V-1)?f(V-2)*(*V==58?*(V-1)/29:1)+(*V&4)/4**(V-1)/29:*V/29;}

• 이 함수는 다음과 같이 문자열 꼬리에서 호출해야합니다. f (V + 10) 여기서 V = ". : .. :. : .. ::"

입력

char '.'유형의 length = 2n + 1 벡터 V 또는 ':'

산출

정수 k

기능

• k = (V [1] op (V [3]) V [2]) op (V [5]) V [4] ....

• op (x) : (x = '.')-> +, (x = ':')-> *

시뮬레이션:

그것을 시도 여기

망막 181 135 129 바이트

각 줄은 별도의 파일에 있어야합니다. <empty>빈 파일을 나타냅니다. 출력은 단항입니다.

^\..*
$&1;
^:.*
$&11;
^.
<empty>
(`^\..*
$&1
^:.*
$&11
^.(.*?1+;1+)
$1
^(\..*);(1+)
$1$2;
;1$
;
^(:.*?)(1+).*
$1$2$2;
)`^.(.*?1+;)
$1
;
<empty>

${0}1가 사용될 때 중괄호는 $0에서 일치하고 1그렇지 않으면 $01첫 번째 일치 그룹이됩니다. 을 사용하려고 시도했지만 $001정규식의 .NET 버전에서는 작동하지 않는 것 같습니다.

편집 : $&와 같은 것을 발견했습니다 $0.

의사 코드에서 이것은 아래에서 볼 수 있듯이 본질적으로 do-while 루프입니다. 첫 번째 숫자를 누른 다음 루프 : 두 번째 숫자를 누르고 연산 (명령)을 제거하고 수학을 수행하고 op를 제거하십시오. 루핑을 계속하십시오. 작업이 팝업되면 모든 지침이 완료된 후 공간도 제거됩니다.

댓글 :

^\..*           # Push if .
$&1;
^:.*            # Push if :
$&11;
^.              # Pop op
<empty>


(`^\..*         # Loop, Push #
$&1
^:.*
$&11
^.(.*?1+;1+)    # Pop op
$1


^(\..*);(1+)    # Add if . (move ;)
$1$2;
;1$          # If mul by 1, remove
;
^(:.*?)(1+).*   # Mul if : (double)
$1$2$2;
)`^.(.*?1+;)    # Pop op, End Loop (clean up)
$1
;               # Remove semicolon
<empty>

파이썬 3, 122 바이트

x=input()
l=[0,0]
for _ in x:
 t=len(l)-2<2
 l=[[[0,0,l[-2]*l[-1]],l+[2]][t],[[0,0,sum(l)],l+[1]][t]][_=='.']
print(l[-1])

언 골프 드 :

x = input()
l = []
for i in x:
    if i == '.':
        if len(l) < 2: 
            l+=[1]        #True, True = 1,1
        else:
            l=[sum(l)]    #True, True = 1,0
    else:
        if len(l)<2:
            l+=[2]        #False, True = 0,1
        else:
            l=[l[0]*l[1]] #False, False = 0,0
print (l[0])

파이썬에서는 다음과 같이 목록의 색인을 참조합니다.

list[index]

부울 값을 Trueis 1and Falseis에 넣을 수 있습니다 0.

# t is True if the length is less than 2, else false.

l=[ 

  # |------- Runs if char is : -------|
  # |------- l<2 -------| |- l>=2 -|

    [ [ 0,0, l[-2]*l[-1] ], l+[2] ] [t],

                                      # |---- Runs if char is . ----| 
                                      # |--- l<2 ---|  |- l>=2 -|

                                        [ [0,0, sum(l)], l+[1] ] [t] ]
                                                                      [_=='.']

여기에서 온라인으로 사용해보십시오

펄, 77 바이트

@o=(0,'+','*');sub d{$_=shift;y/.:/12/;eval'('x s!\B(.)(.)!"$o[$2]$1)"!ge.$_}

넓히는:

@o=(0, '+', '*');
sub d{
    $_=shift;
    y/.:/12/;
    eval '(' x s!\B(.)(.)!"$o[$2]$1)"!ge.$_
}

@o배열은 사업자에게 자리를 매핑합니다. 그런 다음 숫자 쌍을 적절한 연산자로 바꾸고 순서를 바꿉니다. 정규 표현식으로 시작하여 \B첫 번째 문자와 일치하지 않습니다. 결과 s///g는 처음에 얼마나 많은 열린 양모가 필요한지 알려줍니다. 그런 다음 전체 삽입 식을 어셈블하면이를 평가할 수 있습니다. ( eval대신 표현식을 보려면 제거하십시오 ).

결과를 확인하는 데 사용한 테스트 장치는 다음과 같습니다.

while(<>) {
    my ($a, $b) = m/(.*) (.*)/;
    print d($a), " $b\n";
}

입력은 dotty 표현식 및 해당 값 (질문에 제공됨)의 목록이며 출력은 {actual, expect}의 쌍입니다.