एक सीढ़ी पर रोबोट

Question

पृष्ठभूमि

मेरे पास एक दीवार पर झुकाव वाली सीढ़ी है, और एक रिमोट-नियंत्रित रोबोट है जो इस पर चढ़ सकता है। मैं रोबोट को तीन अलग-अलग कमांड भेज सकता हूं:

• UP: रोबोट एक कदम ऊपर की ओर ले जाता है। यदि यह उच्चतम कदम पर था, तो यह यात्रा करता है, नीचे गिरता है और विस्फोट होता है।
• DOWN: रोबोट एक कदम नीचे की ओर ले जाता है। अगर यह सबसे निचले पायदान पर होता, तो कुछ नहीं होता।
• RESET: रोबोट सबसे कम चरण में लौटता है।

मैं कमांड की एक श्रृंखला भी भेज सकता हूं, और रोबोट उन्हें एक-एक करके निष्पादित करेगा। आपका काम इसके आंदोलनों की भविष्यवाणी करना है।

इनपुट

आपके इनपुट एक सकारात्मक पूर्णांक हैं N, सीढ़ी में चरणों की संख्या का प्रतिनिधित्व करते हैं, और एक गैर-रिक्त स्ट्रिंग Cओवर UDR, जो आदेश मैंने रोबोट को भेजा है उसका प्रतिनिधित्व करता है। आप ऐसा मान सकते हैं N < 1000। रोबोट को सीढ़ी के सबसे निचले चरण पर आरंभीकृत किया जाता है।

उत्पादन

यह गारंटी है कि किसी बिंदु पर, रोबोट उच्चतम चरण पर चढ़ जाएगा और विस्फोट करेगा। ऐसा होने से पहले आपका आउटपुट कमांड निष्पादित करता है।

उदाहरण

इनपुट N = 4और C = "UDDUURUUUUUUUDDDD" रोबोट पर विचार करें, इसके द्वारा निरूपित @, निम्नानुसार 4-चरण सीढ़ी के साथ चलता है:

|-|   |-|   |-|   |-|   |-|   |-|   |-|   |-|   |-|   |@|   |-||
|-|   |-|   |-|   |-|   |-|   |@|   |-|   |-|   |@|   |-|   |-||
|-|   |@|   |-|   |-|   |@|   |-|   |-|   |@|   |-|   |-|   |-|v
|@| U |-| D |@| D |@| U |-| U |-| R |@| U |-| U |-| U |-| U |-|# Boom!

शेष आदेशों को निष्पादित नहीं किया गया है, क्योंकि रोबोट विस्फोट हो गया है। विस्फोट 10 आदेशों के बाद हुआ, इसलिए सही आउटपुट है 10।

नियम और स्कोरिंग

आप एक पूर्ण कार्यक्रम या एक फ़ंक्शन लिख सकते हैं। सबसे कम बाइट गिनती जीतता है, और मानक खामियों को रोक दिया जाता है।

परीक्षण के मामलों

  1 U -> 1
  1 DDRUDUU -> 4
  4 UDDUUUUURUUUUDDDD -> 7
  4 UDDUURUUUUUUUDDDD -> 10
  6 UUUUUDRUDDDDRDUUUUUUDRUUUUUUUDR -> 20
 10 UUUUUURUUUUUUURUUUUUUUURUUUUUUUUUUUUUU -> 34
  6 UUUDUUUUDDDDDDDDDDDDDDRRRRRRRRRRRUUUUUU -> 8
  6 UUUDUUUDURUDDDUUUUUDDRUUUUDDUUUUURRUUDDUUUUUUUU -> 32
 20 UUDDUDUUUDDUUDUDUUUDUDDUUUUUDUDUUDUUUUUUDUUDUDUDUUUUUDUUUDUDUUUUUUDUDUDUDUDUUUUUUUUUDUDUUDUDUUUUU -> 56
354 UUDDUUDUDUUDDUDUUUUDDDUDUUDUDUDUDDUUUUDUDUUDUDUUUDUDUDUUDUUUDUUUUUDUUDUDUUDUDUUUUUDUDUUDUDUDUDDUUUUUUUDUDUDUDUUUUUDUDUDUDUDUDUDUDUUDUUUUUURUUUDUUUUDDUUDUDUDURURURUDUDUUUUDUUUUUUDUDUDUDUDUUUUUUDUDUUUUUUUDUUUDUUDUDUDUUDUDUDUUUUUUUUUUDUUUDUDUUDUUDUUUDUUUUUUUUUUUUUDUUDUUDUDUDUUUDUDUUUUUUUDUUUDUUUDUUDUUDDUUUUUUUUDUDUDUDUDUUUUDUDUUUUUUUUDDUUDDUUDUUDUUDUDUDUDUUUUUUUUUDUUDUUDUUUDUUDUUUUUUUUUUUDUDUDUDUUUUUUUUUUUUDUUUDUUDUDDUUDUDUDUUUUUUUUUUUUDUDUDUUDUUUDUUUUUUUDUUUUUUUUUDUDUDUDUDUUUUUUDUDUDUUDUDUDUDUUUUUUUUUUUUUUUDUDUDUDDDUUUDDDDDUUUUUUUUUUUUUUDDUDUUDUUDUDUUUUUUDUDUDUDUDUUUUDUUUUDUDUDUUUDUUDDUUUUUUUUUUUUUUUUUUDUUDUUDUUUDUDUUUUUUUUUUUDUUUDUUUUDUDUDUUUUUUUUUDUUUDUUUDUUDUUUUUUUUUUUUDDUDUDUDUUUUUUUUUUUUUUUDUUUDUUUUDUUDUUDUUUUUUUUUUUDUDUUDUUUDUUUUUUDUDUDUUDUUUUUUUUUUUUDUUUDUUDUDUDUUUUDUDUDUDUDUUUUUUUUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUUU -> 872

Comments

संबंधित

— पीटर टेलर

मुझे निराशा है कि कार्य ASCII कला उत्पन्न करने के लिए नहीं है।

— user253751

@immibis आपको पता है कि क्या करना है ...

— मार्टिन

एक स्ट्रिंग के बजाय, हम चरित्र कोड की एक सूची ले सकते हैं?

— साइओस

@Cyoce केवल अगर आपकी भाषा में स्ट्रिंग का प्रतिनिधित्व करने के लिए कोई अन्य साधन नहीं है।

— जरगब

Answer 1

CJam, 26 25 22 बाइट्स

0l{i"()~ "=~0e>_}%ri#)

इनपुट प्रारूप पहली पंक्ति पर निर्देश और दूसरी पर सीढ़ी की ऊंचाई है।

इसका परीक्षण यहां करें।

व्याख्या

0         e# Push a 0 - the initial position of the robot.
l         e# Read the instructions.
{         e# Map this block over the instruction...
  i       e#   Convert to character code. D -> 68, U -> 85, R -> 82.
  "()~ "= e#   We use these as cyclic indices into this array. Note that the values
          e#   modulo 4 are 0, 1 and 2, respectively. So U -> ) (increment),
          e#   D -> ( (decrement), R -> ~ (bitwise NOT, i.e negated and decrement).
  ~       e#   Evaluate the character as code.
  0e>     e#   Clamp to non-negative numbers. So D can't go below 0, and since R is
          e#   guaranteed to yield something negative, this resets it to zero.
  _       e#   Duplicate, so we keep one copy of the current position on the stack.
}%        e# Since this was a map, the result will be wrapped in an array.
ri        e# Read the ladder height and convert it to an integer.
#         e# Find its first occurrence in the list of positions.
)         e# The result is off by one, so we increment it.

Comments

विस्फोट के बाद भी सभी आदेशों को संसाधित करने का अच्छा विचार है। मैं कुछ बाइट्स बचाने के लिए उधार लूंगा

— लुइस मेंडो

Answer 2

सी, 83 71 + 4 = 75 बाइट्स

धन्यवाद @Josh मुझे K & S स्टाइल दिखाने के लिए , जिसने 8 बाइट्स की अनुमति दी !!

f(i,s,z,a)char*s;{z-=*s<82?z>0:*s>82?-1:z;return z-i?f(i,s+1,z,a+1):a;}

व्याख्या:

f(i,s,z,a)char*s;{ // function needs one integer and one "string"
  z-=              // z is the bot's height
    *s<82?         // if 'Down'
      z>0          // then subtract 1 when z>0 or nothing otherwise
    :*s>82?        // else if 'Up'
      -1           // increase height z-=-1
    :z;            // else reset z=z-z
  return z-i?      // if z is not the max height
    f(i,s+1,z,a+1) // try next step
  :a;              // else print how many calls/steps were made
}                  // end of function

उदाहरण कॉल:

f(1,"U",0,1);    // I've added 4 bytes in the score because of ",0,1"

आइडोन पर लाइव टेस्ट

Comments

अच्छा जवाब है, लेकिन यह ध्यान देने योग्य है कि फ़ंक्शन केवल ग्लोबल्स के बाद से एक बार प्रभावी रूप से उपयोग किया जा सकता है zऔर aरीसेट नहीं किया जाता है।

— जोश

@Josh। मैंने अपडेट किया है। :)

— हटा दिया

बहुत बढ़िया! आप अपने फ़ंक्शन में प्रकार की घोषणाओं के साथ खेलने के साथ कुछ पात्रों को भी बचा सकते हैं: codegolf.stackexchange.com/a/40266/13877

— जोश

@Josh। वाह यह कमाल है! धन्यवाद

— हटा दिया

Answer 3

जावास्क्रिप्ट (ईएस 6), 54 53 बाइट्स

n=>c=>(f=p=>n-p?f({D:p&&p-1,U:p+1}[c[i++]]|0):i)(i=0)

व्याख्या

आंतरिक रूप से पुनरावर्ती फ़ंक्शन का उपयोग करता है।

var solution =

n=>c=>(
  f=p=>             // f = recursive function, p = position of robot on ladder
    n-p?            // if p != n
      f({           // execute the next command
          D:p&&p-1, // D -> p = max of p - 1 and 0
          U:p+1     // U -> p = p + 1
        }[c[i++]]   // get current command then increment i (current command index)
        |0          // R -> p = 0
      )
    :i              // else return the current command index
)(i=0)              // initialise p and i to 0 for the first recurse

N = <input type="number" id="N" value="354" /><br />
C = <input type="text" id="C" value="UUDDUUDUDUUDDUDUUUUDDDUDUUDUDUDUDDUUUUDUDUUDUDUUUDUDUDUUDUUUDUUUUUDUUDUDUUDUDUUUUUDUDUUDUDUDUDDUUUUUUUDUDUDUDUUUUUDUDUDUDUDUDUDUDUUDUUUUUURUUUDUUUUDDUUDUDUDURURURUDUDUUUUDUUUUUUDUDUDUDUDUUUUUUDUDUUUUUUUDUUUDUUDUDUDUUDUDUDUUUUUUUUUUDUUUDUDUUDUUDUUUDUUUUUUUUUUUUUDUUDUUDUDUDUUUDUDUUUUUUUDUUUDUUUDUUDUUDDUUUUUUUUDUDUDUDUDUUUUDUDUUUUUUUUDDUUDDUUDUUDUUDUDUDUDUUUUUUUUUDUUDUUDUUUDUUDUUUUUUUUUUUDUDUDUDUUUUUUUUUUUUDUUUDUUDUDDUUDUDUDUUUUUUUUUUUUDUDUDUUDUUUDUUUUUUUDUUUUUUUUUDUDUDUDUDUUUUUUDUDUDUUDUDUDUDUUUUUUUUUUUUUUUDUDUDUDDDUUUDDDDDUUUUUUUUUUUUUUDDUDUUDUUDUDUUUUUUDUDUDUDUDUUUUDUUUUDUDUDUUUDUUDDUUUUUUUUUUUUUUUUUUDUUDUUDUUUDUDUUUUUUUUUUUDUUUDUUUUDUDUDUUUUUUUUUDUUUDUUUDUUDUUUUUUUUUUUUDDUDUDUDUUUUUUUUUUUUUUUDUUUDUUUUDUUDUUDUUUUUUUUUUUDUDUUDUUUDUUUUUUDUDUDUUDUUUUUUUUUUUUDUUUDUUDUDUDUUUUDUDUDUDUDUUUUUUUUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUUU" /><br />
<button onclick="result.textContent=solution(+N.value)(C.value)">Go</button>
<pre id="result"></pre>

Answer 4

पर्ल, 47 + 2 = 49 बाइट्स

$z-=-/U/||$z&&/D/;$z*=!/R/;$^I<=$z&&last}{$_=$.

बाद की ऊंचाई के लिए -pध्वज की आवश्यकता होती है , -i$Nऔर चालों की एक नई पंक्ति अलग सूची:

$ perl -pi10 ladderbot.pl <<<< $'U\nU\nU\nU\nU\nU\nR\nU\nU\nU\nU\nU\nU\nU\nR\nU\nU\nU\nU\nU\nU\nU\nU\nR\nU\nU\nU\nU\nU\nU\nU\nU\nU\nU\nU\nU\nU\nU'
34

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

                                                # '-p' wraps the code in (simplified):
                                                # while($_=<>) {...print $_}
$z-=-/U/||$z&&/D/;                              # Subtract -1 if UP. subtract 1 if DOWN
                  $z*=!/R/;                     # If R then times by zero
                           $^I<=$z&&last        # Break while loop if N is reached
                                        }{      # Eskimo operator:
                                                # while($_=<>){...}{print$_}
                                          $_=$. # `$.` contains number of lines read from input.

Deparsed:

LINE: while (defined($_ = <ARGV>)) {
    $z -= -/U/ || $z && /D/;
    $z *= !/R/;
    last if $^I <= $z;
}
{
    $_ = $.;
}
continue {
    die "-p destination: $!\n" unless print $_;
}
-e syntax OK

Answer 5

जावास्क्रिप्ट (स्पाइडरमोनी 30+), 65 64 बाइट्स

(n,s,i=0)=>[for(c of s)if(i<n)c<'E'?i&&i--:c>'T'?i++:i=0].length

---

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

हमने सबसे पहले वेरिएबल iको 0. पर सेट किया है। यह इस बात पर नज़र रखेगा कि रोबोट कितने कदम ऊपर चढ़ चुका है। फिर cइनपुट स्ट्रिंग में प्रत्येक चार के लिए, हम निम्नलिखित तर्क चलाते हैं:

1. यदि इससे iबड़ा या इसके बराबर है n, तो कुछ भी न करें।
2. अगर cहै"D" :
   • अगर i 0 है, तो इसे छोड़ दें।
   • अन्यथा, इसे 1 से घटाएं।
3. अगर cहै "U", तो वेतन वृद्धिi 1 से ।
4. अन्यथा, i0 पर सेट करें।

यदि i>=nरोबोट शीर्ष पर पहुंच गया है, तो कट ऑफ करके , हम किसी और आइटम को जोड़ने से बचते हैं। इस प्रकार, हम केवल परिणामी सरणी की लंबाई वापस कर सकते हैं।

Answer 6

हास्केल, 65 बाइट्स

x%'U'=x+1
x%'D'=max(x-1)0
x%_=0
f n=length.fst.span(<n).scanl(%)0

प्रयोग उदाहरण: f 4 "UDDUURUUUUUUUDDDD"-> 10।

%सीढ़ी पर वर्तमान स्थिति को समायोजित करता है, scanlसभी पदों की एक सूची बनाता है, fst.span(<n)विस्फोट से पहले भाग लेता है और lengthचरणों को गिनता है।

Comments

नामित तर्क और रचना / करीने के संयोजन के साथ अच्छी नौकरी

— साइरो

Answer 7

जावास्क्रिप्ट (ईएस 6), 65 बाइट्स

(n,s)=>[...s].map(_=>i=_<'E'?i&&i-1:_>'T'?i+1:0,i=0).indexOf(n)+1

Comments

आइए हम इस चर्चा को चैट में जारी रखते हैं ।

— 21

मुझे लगता है कि0,i=0i=0

— Cyoce

@Cyoce हम्म, एक नए टैब में मेरे लिए विफल रहता है (इस पृष्ठ पर काम करता है b / ci पहले से ही परिभाषित है)

— चार्ली व्यान

@CharlieWynn माफ करना, मेरी पूर्वता को मिलाया गया

— Cyoce

Answer 8

MATL , 37 34 बाइट्स

Oj"t@4\1=?Q}6M?x0}qt0>*]]]N$h=f1)q

इसे ऑनलाइन आज़माएं!

व्याख्या

स्थिति 0-आधारित है। प्रत्येक नई स्थिति को पुराने पदों को ध्यान में रखते हुए स्टैक पर धकेल दिया जाता है। तो स्टैक आकार अब तक आंदोलनों की संख्या का प्रतिनिधित्व करता है, प्लस 1।

प्रत्येक आदेश को संसाधित करने के लिए एक लूप का उपयोग किया जाता है। लूप तब बाहर निकलता है जब स्थिति सीढ़ी की ऊंचाई तक पहुंच जाती है, सभी आदेशों के बाद भी विस्फोट के बाद ( मार्टिन के जवाब से लिया गया विचार )। अंतिम परिणाम सीढ़ी की ऊंचाई के बराबर पहली स्थिति के सूचकांक द्वारा दिया जाता है।

O             % push a 0: initial position (0-based)
j             % take first input (commands) as a string
"             % for each command
  t           %   duplicate current position
  @           %   push command
  4\          %   modulo 4. This gives 1, 2, 0 for 'U','R', 'D'
  1=?         %   if result equals 1 (command 'U')
    Q         %     increase position by 1
  }           %   else
    6M?       %     if result was nonzero (command 'R')
      x0      %       delete current position and push 0
    }         %     else (command 'D')
      q       %       decrement by 1
      t0>*    %       turn negative values into 0
    ]         %     end if
  ]           %   end if
]             % end for each
N$h           % pack all numbers in the stack into an array
=             % implicitly read second input: ladder height
f1)q          % find first position equal to that, and subtract 1.
              % Implicitly display

Answer 9

पायथन 2, 63 62 बाइट्स

f=lambda n,s,h=0:h^n and-~f(n,s[1:],-[2%~h,~h,0][ord(s[0])%4])

उदाहरण के लिए, f(4, 'UDDUURUUUUUUUDDDD')है 10।

xnor को और भी छोटी अभिव्यक्ति मिली: 2%~hवाकई बहुत अच्छा है :)

Comments

के साथ अच्छा लगा %4। अगर मैं गलत नहीं हूं, तो आप एक चरित्र को बचा कर कर सकते हैं -[2%~h,~h,0][ord(s[0])%4]।

— xnor

Answer 10

पॉवरशेल, 86 79 बाइट्स

param($a,[char[]]$b)$b|%{$d++;if(($c-=((1,0)[!$c],-1,$c)[$_%4])-ge$a){$d;exit}}

जब सांता बेसमेंट में प्रवेश करता है, तो मेरी थोड़ी सी भी वापसी नहीं होती है। जवाब।

इनपुट लेता है $aऔर $b, स्पष्ट $bरूप से चार-सरणी के रूप में कास्टिंग करता है। हम तो |%{...}सभी के साथ लूप $b। प्रत्येक पुनरावृत्ति हम अपने काउंटर को बढ़ाते हैं $d।

फिर, ifयह जाँचने के लिए कि क्या हमने शीर्ष पर मारा है -ge$a। यदि हां, तो हम आउटपुट $dऔर exit। इस ifकथन का निर्माण छद्म-त्रिगुट से बनाया $cगया है, जो किसी अनुक्रम में कई अनुक्रमों के परिणाम के बराबर माइनस- असाइन करके बनाया गया है ।

हम एक चाल है कि ASCII मूल्यों है D, Rऔर Uपत्र व्यवहार करने 0, 2और 1जब सापेक्ष -4 लिया है, इसलिए $_%4हमारी पहली सूचकांक के रूप में कार्य करता है। यदि यह है R, कि रीसेट $cकरने के बराबर $c-$c, सेट करता है । यदि U, इसका मतलब है कि हमें ऊपर जाने की आवश्यकता है, तो $c-(-1)परिणाम। अन्यथा यह एक है D, इसलिए हमें यह जांचने की आवश्यकता है कि क्या हम पहले से ही नीचे हैं (जो कि !$cपॉवरशेल में है, "नहीं-शून्य" "सच" या 1) है और क्रमशः या $cउसके बराबर सेट है।$c-0$c-1

_{संपादित करें - प्रत्यक्ष असाइनमेंट के बजाय माइनस-समान असाइनमेंट का उपयोग करके सहेजे गए 7 बाइट्स}

Answer 11

पर्ल 5, 61 बाइट्स

के लिए दो बाइट्स शामिल हैं -F -i। ( -M5.01स्वतंत्र है।)

पूर्णांक का इनपुट (उदाहरण 10) इस प्रकार है perl -M5.01 -F -i10 robot.pl; सीढ़ी कमांड का इनपुट STDIN के रूप में है।

for(@F){($i+=/U/)-=/R/?$i:$i&&/D/;$j++;last if$^I<=$i}say$j

Comments

पर्ल 5.12.5 का उपयोग करते हुए, मुझे भी स्पष्ट रूप से ऑटोसप्लिट मोड को सक्षम करना पड़ता, -anFइससे पहले कि यह मेरे लिए कुछ भी प्रिंट करता। लेकिन यह केवल -F5.20.3 में अनुमानित रूप से सक्षम होने लगता है । क्या आप इसे सत्यापित कर सकते हैं?

— arnnew

@ardnew, सिर्फ -Fमेरे लिए पर्याप्त है (5.20 या 5.22 या तो)। Iirc वर्तमान perldoc perlrun का कहना है कि इसका मतलब है -aऔर -aइसका मतलब है -n।

— msh210

हम कितना गिनते -iहैं? मैं आपको इसे 1 के रूप में गिनते हुए देख सकता हूं लेकिन मुझे लगता है कि इसे वास्तव में 3 के रूप में गिना जाना चाहिए? :-)

— andlrc

@ देव-नल, तीन क्यों? मुझे लगता है कि PPCG.SE पर सम्मेलन एक ध्वज में अक्षरों को गिनना है, लेकिन हाइफ़न-माइनस वर्णों को नहीं, लेकिन अगर मैं गलत हूं तो कृपया मुझे सुधारें। (ऐसा लगता है कि आप इस प्रश्न के उत्तर के लिए उसी

— मत

@ msh210 मैं बस का उपयोग करते समय अंतर की गणना करता था -iऔर बिना perl -i10 -pe';'बनाम perl -pe';'जो मुझे लगता है कि हम गिनती नहीं करना चाहिए - 3 अक्षरों अधिक और फिर इनपुट संख्या। लेकिन मैं गलत हो सकता है, हालांकि इसके बारे में आज सुबह :-)

— 15

Answer 12

विट्टी, 44 बाइट्स

शायद कुछ कटौती हो सकती है - अगर मैं कर सकता हूं तो मैं कुछ और चीजों का पता लगाऊंगा।

0vVWl:X[4M1+mDvV-);]lvXv?v-N
vD([1-]
v1+
vX0

स्पष्टीकरण (प्रगति में):

0vVWl:X[4M1+mDvV-);]lvXv?v-N
0v             Save 0 as our temp var to edit.
  V            Save the input as a global var.
   W           Grab a line of STDIN.
    l          Push the length of the stack.
     :         Clone the stack. This is for later use.
      X        Remove the top item of the stack (we don't need the length right now.
[            ] Do the stuff in the brackets infinitely.
 4M            Modulo 4.
   1+          Add one.
     m         Go to the line index as specified by the top item of the stack.
      Dv       Duplicate the top item, save it in the temp var.
        V-);   If the top value is equal to the input number, exit the loop.
l              Push the length of the stack.
 vXv           Dump the temp var, then save the top item.
    ?          Rotate back to the original stack.
     v-        Subtract the top item (the original length) by the temp var (new length)
       N       Output the top item of the stack of the number.

vD([1-]
v              Push the temp variable to the stack.
 D([  ]        If this value is not zero...
    1-         Subtract one from it.

v1+            Push the temp variable to the stack, then add one to it.

vX0            Dump the temp var and replace it with zero.

यह ऑनलाइन की कोशिश करो! (बड़ा परीक्षण मामला)

Answer 13

PHP, 88 बाइट्स

यह कुछ उत्पन्न करता है (3 + 2n जहां n कमांड चलाने की संख्या है) नोटिस लेकिन गोल्फिंग के लिए कोई फर्क नहीं पड़ता है, है ना?

<?php for(;$x++<$argv[1];)switch($argv[2][$i++]){case R;$x=2;case D;--$x?--$x:0;}echo$i;

ungolfed:

<?php                    # actually 1 byte shorter not as a function
for(;$x++<$argv[1];)     # not initialising the $x causes a notice but still works
                         # post increment $x by 1 regardless of the command (saves us writing a U case)
  switch($argv[2][$i++]) # get next command, increment number of commands
    {case R;             # R gets treated as a constant with value 'R'. and a notice
      $x=2;              # falling through to D which will double decrement so set to 2
    case D;              # same trick as R
      --$x?--$x:0;}      # decrement once then again if >0
echo$i;                  # output

Comments

नोटिस ठीक हैं, जब तक कोड अभी भी चलाया जा सकता है।

— जर्बर्ग

Answer 14

पायथन, 121 बाइट्स

def f(a,n):
 i=c=0
 while i<n:i={'U':lambda x:x+1,'D':lambda x:0 if x==0 else x-1,'R':lambda x:0}[a[c]](i);c+=1
 return c

Comments

PPCG में आपका स्वागत है! यहां हमें डिफ़ॉल्ट रूप से आवश्यकता होती है कि उत्तर या तो पूर्ण कार्यक्रम हैं जो एसटीडीआईएन से इनपुट लेते हैं और एसटीडीयूएसटी पर प्रिंट करते हैं, या फ़ंक्शन जो तर्कों के रूप में इनपुट लेते हैं और आउटपुट मान वापस करते हैं। आपका समाधान इनपुट को हार्ड-कोड करता है, जिसकी अनुमति नहीं है।

— जरगब

फंक्शन में बनने से सही, मैं लिखने के समय दुभाषिया का उपयोग कर रहा था।

— एलेक्स बर्ज

धन्यवाद! आपको ## Python, <N> bytesदूसरों को अपना स्कोर दिखाने के लिए फ़ॉर्म का हेडर भी जोड़ना चाहिए ।

— झगरब

मुझे नहीं लगता कि कोई अनाम फ़ंक्शन हो सकता है।

— user48538 8

आप की जगह बाइट्स बचा सकता है 0 if x==0 else x-1के साथx and x-1

— Cyoce

Answer 15

जावास्क्रिप्ट, 131 106 बाइट्स-

मुझे पता है कि यह एक कोड गोल्फ प्रतियोगिता नहीं जीतेगी, लेकिन इसे लागू करने के लिए एक मजेदार और बेवकूफ समाधान था:

l=>s=>Function('i=c=0;'+s.replace(/./g,x=>`c++;i${{R:"=0",U:`++;if(i>=${l})re‌​turn c`,D:"--"}[x]};`))()

मैं थोड़े गतिशील रूप से उत्पन्न अनिवार्य समाधान करके "कार्यात्मक" मार्ग के विपरीत गया, किसी भी इंस्ट्रक्शन के इंस्ट्रक्शन को इंक्रीमेंट या डिक्रीमेंट और काउंटर इंक्रीमेंट से बदल दिया जाता है।

मुझे 29 बाइट बचाने के लिए साइकोस के लिए धन्यवाद!

Comments

यहाँ, मैं 29 बाइट्स से दूर गया:l=>s=>Function('i=c=0;'+s.replace(/./g,x=>`c++;i${{R:"=0",U:`++;if(i>=${l})return c`,D:"--"}[x]};`))()

— साइओस

Answer 16

पायथन 3, 90

DSM की बदौलत 6 बाइट्स बचाए।

अभी बहुत सरल है।

def f(c,n):
 f=t=0
 for x in c:
  f+=1|-(x<'E');f*=(x!='R')&(f>=0);t+=1
  if f>=n:return t

परीक्षण के मामलों:

assert f('U', 1) == 1
assert f('DDRUDUU', 1) == 4
assert f('UDDUUUUURUUUUDDDD', 4) == 7
assert f('UDDUURUUUUUUUDDDD', 4) == 10
assert f('UUDDUUDUDUUDDUDUUUUDDDUDUUDUDUDUDDUUUUDUDUUDUDUUUDUDUDUUDUUUDUUUUUDUUDUDUUDUDUUUUUDUDUUDUDUDUDDUUUUUUUDUDUDUDUUUUUDUDUDUDUDUDUDUDUUDUUUUUURUUUDUUUUDDUUDUDUDURURURUDUDUUUUDUUUUUUDUDUDUDUDUUUUUUDUDUUUUUUUDUUUDUUDUDUDUUDUDUDUUUUUUUUUUDUUUDUDUUDUUDUUUDUUUUUUUUUUUUUDUUDUUDUDUDUUUDUDUUUUUUUDUUUDUUUDUUDUUDDUUUUUUUUDUDUDUDUDUUUUDUDUUUUUUUUDDUUDDUUDUUDUUDUDUDUDUUUUUUUUUDUUDUUDUUUDUUDUUUUUUUUUUUDUDUDUDUUUUUUUUUUUUDUUUDUUDUDDUUDUDUDUUUUUUUUUUUUDUDUDUUDUUUDUUUUUUUDUUUUUUUUUDUDUDUDUDUUUUUUDUDUDUUDUDUDUDUUUUUUUUUUUUUUUDUDUDUDDDUUUDDDDDUUUUUUUUUUUUUUDDUDUUDUUDUDUUUUUUDUDUDUDUDUUUUDUUUUDUDUDUUUDUUDDUUUUUUUUUUUUUUUUUUDUUDUUDUUUDUDUUUUUUUUUUUDUUUDUUUUDUDUDUUUUUUUUUDUUUDUUUDUUDUUUUUUUUUUUUDDUDUDUDUUUUUUUUUUUUUUUDUUUDUUUUDUUDUUDUUUUUUUUUUUDUDUUDUUUDUUUUUUDUDUDUUDUUUUUUUUUUUUDUUUDUUDUDUDUUUUDUDUDUDUDUUUUUUUUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUUU', 354) == 872

Answer 17

PHP, 129 बाइट्स

function r($h,$s){$i=0;$c=1;while($x=$s[$i++]){if($x=='U'){$c++;}elseif($x=='D'){--$c<1?$c=1:0;}else{$c=1;}if($c>$h){return$i;}}}

जीत नहीं है, लेकिन बनाने के लिए मजेदार है। PHP को टर्नेरी ऑपरेटर में खाली हिस्सों को नापसंद करना प्रतीत होता है (यह एक सिंटैक्स त्रुटि फेंकता है), इसलिए मुझे 0वहाँ लगाना पड़ा ।

Ungolfed संस्करण:

function r($h,$s) {          // $h - height of ladder; $s - instructions
  $i = 0;                    // Instruction index
  $c = 1;                    // Position on ladder
  while ($x = $s[$i++]){     // Set $x to current instruction and increment index
    if ($x == 'U'){          // If instruction is U...
      $c++;                  // Increment ladder position
    } elseif ($x == 'D') {   // If instruction is D...
      --$c < 1 ? $c = 1 : 0; // Decrement ladder position, if under 1 set to 1
    } else {                 // If instruction is anything else (in this case R)
      $c = 1;                // Reset ladder position
    }
    if ($c > $h) {           // If ladder position is larger than height...
      return $i;             // Return current instruction index
    }
  }
}

Answer 18

PHP, 113 बाइट्स

Https://codegolf.stackexchange.com/a/74575/13216 का छोटा संस्करण

function r($h,$s){$i=0;$c=1;while($x=$s[$i++]){$c+=($x=='U'?1:($x=='D'?($c>1?-1:0):1-$c));if($c>$h){return $i;}}}

Ungolfed:

// $h - height of ladder; $s - instructions
function r($h,$s) {
    $i = 0;
    $c = 1;
    while ($x = $s[$i++]) {
        $c += (
            $x=='U'?
                1
            :
                (
                    $x=='D'? (
                        $c>1?
                            -1
                        :
                            0
                    ):
                        1-$c
                )
        );
        if ($c > $h) {
            return $i;
        }
    }
}

Comments

महान पहली पोस्ट! मैंने आपकी पोस्ट को बेहतर पठनीयता के लिए संपादित किया है। हैप्पी गोल्फिंग!

— GamrCorps

Answer 19

पायथ, 19 बाइट्स

x.u@[tWNNhN00)CYz0Q

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

स्पष्टीकरण:

x.u@[tWNNhN00)CYz0Q   implicit: z = input string, Q = input number
 .u             z0    reduce z: for each char Y in z manipulate N = 0 with:
    [        )           create a list with
     tWNN                  * N-1 if N>0 else N
         hN                * N+1
           0               * 0
            0              * 0
   @          CY         replace N by the ord(Y)-th element (mod 4)
 .u                   .u give us a list with all intermediate values of N
x                 Q   print the index of Q in this list

Answer 20

जावा, 250 बाइट्स

int cmds(int n, String s) {
int steps=1;
int count=0;
for (int i=0;i< s.length();i++) {
count++;
char c=s.charAt(i);
switch(c){
case 'D':
steps=(steps==1)?1:--steps;
break;
case 'R':
steps=1;
break;
case 'U':
++steps;
break;
}
if(steps>n)
return count;
}
return 0;
}

Comments

एक कोड-गोल्फ -चैल्ज का उत्तर देते समय, आपको अपना उत्तर शुरू करना चाहिए # <language_name>, XX bytes। इसके अलावा, आप अपने चर नामों को एक वर्ण में कम कर सकते हैं और अतिरिक्त व्हाट्सएप को हटा सकते हैं, इस तरह से आपकी बाइट गिनती कम हो जाएगी (जो कि यहां उद्देश्य है) ... आह, और पीपीसीजी में आपका स्वागत है!

— हटा दिया

कुछ सुझाव: कोड के रूप में अपने कोड को इंडेंट करने के लिए लाइन की शुरुआत में 4 रिक्त स्थान जोड़ें। आपने कुछ स्थान हटा दिए हैं, लेकिन आप अभी भी अधिक निकाल सकते हैं (उदा: इसके बजाय int steps=1; int count=0;आप उपयोग कर सकते हैं int s=1,c=0;- देखो मैंने चर नाम बदल दिया है - और इसी तरह)। आप अभी भी अपने को दिखा सकते हैं ungolfed नीचे संस्करण golfed एक स्पष्टीकरण भी संस्करण (इस तरह से किसी को आपकी सहायता करने के लिए आसान है गोल्फ अधिक बाइट्स)।

— हटा दिया

Answer 21

सी, 91 बाइट्स

के साथ कोई चेतावनी नहीं gcc -Wall। पुनरावृत्ति और अल्पविराम द्वारा अलग किए गए भाव।

r.c नंगे समारोह में शामिल हैं:

int r(int N,int n,int s,char*C){return*C&&s<=N?s+=*C&2?-s:*C&1?1:-1,r(N,n+1,s?s:1,C+1):n;}

टिप्पणी की,

int r(int N,   // number of steps on ladder
      int n,   // result, seed with 0
      int s,   // current step, seed with 1
      char *C  // command string
      )
{
    return *C&&s<=N ?  // still reading commands and still on ladder?
       s+=                // increment step value by...
        *C&2?             // bit test if 'R' but not 'U' or 'D'.
         -s               // negate to 0, will set to 1 in call if needed
         :*C&1?           // Not 'R', is it 'U'?
            1             // 'U', add 1
            :-1,          // Must be 'D', subtract 1
       r(N,n+1,s?s:1,C+1) // Recursive call, and fix case where s==0.
      :n;                 // end of string or fell off ladder
}

सन्दर्भ के लिए,

'U'.charCodeAt(0).toString(2)
"1010101"
'D'.charCodeAt(0).toString(2)
"1000100"
'R'.charCodeAt(0).toString(2)
"1010010"

roboladder.c आवरण,

#include <stdio.h>
#include <stdlib.h>
#include "r.c"
int main(int argc, char * argv[])
{
  int N = atoi(argv[1]);
  int n = r(N,0,1,argv[2]);
  int check = atoi(argv[3]);
  printf("%d : %d\n", n, check);
  return 0;
}

Makefile परीक्षण के लिए,

run:
    @gcc -Wall robotladder.c -o robotladder 
    @./robotladder 1 U 1
    @./robotladder 1 DDRUDUU 4  
    @./robotladder 4 UDDUUUUURUUUUDDDD 7
    @./robotladder 4 UDDUURUUUUUUUDDDD 10
    @./robotladder 6 UUUUUDRUDDDDRDUUUUUUDRUUUUUUUDR 20
    @./robotladder 10 UUUUUURUUUUUUURUUUUUUUURUUUUUUUUUUUUUU 34
    @./robotladder 6 UUUDUUUUDDDDDDDDDDDDDDRRRRRRRRRRRUUUUUU 8
    @./robotladder 6 UUUDUUUDURUDDDUUUUUDDRUUUUDDUUUUURRUUDDUUUUUUUU 32
    @./robotladder 20 UUDDUDUUUDDUUDUDUUUDUDDUUUUUDUDUUDUUUUUUDUUDUDUDUUUUUDUUUDUDUUUUUUDUDUDUDUDUUUUUUUUUDUDUUDUDUUUUU 56
    @./robotladder 354 UUDDUUDUDUUDDUDUUUUDDDUDUUDUDUDUDDUUUUDUDUUDUDUUUDUDUDUUDUUUDUUUUUDUUDUDUUDUDUUUUUDUDUUDUDUDUDDUUUUUUUDUDUDUDUUUUUDUDUDUDUDUDUDUDUUDUUUUUURUUUDUUUUDDUUDUDUDURURURUDUDUUUUDUUUUUUDUDUDUDUDUUUUUUDUDUUUUUUUDUUUDUUDUDUDUUDUDUDUUUUUUUUUUDUUUDUDUUDUUDUUUDUUUUUUUUUUUUUDUUDUUDUDUDUUUDUDUUUUUUUDUUUDUUUDUUDUUDDUUUUUUUUDUDUDUDUDUUUUDUDUUUUUUUUDDUUDDUUDUUDUUDUDUDUDUUUUUUUUUDUUDUUDUUUDUUDUUUUUUUUUUUDUDUDUDUUUUUUUUUUUUDUUUDUUDUDDUUDUDUDUUUUUUUUUUUUDUDUDUUDUUUDUUUUUUUDUUUUUUUUUDUDUDUDUDUUUUUUDUDUDUUDUDUDUDUUUUUUUUUUUUUUUDUDUDUDDDUUUDDDDDUUUUUUUUUUUUUUDDUDUUDUUDUDUUUUUUDUDUDUDUDUUUUDUUUUDUDUDUUUDUUDDUUUUUUUUUUUUUUUUUUDUUDUUDUUUDUDUUUUUUUUUUUDUUUDUUUUDUDUDUUUUUUUUUDUUUDUUUDUUDUUUUUUUUUUUUDDUDUDUDUUUUUUUUUUUUUUUDUUUDUUUUDUUDUUDUUUUUUUUUUUDUDUUDUUUDUUUUUUDUDUDUUDUUUUUUUUUUUUDUUUDUUDUDUDUUUUDUDUDUDUDUUUUUUUUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUDUUUUDUDUUUUUU 872
    @wc -c r.c

Answer 22

गणितज्ञ, ११४ १२० बाइट्स

(d=#~Max~1-1&;u=#+1&;r=1&;s=StringToStream@ToLowerCase@#;l=1;t=1;While[(l=ToExpression[s~Read~Character]@l)<=#2,t++];t)&

अनाम फ़ंक्शन, जो दो तर्क (C, N) लेता है। इसे इस्तेमाल करने वाले सावधान, क्योंकि यह खुलने वाली धारा को बंद नहीं करता है। इसके अलावा यह विश्व स्तर पर अपने सभी चर प्रदान करता है।

के d=#-1&साथ बदलने के लिए संपादित किया गया है d=#~Max~1-1&, ताकि लूट खोदने न जाए।

Comments

प्रतीक्षा करें: मुझे नहीं लगता कि यह मान्य है। यह रोबोट को नेगेटिव रूंग नीचे जाने देता है। ओह। यह मुझे गैर-व्यापक रूप से परीक्षण करने के लिए सिखाएगा ... मुझे मौका मिलने पर एक सुधार करना होगा।

— hYPotenuser

Answer 23

गणितज्ञ, 112 बाइट्स

i=0;First@Position[ToExpression["{"<>#~StringReplace~{"U"->"i++,","D"->"i=i~Max~1-1,","R"->"i=0,"}<>"0}"],#2-1]&

Answer 24

क्लोजर, 92 84 बाइट्स

nशून्य से शून्य के बजाय मायने रखता है n, उपयोग कर सकते हैं take-while pos?।

#(count(take-while pos?(reductions(fn[p o](if o(min(o p 1)%)%))%(map{\U -\D +}%2))))

मूल:

#(count(take-while(partial > %)(reductions(fn[p o](if o(max(o p 1)0)0))0(map{\U +\D -}%2))))

मैप्स Uटू टू +, Dटू -और अन्य को nil। फ़ंक्शन को कम करना (operand position 1)गैर-अशक्त operandऔर 0अन्यथा के साथ चलता है । मान तब तक लेता है जब तक हम 1 इनपुट तर्क से अधिक नहीं होते हैं और गिनते हैं कि हमें कितने मिले हैं।

Answer 25

गणितज्ञ, 67 बाइट्स

(p=i=0;While[p<#,p=Switch[#2[[++i]],"U",p+1,"D",1~Max~p-1,_,0]];i)&

दो तर्कों के कार्य, एक सकारात्मक पूर्णांक और पात्रों की एक सूची, जो एक सकारात्मक पूर्णांक लौटाता है। Whileअन्य मैथेमैटिका प्रविष्टियों की तुलना में अधिक सरल कार्यान्वयन, जिसके परिणामस्वरूप अधिक प्रतिस्पर्धात्मक लंबाई होती है।