งานของคุณ - หากคุณเลือกที่จะยอมรับมัน - คือการสร้างโปรแกรมที่แยกวิเคราะห์และประเมินสตริง (จากซ้ายไปขวาและความยาวตามอำเภอใจ) ของโทเค็นที่ให้ทิศทาง - ซ้ายหรือขวา ต่อไปนี้เป็นโทเค็นที่เป็นไปได้ทั้งสี่และความหมาย:

>  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

มีข้อสรุปว่า - โทเค็นของเส้นทางที่โปรแกรมของคุณควรจะแยกวิเคราะห์จะถูกนำเสนอในรูปแบบนี้:

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

... กล่าวอีกนัยหนึ่งมันถูกต่อกันและมันเป็นหน้าที่ของโปรแกรมของคุณในการหาลำดับความสำคัญของทิศทางที่ถูกต้องและจำนวนของขั้นตอนที่ต้องดำเนินการ (โดยมองไปข้างหน้า) ลำดับความสำคัญมีดังต่อไปนี้ (จากลำดับความสำคัญสูงสุดไปต่ำสุด):

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

หากคุณพบ<-เมื่อก่อนหน้านี้ไม่มีขั้นตอนทางด้านซ้ายตั้งแต่เริ่มต้นหรือตั้งแต่รีเซ็ตล่าสุดให้ทำขั้นตอนเดียวไปทางซ้าย ใช้กฎเดียวกันกับ->แต่จากนั้นไปทางขวา

โปรแกรมของคุณควรเริ่มต้นที่ 0 และผลลัพธ์ควรเป็นจำนวนเต็มที่ลงนามแทนตำแหน่งสุดท้าย

คุณอาจคาดหวังว่าอินพุตจะถูกต้องเสมอ (เช่นไม่มีอะไรที่เหมือน<--->>--<)

อินพุตตัวอย่าง:

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

ขั้นตอนในตัวอย่างนี้:

 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  

สำหรับการชี้แจง: ผลลัพธ์ของโปรแกรมควรเป็นตำแหน่งสิ้นสุดสุดท้ายเป็นจำนวนเต็มที่ลงนามแล้ว ตารางด้านบนมีไว้เพื่อแสดงขั้นตอนตัวอย่างของฉัน ไม่จำเป็นต้องแสดงผลเช่นตารางแถวของตารางหรือแม้แต่ตำแหน่งสิ้นสุดขั้นตอน ต้องระบุตำแหน่งสุดท้ายเท่านั้นในฐานะเลขจำนวนเต็มที่ลงนาม

รหัสที่สั้นที่สุดหลังจากหนึ่งสัปดาห์จะชนะ

GolfScript, 46 ตัวอักษร

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

นี่เป็นหนึ่งในโปรแกรม GolfScript เชิงเส้นส่วนใหญ่ที่ฉันเคยเขียน - มันไม่มีการวนซ้ำแบบมีเงื่อนไขเงื่อนไขหรือตัวแปรในนั้น ทุกอย่างเสร็จสิ้นโดยใช้การจัดการสตริง:

• ครั้งแรกผมเปลี่ยนการเกิดขึ้นของทุกคนโดย-> )ตั้งแต่การป้อนข้อมูลที่รับประกันได้ว่าจะถูกต้องเพื่อให้แน่ใจว่าการใด ๆ ที่เกิดขึ้นที่เหลืออยู่ของต้องเป็นส่วนหนึ่งของ-<-

• ต่อไปฉันสร้างสตริงสองชุด จากสำเนาแรกผมเอาตัวละคร<และ-เหลือเพียงและ> )จากนั้นฉันก็ทำซ้ำผลลบทั้งหมด)และทุก>ครั้งสุดท้าย)จากสำเนาที่สองต่อกันและนับจำนวนตัวอักษร ดังนั้นฉันจึงนับ:

  • +1 สำหรับแต่ละรายการ ) ,
  • +1 สำหรับแต่ละรายการ>หลังสุด)และ
  • 2 สำหรับแต่ละก่อนสุดท้าย>)

• ถัดไปฉันทำแบบเดียวกันกับสำเนาอื่นยกเว้นเวลานี้นับ<และ<-แทน>และ)และลบ-s ก่อนที่จะนับตัวอักขระสุดท้าย ดังนั้นฉันนับ:

  • +1 สำหรับแต่ละรายการ <- ,
  • +1 สำหรับแต่ละรายการ <หลังสุด<-และ
  • 2 สำหรับแต่ละก่อนสุดท้าย<<-

• ในที่สุดฉันก็ลบจำนวนที่สองออกจากอันแรกแล้วเอาผลลัพธ์ออกมา

Python 2.7 - 154 147 134 128 ไบต์

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

มีการเปลี่ยนแปลงอย่างจริงจังกับวิธีการทำงานของโปรแกรมนี้ ฉันได้ลบคำอธิบายเก่าซึ่งยังสามารถพบได้ในประวัติการแก้ไขคำตอบนี้

ขั้นต้นของคนนี้

มันทำงานในลักษณะเดียวกับคำตอบอื่น ๆ สำหรับคำถามนี้แทนที่อักขระในอินพุตด้วยข้อความสั่งที่ถูกต้องในภาษานั้นและเรียกใช้งานพวกเขา มีความแตกต่างที่สำคัญอย่างหนึ่งแม้ว่า: replaceเป็นคำที่ยาว สกรูที่

@ProgrammerDan ในการแชทเกิดขึ้นกับแนวคิดของการใช้ tuple กับสตริง;').replace('ในนั้น 4 ครั้งเพื่อใช้str.format()วิธีการก่อนการจัดรูปแบบข้อความ อินสแตนซ์ของสี่%sอยู่ในสายอักขระบนบรรทัดที่สองแต่ละอันรับค่าจากองค์ประกอบที่เกี่ยวข้องของ tuple ที่สิ้นสุด เนื่องจากพวกเขากำลังทั้งหมดเดียวกันแต่ละจะถูกแทนที่ด้วย%s ;').replace('เมื่อคุณทำการดำเนินการคุณจะได้รับข้อความนี้:

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;')

ตอนนี้นี่เป็นรหัสไพ ธ อนที่ถูกต้องที่สามารถดำเนินการexecได้ ที่เหมาะสมทารก: ซ้อนexecs ให้ฉันใช้การดำเนินงานสตริงในรหัสที่ตอบสนองความต้องการในการดำเนินการสตริงรหัส มีคนฆ่าฉันที

ส่วนที่เหลือมันค่อนข้างตรงไปตรงมา: แต่ละคำสั่งจะถูกแทนที่ด้วยโค้ดที่ติดตามตัวแปรสามตัว: ตำแหน่งปัจจุบันจำนวนสิทธินับตั้งแต่ครั้งสุดท้าย -><-และเหมือนกันสำหรับการทักทายและ ทุกอย่างทำงานและตำแหน่งจะถูกพิมพ์

คุณจะสังเกตเห็นว่าฉันraw_input(';')ใช้ ';' เป็นพรอมต์มากกว่าraw_input()ที่ไม่มีพรอมต์ นี้ช่วยประหยัดตัวละครในทาง unintuitive: ถ้าผมทำraw_input()ผมจะต้องมี tuple ที่เต็มไปด้วย).replace('และตัวอย่างของทุก%sจะมี '; \'' ก่อนที่จะยกเว้นคนแรก การมีพรอมต์สร้างความซ้ำซ้อนมากขึ้นเพื่อให้ฉันสามารถบันทึกตัวละครโดยรวมได้มากขึ้น

Perl, 134 131 ... 99 95 ไบต์

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

รับอินพุตเป็นบรรทัดเดียวบน stdin เช่น:

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

หรือ:

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

ฉันแบ่งคำแนะนำออกเป็นตัวดำเนินการ "ขวา" (">" และ "->") และตัวดำเนินการ "ซ้าย" ("<" และ "<-") ข้อดีของการทำเช่นนี้คือการใช้ประโยชน์จากความเท่าเทียมกันระหว่างตัวดำเนินการด้านซ้ายและด้านขวาได้ง่ายขึ้นและเราไม่ต้องทำอะไรแฟนซีเพื่อโทเค็นสตริง "ทิศทาง" แต่ละครั้งจะได้รับการจัดการเป็นการดำเนินการทดแทนซึ่งเราปรับผลรวมการวิ่งตามจำนวนขั้นตอนที่ดำเนินการในทิศทางนั้นโดยไม่สนใจทิศทางย้อนกลับซึ่งได้รับการดูแลโดยการดำเนินการทดแทนอื่น ๆ นี่คือบรรพบุรุษที่น้อยกว่าของรหัสนี้เป็นเอกสารประกอบ:

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

ในการย้ำรหัสก่อนหน้านี้การแทนที่ถูกทำในครั้งเดียว สิ่งนี้มีความได้เปรียบในการคงการจับคู่โดยตรงระหว่าง $ p / $ pos และตำแหน่งที่จะถูกส่งคืน ณ จุดใดก็ตามในเวลา แต่รับรหัสไบต์เพิ่มขึ้น

หากคุณต้องการใช้ () 5.10.0 คุณสามารถ s / พิมพ์ / พูด / เพื่อโกนหนวดอีก 2 ตัวละครนับ แต่นั่นไม่ใช่สไตล์ของฉัน

Perl, 88 77 ไบต์

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

คาดว่าจะมีการป้อนข้อมูลผ่าน STDIN เช่น:

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

ปรับปรุง

ไม่จำเป็นต้องแปลงสตริงเป็นผลรวมเนื่องจากs//มีการนับแล้ว :-)

รุ่นแรก

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

คาดว่าจะมีการป้อนข้อมูลผ่าน STDIN ตัวอย่าง:

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

คำอธิบาย:

print evalความคิดที่จะแปลงสตริงทิศทางบวกเข้าไปเพื่อให้ผลที่ได้คือการส่งออกโดยง่าย

>ก่อนที่->จะใช้เวลาสองขั้นตอนหนึ่งในครั้งเดียวและอื่น ๆ ->ที่ต่อไป มันไม่สำคัญซึ่งใน->ขณะนั้นจะติดตามอย่างน้อยหนึ่งในนั้น ตัวนับภายในจะถูกรีเซ็ตหลังจากถัดไป->จึง>ไม่ทำให้เกิดขั้นตอนเพิ่มเติมสูงสุดคือสองขั้นตอน จากนั้น->เพิ่มหนึ่งขั้นตอนสำหรับตัวเองและทำสิ่งที่เหลืออยู่>หลังจากขั้นตอนสุดท้าย->หลังจากที่ผ่านมา

ทิศทางเดียวกันกับทิศทางด้านหลังด้วยค่าลบแทนที่จะนับเป็นค่าบวก

เช่น: ><->><-<-><-<>>->

s/->/+1/: เริ่มต้นด้วยทิศทางไปข้างหน้าเพราะ->มีความสำคัญสูงสุด
เช่น:><+1><-<+1<-<>>+1

s/>(?=.*1)/+2/g: รูปแบบการมองไปข้างหน้ามั่นใจได้ว่ามีเพียงการแปลง>ก่อนหน้า->เท่านั้น
เช่น:+2<+1+2<-<+1<-<+2+2+1

s/>/+1/g: ตอนนี้ส่วนที่เหลือ>จะได้รับความคุ้มครอง
เช่น:+2<+1+2<-<+1<-<+2+2+1

s/<-/-1/g: อะนาล็อกไปทางด้านหลัง
เช่น:+2<+1+2-1<+1-1<+2+2+1

s/<(?=.*-)/-2/g: ในรูปแบบการมองไปข้างหน้าไม่จำเป็นต้องใช้แบบเต็มรูปแบบ-1เดิม<-เนื่องจากไม่มี-สัญลักษณ์ทิศทางที่เหลืออยู่
เช่น:+2-2+1+2-1-2+1-1<+2+2+1

s/</-1/g: ส่วนที่เหลือ<หลังจากที่ผ่านมา<-จะถูกแปลง
เช่น:+2-2+1+2-1-2+1-1-1+2+2+1

print eval: คำนวณและส่งออกผลลัพธ์
เช่น:4

ทับทิม 141 ไบต์

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

Ungolfed:

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

ยกเลิกการตีลูก :

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

ด้วยช่องว่าง:

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

อาจเป็นห้องที่มากขึ้นในการเล่นกอล์ฟนี้ ฉันส่วนใหญ่ยอมแพ้ในการพยายามจัดการกับตัวแปร 4 ใน ternaries ที่จับ lvalues ​​(มันออกมาอีกต่อไปและรับในภายหลัง) แต่ไม่ใช่ผ่านครั้งแรกที่ไม่ดี การส่งผ่านแถวหน้าตรงค่อนข้างสวย รับอินพุตเป็นอาร์กิวเมนต์บรรทัดคำสั่งเอาต์พุตผ่านค่าส่งคืน

คุณจะต้อง-std=c99ตั้งค่าสถานะเพื่อรวบรวมด้วย gcc

แก้ไข: ใช่มันช้าแล้ว - คิดถึงบางอย่างที่ชัดเจน

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)

Unminified:

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)

มันทำงานอย่างไร

รับอินพุตสตริงตามsต้องการ:

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

มันใช้ Regex เพื่อแทนที่แต่ละคำสั่งด้วยชุดคำสั่งที่แก้ไขz(ตำแหน่งสิ้นสุด), l(การเคลื่อนไหวซ้ายที่เก็บไว้) และrการเคลื่อนไหวขวาที่จัดเก็บ Regex แต่ละตัวจะดำเนินการตามลำดับความสำคัญ

สำหรับอินพุตด้านบนสิ่งนี้จะแปลงsเป็น:

"++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;"

สวยมันไม่ใช่

ในที่สุดเราก็eval(s)จะทำตามคำแนะนำและการแจ้งเตือนzซึ่งมีตำแหน่งสิ้นสุด

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 ไบต์]

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)

อาจจะสั้นลงอีกเล็กน้อย ...

PHP, 284 282

ไม่มี 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;

Ungolfed:

$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;

โซลูชัน perl อื่น 113 ตัวอักษร

มีสองคำตอบที่เอาชนะสิ่งนี้มันเป็นเพียงสำหรับหัวเราะคิกคัก มันใช้วิธีการตามการสังเกตของ Ilmari เกี่ยวกับคุณค่าของโทเค็น:

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

ระเบิดเล็กน้อย:

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