मोटरसाइकिल गियर चेकर!

Question

आप में से कुछ इस तरह से परिचित हो सकते हैं कि एक मोटरसाइकिल शिफ्ट हो जाती है। लेकिन जो नहीं करते हैं, उनके लिए यह ऐसा दिखता है

6

5

4

3

2

एन

1

अब मैं जानना चाहता हूं कि कुछ अप और डाउन शिफ्ट करने के बाद मैं किस गियर में हूं। कार्यक्रम को तटस्थ से काम करना चाहिए।

नमूना इनपुट:

V^^

नमूना उत्पादन:

2

जैसा कि आप देख सकते हैं कि मैंने N से 1 तक एक बार डाउनशिफ्ट किया और दो बार 2 गियर में अपशिफ्ट किया।

यह एक कोड गोल्फ है। बाइट्स जीत में सबसे छोटा जवाब।

नोट: इनपुट किसी भी 2 वर्ण का हो सकता है। ऊपर और नीचे के लिए यू और डी हो सकता है या आप जो भी चाहते हैं उसे एक स्ट्रिंग होना चाहिए । आप 1 या 6 वें गियर से आगे नहीं बढ़ सकते। यदि आप 6 वें में हैं और फिर से ऊपर उठा रहे हैं तो यह 6 वें स्थान पर रहेगा। सौभाग्य!

Comments

अगली बार, कृपया सैंडबॉक्स में अपनी चुनौती पोस्ट करें, इसे मुख्य पर पोस्ट करने से पहले प्रतिक्रिया प्राप्त करें

— fəˈnɛtɪk

@ शेषमारा केवल दो आवश्यकताएं हैं जिन्हें एक स्ट्रिंग होना है और आप केवल 2 वर्णों को इनपुट कर सकते हैं। तो एक चरित्र के रूप में एक नई पंक्ति का उपयोग कर सकता है। लेकिन अगर आप इसे किसी अन्य कारण से उपयोग करेंगे, तो मुझे वास्तव में कोई आपत्ति नहीं है। यह देखना दिलचस्प होगा कि आपके मन में क्या है। लेकिन एक छोटा स्पष्टीकरण दें कि आपने ऐसा क्यों किया है। जीएल!

— मार्टिन विंस

यह शर्म की बात है कि यह 1 और एन के बीच आधे चरण की पारी के लिए जिम्मेदार नहीं है। यह न केवल 2 एन 1 एन 2 3 पर जाने में सक्षम होगा, बल्कि 2 1 एन 2 3

— कॉर्ट अमोन

मैं @CortAmmon से सहमत हूं - 1 और 2 के बीच एक ही बदलाव है। यह आधा बदलाव है जहां तटस्थ है।

— Džuris

नहीं सभी मोटरसाइकिल इस तरह से बदलाव। अधिकांश क्लचलेस मोटरसाइकिल एन-1-2-3-4 (या कुछ बहुत प्राचीन वाहनों पर एन-1-2-3) में बदल जाती हैं। उनके पास गियर 5 या 6 नहीं है और एक गोल गियर का उपयोग करते हैं, अर्थात जब यह 4 है तब गियर बढ़ने से यह एन के चारों ओर लपेट जाएगा

— phuclv

Answer 1

जावास्क्रिप्ट (ईएस 6), 49 48 47 46 बाइट्स

उम्मीद:

• 1 नीचे के लिए
• 7 ऊपर के लिए

f=([c,...s],g=2)=>c?f(s,g-c&7||g):'1N'[--g]||g

प्रारूपित और टिप्पणी की गई

f = (                   // f is a recursive function which takes:
  [c,                   // - c = next character in input string
      ...s],            // - s = remaining characters
  g = 2                 // - g = current gear, with default = neutral = 2
) =>                    //
  c ?                   // if there's still a character to process:
    f(                  //   do a recursive call with:
      s,                //     - the remaining characters
      g - c & 7 ||      //     - the updated gear if it is valid
      g                 //       or the previous gear if not
    )                   //
  :                     // else:
    '1N'[--g] ||        //   decrement g and output '1' for g = 0, 'N' for g = 1,
    g                   //   or simply the corresponding digit for other values

इस प्रकार गियर को मैप किया जाता है:

g MOD 8 = 0 1 2 3 4 5 6 7
          ---------------
gear    = X 1 N 2 3 4 5 6       (where 'X' is an invalid state)

जो हमें वर्तमान गियर की वैधता की आसानी से जांच करने की अनुमति देता है:

(g & 7) != 0

डेमो

f=([c,...s],g=2)=>c?f(s,g-c&7||g):'1N'[--g]||g

console.log(f(''))
console.log(f('1'))
console.log(f('11'))
console.log(f('17777'))
console.log(f('1777777771'))

Answer 2

05AB1E , 22 20 बाइट्स

Îvy<+®‚Z5‚W}6LÀ'N¸ìè

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

व्याख्या

Î                      # push 0 (accumulator) and input
 v         }           # for each in input
  y<+                  # decrement current element and add to accumulator
     ®‚Z               # take maximum of current value and -1
        5‚W            # take minimum of current value and 5
            6L         # push the range [1 ... 6]
              À        # rotate left
               'N¸ì    # prepend the letter "N" producing the list [N, 2, 3, 4, 5, 6, 1]
                   è   # index into this list with the value produced by the loop

Answer 3

MATL, 32 28 23 बाइट्स

5 बाइट्स @Luis की बदौलत बच गईं

'234561N'j!Uq[aA]&Ys0))

यह समाधान '2'अप-शिफ्ट के लिए और '0'डाउन-शिफ्ट के लिए उपयोग करता है ।

इसे MATL ऑनलाइन पर आज़माएं

व्याख्या

'234561N'   % Push the string literal to the stack
j           % Grab the input as a string
!U          % Convert the input to a numeric array based on the characters.
q           % Subtract 1 to turn '2' into 1 and '0' into -1
[aA]        % Push the array [-1 5] to the stack
&Ys         % Compute the cumulative sum using the array [-1, 5] as
            % the upper and lower limits at each point
0)          % Get the last value from the cumulative sum
)           % Use this to index into the initial string literal.
            % Implicitly display the result

Comments

@Lifless एक स्पष्टीकरण के साथ अपडेट किया गया

— Suever

बहुत अच्छा! क्या मैं पूछ सकता हूं कि 1n23456 या 65432n1 के बजाय स्ट्रिंग 234561N क्यों है? मुझे भी एक दोष मिला! यदि आप इसे ऊपर रखते हैं तो इसे 6 वें गियर में रहना चाहिए लेकिन यह N

— Martijn Vissers

अच्छा! कम्सुम में सीमा के बारे में पता नहीं था

— बी मेहता

@ बी.मेहता मुझे ना! लुइस ने इसकी सिफारिश की

— स्वेवर

@ B.Mehta इसके अलावा, हमें MATL चैट रूम में शामिल होने के लिए स्वतंत्र महसूस करें !

— स्वेवर

Answer 4

वी , 20 , 15 बाइट्स

:sil!î¬61énÀxVp

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

इनपुट h(ऊपर) और l(नीचे) वर्णों की एक स्ट्रिंग है ।

5 बाइट्स बचाने और मुझे एक विम फीचर के बारे में सिखाने के लिए @nmjcman का धन्यवाद, जिनके बारे में मुझे कभी पता नहीं था!

यदि हम मान सकते हैं कि इनपुट कभी भी सीमा से बाहर नहीं जाता है, तो यह केवल 9 बाइट्स होगा:

¬61énÀxVp

लेकिन दुर्भाग्य से इसकी अनुमति नहीं है।

स्पष्टीकरण:

:sil!           " If the cursor goes out of bounds, ignore it and continue
     î          " Run the following keystrokes as V code, rather than vimscript:
      ¬61       "   Insert the string "654321". This will leave the cursor on the '1'
         én     "   Insert an 'n'
           À    "   Run the first arg as V code. This will move left and right a bunch of times
            x   "   Delete whatever character we ended up on
             V  "   Select this whole line,
              p "   And replace it with the character we just deleted

Comments

इसके अलावा, यह ऑनलाइन कोशिश करो! वी संपीड़न। यह अच्छा है।

— nmjcman101

वास्तव में, मुझे लगता है कि यह काम नहीं करता है क्योंकि 1/6 से अधिक या नीचे जाने से मैक्रो टूट जाता है: /

— nmjcman101

9 बाइट के उत्तर की अनुमति क्यों नहीं है?

— अल्बर्ट रेनशॉ

@AlbertRenshaw यह विफल हो जाता है यदि आप कभी भी 1 या 6 वें गियर से परे शिफ्ट करने का प्रयास करते हैं। उदाहरण के लिए इसे ऑनलाइन आज़माएं! आउटपुट चाहिए n, नहीं 1।

— DJMcMayhem

ओह, मैं देख रहा हूं, मुझे लगा कि इनपुट हमेशा वैध होता है, जिसका मतलब है कि आप गैर-स्थानांतरण वर्ण हैं। फिर भी एक ठंडा जवाब भले ही इसका अमान्य हो

— अल्बर्ट रेनशॉ

Answer 5

जावा 7, 106 105 103 बाइट्स

char c(String s){int r=1;for(int c:s.toCharArray())r+=c<99?1:-1;return"1N23456".charAt(r<0?0:r>6?6:r);}

स्पष्टीकरण:

char c(String s){                // Method with String input and character return-type
  int r = 1;                     // Result-index (0-indexed and starting at 1)
  for(int c : s.toCharArray()){  // Loop over all characters in the input String
    r += c < 99 ?                //  If the current character is '^':
           1                     //   Raise the result-index by 1
         :                       //  If it is 'v' instead:
           -1;                   //   Decrease the result-index by 1
  }
  return "1N23456".charAt(       // Return the character based on the return-index:
           r < 0 ?               //  If the result-index is below 0
                  0              //   Use 0 instead
                 : r > 6 ?       //  Else-if the result-index is above 6
                          6      //   Use 6 instead
                         :       //  Else
                          r);    //   Use the result-index
}

टेस्ट कोड:

इसे यहाँ आज़माएँ।

class M{
  static char c(String s){int r=1;for(int c:s.toCharArray())r+=c<99?1:-1;return"1N23456".charAt(r<0?0:r>6?6:r);}

  public static void main(String[] a){
    System.out.println(c("v^^"));
    System.out.println(c("^^^^^^^^"));
    System.out.println(c("vvvv^^^vvvv"));
    System.out.println(c("^v^v^v^v"));
  }
}

आउटपुट:

2
6
1
N

Answer 6

हास्केल, 59 53 51 बाइट्स

("1N23456"!!).foldl(\l c->max 0$min 6$l+read[c]-1)1

0नीचे और 2ऊपर के लिए उपयोग करता है । उपयोग उदाहरण:

(("1N23456"!!).foldl(\l c->max 0$min 6$l+read[c]-1)1) "0002"

6 बाइट्स उतारने के लिए @xnor को धन्यवाद! इसके अलावा, मुझे पता है कि मुझे किसी फ़ंक्शन नाम या कोष्ठक की आवश्यकता नहीं है ताकि कोई अन्य 2 बाइट्स हो।

Comments

यदि आप इनपुट वर्ण को 0 और 2 के रूप में लेते हैं, तो आप कर सकते हैं read[c]-2।

— xnor

PPCG में आपका स्वागत है! बेनामी कार्यों भी ठीक है ताकि आप की जरूरत नहीं है कर रहे हैं, g=।

— लाकोनी

@ लिकोनी मुझे इसे कोष्ठक में लपेटना होगा, है ना? यह बाइट की गिनती को नहीं बदलेगा, इसलिए मैंने सोचा कि मैं इसे छोड़ g=

— दूंगा

@ user1472751 आपको

— फल को तोड़ना

Answer 7

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

s=>"1N23456"[[1,...s].reduce((a,b)=>a?a<6?+b?a+1:a-1:6:0)]

प्रयोग

इसे किसी फ़ंक्शन में असाइन करें, और फिर इसे कॉल करें। इनपुट एक स्ट्रिंग है जिसमें 1अपशिफ्ट के लिए, और डाउनशिफ्ट के लिए एक स्ट्रिंग है 0।

f=s=>"1N23456"[[1,...s].reduce((a,b)=>a?a<6?+b?++a:a--:6:0)]
f("011")
-> "2"
f("0")
-> "1"
f("01")
-> "N"

Comments

f (0) रिटर्न 1 नहीं N ... और आपका कोड अपरिभाषित होता है यदि आप 6 से ऊपर या 1 से नीचे जाते हैं

— fɛn Febtəˈk

अच्छी पकड़। दो बाइट्स की लागत से निर्धारित

— ल्यूक

इनपुट काम नहीं करता है जैसे कि एनf("001") को वापस कैसे करना चाहिए (गियर 1 से नीचे, गियर डाउन 1 पर रहना, गियर तक एन)

— एमिगा

लूप के आसपास नहीं माना जाता है। यह 6 से ऊपर रहना चाहिए, अगर 6 से ऊपर की ओर

— बढ़े

Answer 8

PHP 7.1, 71 बाइट्स

for(;$c=$argv[1][$i++];))$g=max(-1,min($g+=$c<=>X,5));echo N234561[$g];

$g-1 से 5 तक की शिफ्ट , पहले गियर के लिए नकारात्मक स्ट्रिंग ऑफसेट का उपयोग करता है।
साथ चलाएं -nr, कमांड लाइन तर्क के रूप में स्थानांतरण स्ट्रिंग प्रदान करें।

Answer 9

जेली , 17 14 बाइट्स

1;r2ị$¥/CỊ¡o”N

6ऊपर और 0नीचे के लिए उपयोग करता है ।

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

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

1;r2ị$¥/CỊ¡o”N  Main link. Argument: s (string of 6's and 0's)

1;              Prepend a 1 (integer) to the string/character array s.
       /        Reduce the result by the following dyadic link.
                Let's call the arguments x and y.
      ¥           Create a dyadic chain of 2 links:
  r                 Construct the range [x, ..., y] (increasing or decreasing).
                    y will be a character, but 'r' casts both argument to int.
                    This is intended for use with floats, but it works just as well
                    when the argument is a digit.
     $              Create a monadic chain of two links:
   2ị                 Take the second element of the constructed range.
                  When y = 6 > x, this gives x + 1.
                  When y = 0 < x, this gives x - 1.
                  When y = x, the range is a singleton array, so this gives x.
          ¡     Conditional application:
         Ị        If the previous result is insignificant (0 or 1):
        C           Subtract it from 1.
                This swaps 0 and 1 without affecting the other potential outcomes.
           o”N  Logical OR with 'N', replacing 0 with that character.

Answer 10

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

->s{a=1;s.chars{|b|a-=[a<=>0,a<=>6][b<=>?v]};"1N23456"[a]}

अपेक्षित इनपुट एक डाउनशिफ्ट के लिए 'v' और अपशिफ्ट के लिए '^' है

Answer 11

प्रसंस्करण जेएस (संशोधित) 121 बाइट्स

var g="1N23456",a="",c=0; for(var i=0;i<a.length;i++){if(a[i]==="d"&&c>0){c--;}else if(c<6&&a[i]==="u"){c++;}}println(g[c]);

Ungolfed

var g=[1,"N",2,3,4,5,6],a="",c=0;
for(var i=0;i<a.length;i++)
{if(a[i]==="d"&&c>0)
{
    c--;

}else if(c<6&&a[i]==="u")
{
    c++;

}

}
println(g[c]);

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

मैं पीजे के साथ गया था क्योंकि मैं इसे अच्छी तरह से जानता हूं। एकमात्र समस्या संस्करण है जिसका मैं उपयोग करता हूं बहुत सख्ती से टाइप किया गया है। मैं कोष्ठक और बहुत सारी अन्य चालें नहीं छोड़ सकता। यह बहुत सरल है। इनपुट को चर में जाना चाहिए aऔर इसे लोअरकेस में ले जाना चाहिए u d। कार्यक्रम तब तक लूप करता है जब तक यह स्ट्रिंग के अंत को हिट नहीं करता है और प्रत्येक पुनरावृति यह देखने के लिए जांचता है कि क्या यह अनु या डी है। यदि यह है और यह कोशिश नहीं करेगा और "शिफ्ट" अतीत जहां आप इसे स्थानांतरित कर सकते हैं। अंत में मैं परिणाम प्रिंट करता हूं!

Comments

यदि आपका संस्करण टर्नरी ऑपरेटरों को अनुमति देता है, तो आप अपने आइएफएस को अधिक छोटे तरीके से फिर से लिखने में सक्षम हो सकते हैं, मुझे लगता है।

— बोजीदार मारिनोव

The input should go into the variable aहार्ड कोडित इनपुट का उपयोग करना डिफ़ॉल्ट इनपुट विधि नहीं है, यहां देखें ।

— लकोनी

@ लायकोनी वास्तव में? वह मूर्खतापूर्ण है। मेरे पास कोई बेहतर तरीका नहीं है। अगर मुझे इसे फिर से करना है तो यह ~ 100 बाइट्स लंबा होगा

— क्रिस्टोफर

क्या आप किसी फ़ंक्शन में अपना कोड नहीं लपेट सकते? उदाहरण के लिए। void f(String[] a){...}यह मुश्किल से 100 बाइट्स है।

— लकोनी

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

— कृति लिथोस

Answer 12

k, 25 बाइट्स

"1N23456"@{6&0|x+y-92}/1,

यह एक स्ट्रिंग के रूप में इनपुट लेता है, और [डाउनशिफ्ट, और ]अपशिफ्ट के लिए उपयोग करता है , क्योंकि वे आसानी से स्थित हैं।

"1N23456"@                / the numbers 0 to 6 are used for the gears,
                          / this turns them into the correct number/letter
                       1, / prepend 1 because this is our initial gear
          {          }/   / fold the function through the list
                          / x is before, y is the next character
                 y-92     / subtract 92, which is between "[" and "]"
                          / "[" becomes -1 and "]" becomes 1
               x+         / add it to what we had before
           6&0|           / use max and min to set boundaries 6 and 0

उदाहरण:

 shift:"1N23456"@{6&0|x+y-92}/1,
 shift"[]]"
"2"
 shift"]]]]]]]]"
"6"
 shift"[[[[]]][[[["
"1"
 shift"[][][][]"
"N"
 shift"[[[[[[[[]"
"N"
 shift"]]]]]]]]["
"5"

Answer 13

GNU sed , 89 87 + 1 (आर झंडा) = 88 बाइट्स

क्योंकि sed में कोई पूर्णांक प्रकार या अंकगणितीय संक्रियाएं नहीं हैं, इसलिए समाधान केवल नियमित अभिव्यक्तियों का उपयोग करके किया जाता है।

s:$:65432Nx1:
:
/6x/!s:^U(.*)(.)x:\1x\2:
s:^D(.*)x(.):\1\2x:
t
s:U|D::
t
s:.*(.)x.*:\1:

यह xप्रत्येक इनपुट शिफ्ट के आधार पर पॉइंटर को स्लाइड करके काम करता है , बाएं ( Uपी के लिए) या दाएं ( Dखुद के लिए), एक गैर-रैपिंग टेप के साथ जिसमें केवल कोशिकाएं होती हैं 65432N1। अंत में उत्तर सूचक के बाएं सेल में मूल्य है।

उदाहरण रन: या इसे ऑनलाइन आज़माएं!

sed -rf gear.sed <<< "UUUUUUD"
5

स्पष्टीकरण:

s:$:65432Nx1:              # assign initial tape and pointer
:                          # start loop
/6x/!s:^U(.*)(.)x:\1x\2:   # if shift 'U', slide `x` to left, but not past the edge
s:^D(.*)x(.):\1\2x:        # if shift 'D', slide `x` to right, -||-
t                          # repeat
s:U|D::                    # if a shift couldn't be applied, delete it "manually",
t                          # and jump to the start of the loop again
s:.*(.)x.*:\1:             # print value left of pointer `x` (answer)

Comments

यहाँ 76 बाइट्स हैं , लेकिन यह यूनिरी में आउटपुट करता है।

— रिले

@ रिले यूनरी, बिल्कुल! ठीक है, आपका समाधान अलग है, इसलिए इसे पोस्ट नहीं करें!

— शीशमारा

आपके लिए मुझे इसकी प्रेरणा मिली। मुझे लगा कि अगर तुम चाहो तो मैं तुम्हें इसका उपयोग करने दूंगा

— रिले

@ रिले तब मैं आपके संस्करण और क्रेडिट के साथ एक अलग अनुभाग बनाऊंगा।

— शीशमारा

मैं बस अपनी खुद की :)

— रिले

Answer 14

GNU sed , 76 73 बाइट्स

के लिए +1 शामिल है -r

s/$/1/
:
/1{6}/!s/^U(.*)/\11/
s/^D(.*)1/\1/
t
s/U|D//
t
s/^1$/N/
s/^$/1/

आउटपुट तटस्थ को छोड़कर एकात्मकता में है, जो अभी भी है N( इस सहमति को देखें )।

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

यह मूल रूप से एकरी में ऊपर और नीचे गिना जाता है फिर 1 से N और 0 से 1 में परिवर्तित होता है।

s/$/1/               # add 1 to the end (the starting value)
:                    # loop start
/1{6}/!s/^U(.*)/\11/ # If the string starts with 'U' and doesn't have 6 ones, increment
s/^D(.*)1/\1/        # If the string starts with 'D' decrement (but not past 0)
t                    # if something changed loop back
s/U|D//              # if the U or D couldn't be applied, remove it.
t                    # if something changed loop back
s/^1$/N/             # replace 1 with N
s/^$/1/              # if "0", replace with 1

Comments

यदि आप 1शुरुआती मूल्य के रूप में N, और कुछ भी नहीं के रूप में काम करते हैं, तो मेरा sed संस्करण 4 बाइट्स से छोटा हो सकता है 1। s/$/1/;:;/1{6}/!s/^U(.*)/\11/;s/^D(.*)1/\1/;t;s/U|D//;t;s/^1$/N/;s/^$/1/

— शीशमारा

Answer 15

रीबोल, 96 93 बाइट्स

f: func[s][g: next"1N23456"parse s[any["D"(g: back g)|"U"(unless tail? x: next g[g: x])]]g/1]

Ungolfed:

f: func [s] [
    g: next "1N23456"
    parse s [
        any [
              "D" (g: back g)
            | "U" (unless tail? x: next g [g: x])
        ]
    ]
    g/1
]

उदाहरण का उपयोग (रीबोल कंसोल में):

>> print f "DUU"         
2

>> print f "DDDUU"
2

>> print f "UUUUUUUUU"  
6

>> print f "UUUUUUUUUD"
5

Answer 16

> <> , 35 बाइट्स

कोड का एक उत्साही टुकड़ा जो आपको गति सीमा से ऊपर ड्राइव करने के लिए प्रोत्साहित करता है।

किसी भी दो इनपुट को स्वीकार करता है जिसका कोड modulo 3 0 और 2 हैं, उदाहरण के लिए 0और 2।
अतिरिक्त मछली पालन के लिए, मैं <और के उपयोग की सलाह देता हूं >।

1i:0(?;3%1-+:0(?0:6)?6:1go!
1N23456

स्पष्टीकरण:

1i:0(?;3%1-+:0(?0:6)?6:1go!
1                             # initial position
 i                            # read the next char
  :0(?;                       # copies it, test copy against 0, if lower stops (EOF detection)
       3%1-                   # map the char to -1 or 1
           +                  # add it to the position
            :0(?0             # if the new position is lower than 0, set to 0
                 :6)?6        # if the new position is greater than 6, set to 6
                      :1go    # output a character from line 1 at the position
                          !   # loops and skip the position initialisation

आप इसे यहाँ आज़मा सकते हैं !

Answer 17

SpecBAS - 102

1 g=2: INPUT s$
2 FOR i=1 TO LEN s$
3 g+=(s$(i)="^" AND g<7)-(s$(i)="v" AND g>1)
4 NEXT i
5  ?"1N23456"(g)

इनपुट के आधार पर स्ट्रिंग के सूचकांक को स्थानांतरित करता है और संबंधित चरित्र को प्रिंट करता है।

Answer 18

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

J1VQ=JhtS[06+J-qNbqNd;?qJ1\N?JJ1

नीचे और ऊपर के लिए स्थान और न्यूलाइन का उपयोग करता है।

व्याख्या

J1VQ=JhtS[06+J-qNbqNd;?qJ1\N?JJ1
J1                                 Initialize J to 1
  VQ                 ;             For each character in the input
            +J-qNbqNd              Increment or decrement J
      htS[06                       Get the middle sorted value of [0,6,J]
    =J                             Assign it to J
                      ?qJ1\N?JJ1   Change 1 to 'N' and 0 to 1

वेतन वृद्धि और आउटपुट करने का लगभग एक बेहतर तरीका है।

Answer 19

CJam , 24 22 बाइट्स

"1N23456"1q{~0e>6e<}/=

(नीचे और )ऊपर के लिए उपयोग करता है ।

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

व्याख्या

"1N23456"               e# Push the string containing all gears
         1              e# Push 1, the initial index
          q             e# Push the input
           {            e# For each character in the input
            ~           e#   Eval that character. ( is decrement and ) is increment.
             0e>        e#   Take the maximum of (0, index)
                6e<     e#   Take the minimum of (6, index)
                   }/   e# (end of block)
                     =  e# Take that index of the string

Answer 20

बैच, 144 बाइट्स

@set/ps=
@set g=1
:l
@if %g% neq %s:~,1% set/ag+=%s:~,1%/3-1
@set s=%s:~1%
@if not "%s%"=="" goto l
@if %g%==1 (echo N)else cmd/cset/ag+!g

STDIN पर इनपुट लेता है, 0एक निचले गियर 6में जाने के लिए और एक उच्च गियर में जाने के लिए। वर्तमान गियर को अनदेखा करना आसान बनाने के लिए इन नंबरों को चुना गया था। अंत में यदि गियर 1तब Nमुद्रित होता है अन्यथा 0परिवर्तित किया जाता है 1और गियर को प्रिंट किया जाता है।

Answer 21

जावास्क्रिप्ट ईएस 6 नॉनस्ट्रिक्ट, 136 120 चार्ट

136 चरस के लिए V^

with({get x(){return Math.max(0,Math.min(y,6))},set x(v){y=v}})f=s=>eval(s.replace(/(V)|./g,(m,v)=>`x${"-+"[+!v]}=1,`,y=1)+'"1N"[x]||x')

with({get x(){return Math.max(0,Math.min(y,6))},set x(v){y=v}})
f=s=>eval(s.replace(/(V)|./g,(m,v)=>`x${"-+"[+!v]}=1,`,y=1)+'"1N"[x]||x')
console.log(f("V^^"))

के लिए 120 रु -+

with({get x(){return Math.max(0,Math.min(y,6))},set x(v){y=v}})f=s=>eval(s.replace(/./g,m=>`x${m}=1,`,y=1)+'"1N"[x]||x')

with({get x(){return Math.max(0,Math.min(y,6))},set x(v){y=v}})
f=s=>eval(s.replace(/./g,m=>`x${m}=1,`,y=1)+'"1N"[x]||x')
console.log(f("-++"))

Answer 22

रेटिना , 65 बाइट्स

^
1 N23456
+(` (.)?(\w*6)u
$1 $2
)`(.)? (\w*6)d
 $1$2
.* (.).*
$1

उपयोग करता है uऔर dऊपर और नीचे के लिए।

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

व्याख्या

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

^
1 N23456

1 N23456इनपुट से पहले लगाकर शुरू करें । इससे पहले Nकि अंतरिक्ष इंगित करता है कि Nवर्तमान गियर है।

+(` (.)?(\w*6)u
$1 $2
)`(.)? (\w*6)d
 $1$2

ये दो प्रतिस्थापन चरण हैं, जिन्हें एक साथ समूहीकृत किया जाता है और तब तक चलाया जाता है जब तक वे स्ट्रिंग को बदलना बंद नहीं करते हैं:

 (.)?(\w*6)u
$1 $2

पहले वाले गियर को ऊपर की ओर शिफ्ट करने का काम करता है। यह अंतरिक्ष के बाद किसी भी संख्या में गियर की तलाश करेगा 6, उसके बाद ए , उसके बाद u( uगियर शिफ्ट करने के निर्देश को इंगित करता है)। यदि 6 से पहले वर्ण थे, तो यह इसके तुरंत बाद वर्ण के साथ स्थान को स्वैप करता है, हटाता है uऔर बाकी स्ट्रिंग अक्षर को छोड़ देता है। चूंकि 6मैच में यह अनिवार्य है, यह केवल पहले किसी भी चरित्र के साथ अंतरिक्ष स्वैप करेगा 6। यह के साथ स्वैप कभी नहीं होगा 6।

(.)? (\w*6)d
 $1$2

दूसरा चरण गियर शिफ्टिंग को संभालता है, और इसी तरह काम करता है। यह अंतरिक्ष से पहले एक चरित्र है, तो कुछ अन्य गियर में समाप्त होने के बाद के लिए वैकल्पिक रूप से लग रहा है 6, के बाद d। यह चरित्र के साथ अंतरिक्ष को स्वैप करता है इससे पहले, हटाता है d, और बाकी को बरकरार रखता है। यदि अंतरिक्ष स्ट्रिंग की शुरुआत में था, तो अंतरिक्ष से पहले एक चरित्र के लिए कोई मैच नहीं था, इसलिए कोई स्वैप नहीं होता है।

.* (.).*
$1

उपर्युक्त प्रतिस्थापनों में से कोई भी अब नहीं किया जा सकता है, सभी गियर शिफ्ट पूरे हो गए हैं। अंतरिक्ष के तुरंत बाद गियर को छोड़कर लाइन को सब कुछ साफ कर दिया जाता है। यह अंतिम गियर है।

Answer 23

पॉवर्सशेल, 112 87 85 बाइट्स

$i=1;switch([char[]]$args[0]){'^'{if(5-gt$i){$i++}}'v'{if(1-le$i){$i--}}}'1N2345'[$i]

ungolfed

$i=1;                                # index which gear we are in
switch([char[]]$args[0]){            # loop over all elements using a switch
  '^'{if(5-gt$i){$i++}}             # if there is a ^ and we are not in sixth yet, shift up
  'v'{if(1-le$i){$i--}}             # if there is a v and we are not in first, shift down
}
'1N2345'[$i]                         # print the output

पॉवरशेल कोडगॉल्फ टिप्स पढ़कर 25 बाइट्स बचाए

gt / le ऑपरेटरों को फ़्लिप करके 2 बाइट्स सहेजे गए

Answer 24

पर्ल 6, 144 बाइट्स

my enum C <1 N 2 3 4 5 6>;my $n=prompt("");my $p=1;for split("",$n) ->$l {$l eq "u" && $p < 6 ?? ++$p !! 0;$l eq"d"&&$p>0 ?? --$p!!0};say C($p);

जैसा होना चाहिए वैसा ही काम करता है। सुधारों का स्वागत है। पहली बार किसी भी चीज़ के लिए पर्ल का उपयोग करना, लेकिन मुझे भाषा के बारे में सोचना पसंद था, इसलिए मुझे कोशिश करनी थी।

Answer 25

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

#((vec "1N23456")(reduce(fn[c s](max 0(min 6((if(= s \^)inc dec)c))))1 %))

अनुक्रमणिका के रूप में एक इंडेक्स बनाए रखते हुए, शिफ्ट स्ट्रिंग पर सिलवटों। प्रत्येक पुनरावृत्ति इसे या तो बढ़ाता है या सूचकांक को घटाता है, फिर इसे 0-6 की सीमा में बांध देता है। अंत में, गियर को पकड़े हुए एक स्ट्रिंग को अनुक्रमित किया जाता है और वापस किया जाता है।

वर्तमान गियर का प्रतिनिधित्व करते हुए एक क्लोजर वर्ण देता है। गियर 1 के रूप में लौटा है \1, और गियर 'एन' के रूप में लौटा है \N।

पूर्व गोल्फ विवरण। संख्याओं का पालन करें, क्योंकि यह अच्छी तरह से टॉप-डाउन नहीं पढ़ता है।

; Expects ^ for shift-up, and V (or anything else) for shift down
; Returns a character representing the current gear
(defn shift [shift-str]
  ((vec "1N23456") ; 4. Then index the gear list with the calculated index, and return
   (reduce (fn [current-gear s] ; 1. Fold over the shift symbols
             (max 0 (min 6 ; 3. Clamp it to the range 0-6 so we don't overflow
                      ((if (= s \^) inc dec) ; 2. If the shift is up, increase, else decrease
                       current-gear))))
           1
           shift-str)))

Answer 26

पायथन 3, 67 63 बाइट्स

k=1
for i in input():k+=[k<6,-(k>0)][i<'1']
print('1N23456'[k])

बहुत ही सीधा साधा समाधान।

-4 बाइट्स थैंक्स टू @ovs!