Nhiệm vụ của bạn - nếu bạn chọn chấp nhận nó - là xây dựng một chương trình phân tích và đánh giá một chuỗi (từ trái sang phải và độ dài tùy ý) của các mã thông báo đưa ra chỉ dẫn - trái hoặc phải. Dưới đây là bốn mã thông báo có thể và ý nghĩa của chúng:

>  go right one single step
<  go left one single step
-> go right the total amount of single steps that you've gone right, plus one,
   before you previously encountered this token and reset this counter to zero
<- go left the total amount of single steps that you've gone left, plus one,
   before you previously encountered this token and reset this counter to zero

Mặc dù có một nhược điểm - mã thông báo chỉ đường mà chương trình của bạn có thể phân tích cú pháp sẽ được trình bày theo mẫu này:

<<->-><<->->>->>->

... Nói cách khác, chúng được nối với nhau và nhiệm vụ của chương trình là tìm ra mức độ ưu tiên chính xác của các hướng và số lượng bước cần thực hiện (bằng cách nhìn về phía trước). Thứ tự ưu tiên như sau (từ ưu tiên cao nhất đến thấp nhất):

1. ->
2. <-
3. >
4. <

Nếu bạn gặp phải <-khi không có bước bên trái nào được thực hiện trước đó kể từ khi bắt đầu hoặc kể từ lần đặt lại cuối cùng, hãy thực hiện một bước duy nhất ở bên trái. Quy tắc tương tự áp dụng cho ->, nhưng sau đó để đi bên phải.

Chương trình của bạn nên bắt đầu từ 0 và kết quả của nó phải là số nguyên được ký biểu thị vị trí kết thúc cuối cùng.

Bạn có thể mong đợi đầu vào luôn hợp lệ ( <--->>--<ví dụ , chẳng có gì giống như vậy ).

Ví dụ đầu vào:

><->><-<-><-<>>->

Các bước trong ví dụ này:

 step | token | amount | end position
------+-------+--------+--------------
   1. |   >   |     +1 |           1  
   2. |   <   |     -1 |           0  
   3. |  ->   |     +2 |           2  
   4. |   >   |     +1 |           3  
   5. |   <-  |     -2 |           1  
   6. |   <   |     -1 |           0  
   7. |  ->   |     +2 |           2  
   8. |   <-  |     -2 |           0  
   9. |   <   |     -1 |          -1  
  10. |   >   |     +1 |           0  
  11. |   >   |     +1 |           1  
  12. |  ->   |     +3 |           4  

Để làm rõ: đầu ra của chương trình chỉ nên là vị trí kết thúc cuối cùng dưới dạng một số nguyên đã ký. Bảng trên chỉ ở đó để minh họa các bước mà ví dụ của tôi đã thực hiện. Không cần phải xuất ra một bảng, hàng bảng hoặc thậm chí chỉ các vị trí cuối của các bước. Chỉ có vị trí kết thúc cuối cùng, như một số nguyên đã ký, là bắt buộc.

Mã ngắn nhất, sau một tuần, chiến thắng.

GolfScript, 46 ký tự

'->'/')'*.'<-'-.')'/);+,\'>)'-.'<-'/);\'-'-+,-

Đây là một trong những chương trình GolfScript tuyến tính nhất mà tôi từng viết - không có một vòng lặp, gán điều kiện hoặc biến đổi trong đó. Mọi thứ được thực hiện bằng cách sử dụng thao tác chuỗi:

• Trước tiên, tôi thay thế mỗi lần xuất hiện của ->bằng ). Vì đầu vào được đảm bảo là hợp lệ, điều này đảm bảo rằng mọi sự xuất hiện còn lại -phải là một phần của <-.

• Tiếp theo, tôi tạo hai bản sao của chuỗi. Từ bản sao đầu tiên, tôi xóa các ký tự <và -, chỉ để lại >và ). Sau đó, tôi sao chép kết quả, xóa tất cả các )s và mỗi lần >theo sau )từ bản sao thứ hai, nối chúng và đếm các ký tự. Do đó, trong thực tế, tôi đang đếm:

  • +1 cho mỗi ),
  • +1 cho mỗi >lần cuối cùng )và
  • +2 cho mỗi >trước khi cuối cùng ).

• Tiếp theo, tôi làm tương tự cho các bản sao khác, ngoại trừ đếm thời gian này <và <-thay vì >và ), và loại bỏ các -s trước khi đếm ký tự cuối cùng. Vì vậy, tôi tính:

  • +1 cho mỗi <-,
  • +1 cho mỗi <lần cuối cùng <-và
  • +2 cho mỗi <trước khi cuối cùng <-.

• Cuối cùng, tôi trừ đi số thứ hai từ số thứ nhất và xuất kết quả.

Python 2.7 - 154 147 134 128 byte

l=r=p=0
exec"exec raw_input('%s->','p+=r+1;r=0%s<-','p-=l+1;l=0%s>','r+=1;p+=1%s<','l+=1;p-=1;')"%((";').replace('",)*4)
print p

Những thay đổi nghiêm trọng đã được thực hiện theo cách chương trình này hoạt động. Tôi đã xóa lời giải thích cũ, vẫn có thể tìm thấy trong lịch sử chỉnh sửa của câu trả lời này.

Đây là tổng số.

Nó hoạt động khá giống với các câu trả lời khác cho câu hỏi này, thay thế các ký tự trong đầu vào bằng các câu lệnh hợp lệ trong ngôn ngữ đó và thực hiện chúng. Tuy nhiên, có một sự khác biệt lớn: replacelà một từ dài. Kệ đời nó.

@ProgrammerDan trong trò chuyện đã nảy ra ý tưởng sử dụng một tuple với chuỗi ;').replace('trong đó 4 lần, để sử dụng str.format()phương pháp định dạng trước văn bản. Bốn trường hợp %snằm trong chuỗi trên dòng thứ hai, mỗi trường hợp lấy giá trị của nó từ phần tử liên kết của bộ dữ liệu ở cuối. Vì tất cả đều giống nhau, mỗi cái %sđược thay thế bằng ;').replace('. Khi bạn thực hiện các thao tác, bạn nhận được chuỗi này:

exec raw_input(';').replace('->','p+=r+1;r=0;').replace('<-','p-=l+1;l=0;').replace('>','r+=1;p+=1;').replace('<','l+=1;p-=1;')

Đây là mã python hợp lệ có thể được thực thi với exec. Đúng vậy, em yêu: Nested execs cho tôi sử dụng các hoạt động chuỗi trên mã cần thực hiện các hoạt động chuỗi trên mã . Ai đó làm ơn giết tôi đi.

Phần còn lại của nó khá đơn giản: Mỗi lệnh được thay thế bằng mã theo dõi ba biến: Vị trí hiện tại, số lượng quyền kể từ cuối cùng ->và tương tự đối với lefts và <-. Toàn bộ điều được chạy và vị trí được in.

Bạn sẽ nhận thấy rằng tôi làm raw_input(';'), sử dụng ';' như một dấu nhắc, thay vì raw_input()không có dấu nhắc. Điều này lưu các ký tự theo một cách không trực quan: Nếu tôi đã làm raw_input(), tôi phải có bộ dữ liệu đầy ).replace(', và mọi trường hợp %ssẽ có '; \' 'trước nó trừ cái đầu tiên . Có một dấu nhắc tạo ra nhiều dư thừa để tôi có thể lưu nhiều ký tự hơn.

Perl, 134 131 ... 99 95 byte

sub f{$p+=$d;$&=~/-/?($p+=$s,$s=0):($s+=$d)}$_=<>;$d=1;s/-?>/f/eg;$s=0;$d=-1;s/<-?/f/eg;print$p

Đưa đầu vào dưới dạng một dòng trên stdin, ví dụ:

ski@anito:~$ perl -le 'sub f{$p+=$d;$&=~/-/?($p+=$s,$s=0):($s+=$d)}$_=<>;$d=1;s/-?>/f/eg;$s=0;$d=-1;s/<-?/f/eg;print$p'
><->><-<-><-<>>->
4

hoặc là:

ski@anito:~$ echo "><->><-<-><-<>>->" | perl -le 'sub f{$p+=$d;$&=~/-/?($p+=$s,$s=0):($s+=$d)}$_=<>;$d=1;s/-?>/f/eg;$s=0;$d=-1;s/<-?/f/eg;print$p'
4

Tôi chia các hướng dẫn thành toán tử "phải" (">" và "->") và toán tử "trái" ("<" và "<-"). Ưu điểm của điều này là việc khai thác song song giữa các toán tử trái và phải dễ dàng hơn và chúng ta không phải làm bất cứ điều gì lạ mắt để token hóa chuỗi. Mỗi "hướng" được xử lý như một thao tác thay thế trong đó chúng ta điều chỉnh tổng số chạy theo số bước được thực hiện theo hướng đó, bỏ qua hướng ngược lại được thực hiện bởi thao tác thay thế khác. Đây là một tổ tiên ít chơi gôn của mã này như một loại tài liệu:

sub f {
  $dir=shift;
  if($1 =~ /-/) {
    $pos+=$side+$dir;
    $side=0;
  } else {
    $pos+=$dir;
    $side+=$dir;
  }
}

$_=<>;

s/(-?>)/f(1)/eg;
$side=0;
s/(<-?)/f(-1)/eg;

print $pos

Trong lần lặp lại trước của mã này, tất cả các thay thế đều được thực hiện trong một lần. Điều này có lợi thế là giữ ánh xạ trực tiếp giữa $ p / $ pos và vị trí sẽ được trả về tại bất kỳ thời điểm nào, nhưng mất nhiều byte mã hơn.

Nếu bạn muốn sử dụng () 5.10.0, bạn có thể s / print / say / để loại bỏ 2 ký tự khác, nhưng đó không thực sự là phong cách của tôi.

Perl, 88 77 byte

$_=<>;print s/->/F/g+2*s/>(?=.*F)//g+s/>//g-(s/<-/B/g+2*s/<(?=.*B)//g+s/<//g)

Đầu vào được mong đợi thông qua STDIN, ví dụ:

echo '><->><-<-><-<>>->'|perl -e '$_=<>;print s/->/F/g+2*s/>(?=.*F)//g+s/>//g-(s/<-/B/g+2*s/<(?=.*B)//g+s/<//g)'
4

Cập nhật

Không cần phải chuyển đổi chuỗi thành tổng, vì s//đã được tính. :-)

Phiên bản đầu tiên

$_=<>;s/->/+1/g;s/>(?=.*1)/+2/g;s/>/+1/g;s/<-/-1/g;s/<(?=.*-)/-2/g;s/</-1/g;print eval

Đầu vào được mong đợi thông qua STDIN, ví dụ:

echo '><->><-<-><-<>>->'|perl -e '$_=<>;s/->/+1/g;s/>(?=.*1)/+2/g;s/>/+1/g;s/<-/-1/g;s/<(?=.*-)/-2/g;s/</-1/g;print eval'
4

Giải trình:

Ý tưởng là chuyển đổi chuỗi hướng thành một tổng để sao cho kết quả là đầu ra đơn giản print eval.

>trước khi ->thực hiện hai bước, một bước và bước tiếp theo ->. Nó không quan trọng, cái nào ->trong khi nó đi theo ít nhất một trong số chúng. Bộ đếm nội bộ được đặt lại sau lần tiếp theo ->, do đó >không gây ra các bước tiếp theo, tối đa là hai bước. Sau đó ->thêm một bước cho chính nó và do đó, làm bất kỳ còn lại >sau cuối cùng ->.

Điều tương tự giữ cho hướng ngược với tiêu cực thay vì đếm bước tích cực.

Ví dụ: ><->><-<-><-<>>->

s/->/+1/: Bắt đầu với hướng chuyển tiếp, bởi vì ->có quyền ưu tiên cao nhất.
Ví dụ:><+1><-<+1<-<>>+1

s/>(?=.*1)/+2/g: Mẫu nhìn về phía trước đảm bảo rằng chỉ >trước khi bất kỳ ->được chuyển đổi.
Ví dụ:+2<+1+2<-<+1<-<+2+2+1

s/>/+1/g: Bây giờ phần còn lại >được bảo hiểm.
Ví dụ:+2<+1+2<-<+1<-<+2+2+1

s/<-/-1/g: Tương tự hướng ngược.
Ví dụ:+2<+1+2-1<+1-1<+2+2+1

s/<(?=.*-)/-2/g: Trong mẫu nhìn về phía trước, toàn bộ -1trước đây <-là không cần thiết, bởi vì không có -biểu tượng hướng còn lại.
Ví dụ:+2-2+1+2-1-2+1-1<+2+2+1

s/</-1/g: Phần còn lại <sau khi cuối cùng <-được chuyển đổi.
Ví dụ:+2-2+1+2-1-2+1-1-1+2+2+1

print eval: Tính toán và đưa ra kết quả.
Ví dụ:4

Ruby, 141 byte

l=1;r=1;o=0
gets.gsub('->',?R).gsub('<-',?L).chars{|c|case c
when'<';o-=1;l+=1
when'>';o+=1;r+=1
when'L';o-=l;l=1
when'R';o+=r;r=1
end}
$><<o

Ung dung:

parsed = gets.gsub('->', 'R')
             .gsub('<-', 'L')
countL = 1
countR = 1
result = 0
parsed.each_char do |c|
    case c
    when '<'
        result -= 1
        countL += 1
    when '>'
        result += 1
        countR += 1
    when 'L'
        result -= countL
        countL = 1
    when 'R'
        result += countR
        countR = 1
    end
end
puts result

D - 243

Golfed :

import std.regex,std.stdio;void main(string[]a){int s,c,v;auto t=a[1].matchAll("->|<-(?!>)|>|<".regex);foreach(m;t){auto r=m.hit;if(r=="->"){s+=c+1;c=0;}else if(r=="<-"){s-=v+1;v=0;}else if(r==">"){++s;++c;}else if(r=="<"){--s;++v;}}s.write;}}

Chưa chơi gôn :

import std.regex, std.stdio;

void main( string[] a )
{
    int s, c, v;
    auto t = a[1].matchAll( "->|<-(?!>)|>|<".regex );

    foreach( m; t )
    {
        auto r = m.hit;

        if( r == "->" )
        {
            s += c + 1;
            c = 0;
        }
        else if( r == "<-" )
        {
            s -= v + 1;
            v = 0;
        }
        else if( r == ">" )
        {
            ++s;
            ++c;
        }
        else if( r == "<" )
        {
            --s;
            ++v;
        }
    }

    s.write;
}

C, 148 141 140

140:

r,l,o;main(char *x,char **v){for(x=v[1];*x;x++)(*x^45)?(*x^60)?(r++,o++):(*(x+1)==45)?(x++,o-=l+2,l=0):(o--,l++):(o+=r+1,r=0,x++);return o;}

141:

r,l,o;main(char *x,char **v){for(x=v[1];*x;x++)(*x^45)?(*x^60)?(r++,o++):(*(x+1)==45)?(x++,o=o-l-2,l=0):(o--,l++):(o+=r+1,r=0,x++);return o;}

148:

r,l,o;main(char *x,char **v){for(x=v[1];*x;x++){if(*x^45){if(*x^60)r++,o++;else{o--,l++;if(*(x+1)==45)x++,o-=l,l=0;}}else o+=r+1,r=0,x++;}return o;}

Với khoảng trắng:

r,l,o;
main(char *x,char **v) 
{
    for(x=v[1];*x;x++)
    (*x^45) ?
        (*x^60) ?
            (r++,o++)
            :
            (*(x+1)==45) ?
                (x++,o-=l+2,l=0)
            :(o--,l++)
        :(o+=r+1,r=0,x++);
    return o;
}

Có lẽ rất nhiều phòng để chơi golf này. Tôi chủ yếu từ bỏ việc cố gắng thao túng 4 biến trong các ternary đã bắt được các giá trị (nó tiếp tục xuất hiện lâu hơn và nhận được sau này), nhưng không phải là một đường chuyền xấu đầu tiên. Khá vượt qua mảng thẳng. Lấy đầu vào làm đối số dòng lệnh, xuất ra thông qua giá trị trả về.

Bạn sẽ cần -std=c99cờ để biên dịch nó với gcc.

EDIT: Đúng, muộn rồi - đã bỏ lỡ một số thứ rõ ràng.

JavaScript, 136

z=0;l=r=1;c=["--z;++l;",/</g,"++z;++r;",/>/g,"z-=l;l=1;",/<-/g,"z+=r;r=1;",/->/g];for(a=8;a--;s=s.replace(c[a--],c[a]));eval(s);alert(z)

Chưa hoàn thành:

s="><->><-<-><-<>>->";
z=0;
l=r=1;
c=[
    "--z;++l;", /</g,
    "++z;++r;", />/g,
    "z-=l;l=1;", /<-/g,
    "z+=r;r=1;", /->/g
];
for(a=8;a--;s=s.replace(c[a--],c[a]));
eval(s);
alert(z) // Output (4)

Làm thế nào nó hoạt động

Đưa ra một đầu vào chuỗi snhư vậy:

s="><->><-<-><-<>>->";

Nó sử dụng một Regex để thay thế mỗi lệnh bằng một tập lệnh hướng dẫn sửa đổi z(vị trí kết thúc), l(lưu trữ bên trái) và rlưu trữ bên phải. Mỗi Regex được thực hiện theo thứ tự ưu tiên.

Đối với đầu vào ở trên, chuyển đổi sthành:

"++z;++r;--z;++l;z+=r;r=1;++z;++r;z-=l;l=1;--z;++l;z+=r;r=1;z-=l;l=1;--z;++l;++z;++r;++z;++r;z+=r;r=1;"

Khá, không phải thế.

Cuối cùng, chúng tôi eval(s)thực hiện các hướng dẫn và cảnh báo zcó chứa vị trí kết thúc.

Javascript (116, 122 , 130 )

116:

for(l=r=p=i=0;c='<>-0'.indexOf(a.replace(/->/g,0)[i++])+1;p--)c-4?c-3?c-2?l++:(r++,p+=2):(p-=l-2,l=0):(p+=r+2,r=0);p

122:

for(l=r=p=i=0,a=a.replace(/->/g,0);c='<>-0'.indexOf(a[i])+1;i++,p--)c-4?c-3?c-2?l++:(r++,p+=2):(p-=l-2,l=0):(p+=r+2,r=0);p

130:

for(l=r=p=i=0;c='<>-'.indexOf(a[i])+1;i++,p--)c-3?c-1?(r++,p+=2):a[i+1]=='-'?a[i+2]=='>'?l++:(p-=l,l=0,i++):l++:(p+=r+2,r=0,i++);p

JavaScript [217 byte]

prompt(x=l=r=0,z='replace',f='$1 $2 ')[z](/(>.*?)(->)/g,f)[z](/(<.*?)(<-)/g,f)[z](/(<|>)(<|>)/g,f)[z](/<-?|-?>/g,function(c){c=='>'&&(x++,r++),c=='<'&&(x--,l++),c=='->'&&(x+=++r,r*=0),c=='<-'&&(x-=++l,l*=0)}),alert(x)

Có lẽ nó có thể được rút ngắn thêm một chút ...

PHP 284 282

Không có regex.

$i=fgets(STDIN);$c=$a=0;$s=str_split($i);while($c<count($s)){switch($s[$c]){case"<":if($s[$c+1]=="-"){if($s[$c+2]==">"){$c+=3;$a+=$rr;$rr=0;$ll++;}else{$c+=2;$a+=-($ll+1);$ll=0;}}else{$c++;$a--;$ll++;}break;case">":$c++;$a++;$rr++;break;case"-":$c+=2;$a+=$rr+1;$rr=0;break;}}echo$a;

Ung dung:

$i=fgets(STDIN);
$c=$a=0;
$s=str_split($i);
while($c<count($s)){
    switch($s[$c]){
    case "<":
        if($s[$c+1]=="-"){
            if($s[$c+2]==">"){
                $c+=3;$a+=$rr;$rr=0;$ll++;
            }
            else{
                $c+=2;$a+=-($ll+1);$ll=0;
            }
        }
        else{
            $c++;$a--;$ll++;
        }
    break;
    case ">":
        $c++;$a++;$rr++;
        break;
    case "-":
        $c+=2;$a+=$rr+1;$rr=0;
        break;
    }
}
echo $a;

Một giải pháp perl khác, 113 ký tự

Đã có hai câu trả lời đánh bại điều này, nó chỉ dành cho những tiếng cười khúc khích. Nó sử dụng một cách tiếp cận dựa trên quan sát của Ilmari về giá trị của các mã thông báo:

$_=<>;chomp;s/->/#/g;s/<-/%/g;s/>(?=.*#)/?/g;s/<(?=.*%)/;/g;s/#/>/g;s/%/</g;$t+=ord for split//;print$t-61*length

Phát nổ một chút:

$_=<>;
chomp;
s/->/#/g;
s/<-/%/g;
s/>(?=.*#)/?/g;
s/<(?=.*%)/;/g;
s/#/>/g;
s/%/</g;
$t+=ord for split//;
print$t-61*length