14

आपका कार्य - क्या आपको इसे स्वीकार करना चाहिए - एक ऐसा कार्यक्रम बनाना है जो टोकनों का निर्देशन करता है और एक स्ट्रिंग का मूल्यांकन करता है (टोकन के बाएं से दाएं और मनमाने ढंग से लंबाई) जो दिशा-निर्देश देते हैं - या तो बाएं या दाएं। यहां चार संभावित टोकन और उनके अर्थ दिए गए हैं:

>  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

हालांकि एक पकड़ है - आपके कार्यक्रम को दिशा-निर्देश देने में सक्षम होने वाले टोकन इस रूप में प्रस्तुत किए जाएंगे:

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

... दूसरे शब्दों में, उन्हें संक्षिप्त किया गया है, और यह आपके कार्यक्रम का कार्य है कि दिशाओं की सही पूर्वता और चरणों की मात्रा का पता लगाना (आगे देखते हुए)। वरीयता का क्रम निम्नानुसार है (उच्चतम से निम्नतम वरीयता तक):

->
<-
>
<

यदि आपका सामना <-तब होता है जब बाईं ओर कोई कदम पहले या तो शुरू होने के बाद से या अंतिम रीसेट के बाद से नहीं किया गया था, तो बाईं ओर एक भी कदम उठाएं। उसी नियम पर लागू होता है ->, लेकिन फिर दाईं ओर जाने के लिए।

आपका कार्यक्रम 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

स्पष्टीकरण के लिए: कार्यक्रम का आउटपुट केवल हस्ताक्षरित पूर्णांक के रूप में अंतिम अंतिम स्थिति होना चाहिए। ऊपर दी गई तालिका मेरे उदाहरण के लिए उठाए गए चरणों का वर्णन करने के लिए है। इस तरह के एक टेबल, टेबल पंक्ति, या यहां तक कि चरणों के अंत पदों को आउटपुट करने की आवश्यकता नहीं है। हस्ताक्षरित पूर्णांक के रूप में केवल अंतिम अंतिम स्थिति की आवश्यकता होती है।

सबसे कम कोड, एक सप्ताह के बाद, जीतता है।

code-golf parsing

— निर्णायक डब्बलर
स्रोत

4

यदि मैं पूर्वता के नियमों को सही ढंग से समझता हूं, तो आप केवल एक बार ही आह्वान कर सकते हैं <-, यदि इसके तुरंत बाद ए <या ए ->। वहाँ इस भाषा में कोई रास्ता नहीं अनुक्रम का प्रतिनिधित्व करने के लिए <-तो >जो होगा - go left the total amount of single steps that you've gone left, plus one, then go right one single step। क्या यह सही है और डिजाइन द्वारा?

— एडम डेविस

@AdamDavis आप सही हैं। दुर्भाग्य से वह थोड़ा असावधान था।

— डेसटेंट डब्बलर

6

GolfScript, 46 वर्ण

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

यह मेरे द्वारा लिखे गए सबसे रेखीय गोल्फस्क्रिप्ट कार्यक्रमों में से एक है - इसमें एक भी लूप, सशर्त या चर असाइनमेंट नहीं है। स्ट्रिंग हेरफेर का उपयोग करके सब कुछ किया जाता है:

सबसे पहले, मैं ->द्वारा होने वाली हर घटना को प्रतिस्थापित करता हूं )। चूंकि इनपुट वैध होने की गारंटी है, यह सुनिश्चित करता है कि किसी भी शेष घटना का -एक हिस्सा होना चाहिए <-।
अगला, मैं स्ट्रिंग की दो प्रतियां बनाता हूं। पहली प्रति से, मैं पात्रों को हटाता हूं <और -, केवल >और केवल छोड़कर )। मैं फिर परिणाम की नकल करता हूं, दूसरी कॉपी से सभी )एस और हर >आखिरी को )हटा देता हूं, उन्हें संक्षिप्त करता हूं और पात्रों को गिनता हूं। इस प्रकार, वास्तव में, मैं गिन रहा हूँ:
- प्रत्येक के लिए +1 ),
- >अंतिम के बाद प्रत्येक के लिए +1 ), और
- >अंतिम से पहले प्रत्येक के लिए +2 )।
इसके बाद, मैं इस बार उनकी गिनती को छोड़कर अन्य प्रति के लिए भी ऐसा ही, <और <-के बजाय >और ), और हटाने -अंतिम वर्ण गिनती से पहले रों। इस प्रकार, मैं गिनता हूं:
- प्रत्येक के लिए +1 <-,
- <अंतिम के बाद प्रत्येक के लिए +1 <-, और
- <अंतिम से पहले प्रत्येक के लिए +2 <-।
अंत में, मैं पहले एक से दूसरी गणना को घटाता हूं, और परिणाम को आउटपुट करता हूं।

— इल्मरी करोनें
स्रोत

6

पायथन 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 ;').replace('4 बार स्ट्रिंग के साथ एक ट्यूपल का उपयोग करने के विचार के साथ आया था , str.format()पाठ को पूर्व- विधि का उपयोग करने के लिए । %sदूसरी पंक्ति में स्ट्रिंग में चार उदाहरण हैं, प्रत्येक अंत में टपल के संबंधित तत्व से अपना मूल्य ले रहा है। चूंकि वे सभी समान हैं, प्रत्येक के %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। यह सही है, बच्चे: नेस्टेड execमुझे कोड पर स्ट्रिंग संचालन का उपयोग करने की आवश्यकता है जो कोड पर स्ट्रिंग संचालन करने की आवश्यकता है । कृपया कोई मुझे मार डाले।

इसका बाकी हिस्सा बहुत सीधा है: प्रत्येक कमांड को कोड के साथ बदल दिया जाता है जो तीन चर का ट्रैक रखता है: वर्तमान स्थिति, अंतिम के बाद से अधिकारों की संख्या ->, और लेफ़्ट के लिए समान <-। पूरी बात चलती है और स्थिति मुद्रित होती है।

आप देखेंगे कि मैं raw_input(';')',' का उपयोग कर रहा हूँ ; एक संकेत के रूप में, raw_input()जिसके बजाय कोई संकेत नहीं है। यह एक unintuitive तरह से पात्रों की बचत होती है: अगर मैंने किया था raw_input(), मैं टपल से भरा है करने के लिए होगा ).replace(', और के प्रत्येक उदाहरण %sके लिए होता है, इससे पहले कि यह '' \ ' पहले एक को छोड़कर । शीघ्र होने से अधिक अतिरेक पैदा होता है, इसलिए मैं समग्र वर्णों को बचा सकता हूं।

— undergroundmonorail
स्रोत

2

" list.index()रिटर्न -1जब यह चरित्र खोजने में विफल रहता है" .. erm no। यह एक उठाता है IndexError। आपने इसे भ्रमित कर दिया होगा str.find। वास्तव में आप के [list('><rl').index(c)]साथ बदल सकता है ['><rl'.find(c)]।

— बकुरी

... हुह, मैंने इसे डॉक्स में देखा और शपथ ली कि यह -1 लौट आए। यह विशेष रूप से सूचियों के लिए पृष्ठ था, इसलिए मुझे नहीं पता कि मैंने क्या पढ़ा। वैसे भी, मदद के लिए धन्यवाद, मैं जवाब में संपादित करेंगे।

— अंडरग्राउंडोरेल

5

पर्ल, 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

स्टड पर एक ही लाइन के रूप में इनपुट लेता है, जैसे:

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 / $ पॉस के बीच एक सीधा मानचित्रण रखने और उस स्थिति में लाभ होता था जो किसी भी समय में वापस आ जाएगा, लेकिन कोड के अधिक बाइट्स ले लिया।

यदि आप उपयोग करना चाहते हैं () ५.१०.०, तो आप अन्य २ वर्णों को गिनने के लिए दाढ़ी बना सकते हैं / प्रिंट कर सकते हैं / कह सकते हैं, लेकिन यह वास्तव में मेरी शैली नहीं है।

— skibrianski
स्रोत

4

पर्ल, 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

— हेइको ओबर्डिएक
स्रोत

अच्छा था। मैं इस अवधारणा के आसपास कल रात को मार रहा था, लेकिन आज तक इसे लागू करने की कोशिश करने का मौका नहीं था। अच्छी बात है कि मैंने पोस्ट की जाँच की और देखा कि आपके पास पहले से ही =)

— स्किब्रिआंस्की

@skibrianski: कॉपी और पेस्ट त्रुटि को ठीक करने के लिए धन्यवाद।

— Heiko Oberdiek

थोड़ा अधिक golfed जा सकता है: 65 बाइट्स या, का उपयोग किए बिना -p: 74 बाइट्स मैं अपने बदल s/>//gकरने के लिए y/>//प्रत्येक मामले जो भी अभिव्यक्ति में कोष्ठक को हटाने के लिए अनुमति में एक बाइट को बचाने के लिए।

— Xcali

2

रूबी, 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

— टिम एस।
स्रोत

त्वरित जीत की एक जोड़ी: l=1;r=1हो सकता है l=r=1और $><<oहो सकता है p o। मुझे लगता है कि आप उस केस स्टेटमेंट को कुछ कम eval %w(o-=1;l+=1 o+=1;r+=1 o-=l;l=1 o+=r;r=1)['<>LR'.index c]

— उभार के

वास्तव में निष्कासन दृष्टिकोण के साथ आप और भी अधिक बचत करने के लिए कुछ उपसर्ग / प्रत्यय खींच सकते हैं। यह 98 वर्ण है: l=r=1;o=0;gets.gsub('->',??).scan(/<-|./){eval"o+=#{%w[-1;l+ -l;l 1;r+ r;r][$&[-1].ord%4]}=1"};p oआप 94 का उपयोग करके नीचे जा सकते हैंruby -p

— पॉल प्रेस्टिज

1

डी - 243

गोल्फ :

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

— टोनी एलिस
स्रोत

आवश्यक आउटपुट मूल रूप से प्रश्न में था। मैंने इसे अभी हाइलाइट किया है, और आगे स्पष्टीकरण दिया है।

— डेसकल डब्बलर

ठीक है, मैंने अपना उत्तर अब परिणाम के लिए संपादित किया है।

— टोनी एलिस

1

सी, 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 वैरिएबल्स को हेरफेर करने की कोशिश में हार मान ली, जिन्होंने लैवल्स पर कब्जा कर लिया (यह लंबे समय तक बाहर निकलता रहा और बाद में मिलता रहा), लेकिन एक बुरा पहला पास नहीं। सुंदर सीधे आगे सरणी पास। कमांड-लाइन तर्क के रूप में इनपुट लेता है, रिटर्न वैल्यू के माध्यम से आउटपुट करता है।

आपको -std=c99इसे gcc के साथ संकलित करने के लिए ध्वज की आवश्यकता होगी ।

संपादित करें: हाँ, यह देर हो चुकी है - कुछ स्पष्ट सामान याद किया।

— Comintern
स्रोत

आप का तर्क सूची में दो रिक्त स्थान को हटा सकते हैं main: main(char*x,char**v)। फिर आपके पास 140 के बजाय 138 है।

— Heiko Oberdiek

एक बग है: >><-1 के ><->बदले 0 देता है या 2 के बदले 0 देता है

— Heiko Oberdiek

अगर बीच अपने निकालें रिक्त स्थान आप 4 बाइट बचा सकता है charऔर *, और की जगह (*(x+1)==45)?(x++,o-=l+2,l=0):(o--,l++)के साथ (*++x==45)?(o-=l+2,l=0):(x--,o--,l++)।

— मैथ्यू रोडिक

1

जावास्क्रिप्ट, 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="><->><-<-><-<>>->";

यह प्रत्येक कमांड को निर्देश के एक सेट के साथ बदलने के लिए एक रेगेक्स का उपयोग करता है जो संशोधित 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जिसमें अंतिम स्थिति होती है।

— जॉर्ज रीथ
स्रोत

1

जावास्क्रिप्ट (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

— mowwwalker
स्रोत

0

जावास्क्रिप्ट [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)

संभवतः इसे थोड़ा और छोटा किया जा सकता है ...

— दृष्टि
स्रोत

0

PHP, 284 282

रेगेक्स नहीं।

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

— Vereos
स्रोत

आप 2 चर जीत सकते हैं str_split($i)( 1दूसरे तर्क के लिए डिफ़ॉल्ट है।) और $iशायद $cसही होना चाहिए ?

— डिसेंट डब्बलर

पहली पंक्ति गलत थी (यह थी $i): पी फिक्स्ड इट!

— 18

0

एक और पर्ल समाधान, 113 वर्ण

पहले से ही दो जवाब हैं जो इसे हराते हैं, यह सिर्फ गिगल्स के लिए है। यह टोकन के मूल्य के बारे में इल्मरी के अवलोकन पर आधारित एक दृष्टिकोण का उपयोग करता है:

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

— skibrianski
स्रोत

ब्रेनफ * सीकिश दिशाओं

GolfScript, 46 वर्ण

पायथन 2.7 - 154 147 134 128 बाइट्स

पर्ल, 134 131 ... 99 95 बाइट्स

पर्ल, 88 77 बाइट्स

अपडेट करें

पहला संस्करण

स्पष्टीकरण:

रूबी, 141 बाइट्स

डी - 243

सी, 148 141 140

जावास्क्रिप्ट, 136

यह काम किस प्रकार करता है

जावास्क्रिप्ट (116, 122 , 130 )

जावास्क्रिप्ट [217 बाइट्स]

PHP, 284 282

एक और पर्ल समाधान, 113 वर्ण