मेरी फिल्म कितनी निराशाजनक है?

Question

मेरे माता-पिता के पास एक होम थिएटर डिवाइस है। रिमोट टूट जाता है जिससे मेनू में दाईं ओर नेविगेट करना अविश्वसनीय रूप से कठिन हो जाता है। ज्यादातर समय यह काम नहीं करता है लेकिन जब यह करता है तो यह अविश्वसनीय रूप से जल्दी से सही ढंग से आगे बढ़ता है।

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

a b c d e f
g h i j k l
m n o p q r
s t u v w x
y z 1 2 3 4
5 6 7 8 9 0

आपका काम एक फिल्म शीर्षक के रूप में लेना है और यह गणना करना है कि उस फिल्म का शीर्षक टाइप करने के लिए "निराशाजनक" कैसे है। एक विशेष स्ट्रिंग की हताशा संख्या उन अक्षरों की संख्या है जिनके लिए उनके सामने पत्र से दाईं ओर बढ़ने की आवश्यकता होती है। हम परवाह नहीं करते हैं कि वे कितने सही हैं, क्योंकि अगर हम सही चलना शुरू करते हैं तो हम बहुत तुरंत लाइन के अंत में जाते हैं, और हम ऊपर, नीचे या बाईं ओर आंदोलन के बारे में परवाह नहीं करते हैं क्योंकि वे आसान हैं।

उदाहरण के लिए यदि हम टाइप करना चाहते हैं

keyboard

• हम kमुफ्त में शुरू करते हैं।
• eठीक ऊपर है kइसलिए हमें सही कदम उठाने की जरूरत नहीं है।
• y सभी तरह से छोड़ दिया है तो सही स्थानांतरित करने की कोई जरूरत नहीं है।
• b हालाँकि, अगले स्तंभ पर दाईं ओर है, इसलिए हमें इसे प्राप्त करने के लिए सही स्थानांतरित करने की आवश्यकता है।
• o अगले कॉलम पर है इसलिए हमें इसे प्राप्त करने के लिए दाईं ओर बढ़ना होगा।
• a पहले कॉलम में वापस आ गया है, इसलिए हम इसे पाने के लिए बाएं चलते हैं।
• r सभी तरह से दाईं ओर है, इसलिए हम इसे दाईं ओर ले जाते हैं।
• dस्तंभ के बाईं ओर दो rस्तंभ हैं।

जिन पात्रों को दाईं ओर ले जाने की आवश्यकता है, उनका borअर्थ है कि यह कुंठा 3 है।

अतिरिक्त नियम

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

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

keyboard -> 3
2001aspaceodyssey -> 6
sorrytobotheryou -> 8
thinblueline -> 5
blast2 -> 3

Comments

सुझाए गए परीक्षण का मामला: "blast2" -> 3(एक वास्तविक फिल्म नहीं, लेकिन कुछ उत्तरों में इस तरह के परीक्षण मामलों की समस्याएं हैं)

— अरनौल्ड

सुझाए गए परीक्षण के मामले: केवल 5 से एक अंक से मिलकर बनता है, जैसे कि 5 -> 0

— lirtosiast

सुझाया गया परीक्षण मामला:90 -> 1

— nwellnhof

क्या हम मान सकते हैं कि इनपुट स्ट्रिंग गैर-रिक्त होगी?

— चास ब्राउन

@ChasBrown यह प्रश्न में शामिल है।

— गेहूं जादूगर

Answer 1

जावास्क्रिप्ट (Node.js) , 61 55 54 बाइट्स

@Nwellnhof को 1 बाइट धन्यवाद दिया

वर्णों के एक सरणी के रूप में इनपुट लेता है।

s=>s.map(p=c=>r+=p>(p=(+c?~c:1-Buffer(c)[0])%6),r=0)|r

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

कैसे?

सभी वर्णों पर से अधिक अंकों के लिए , 0-अनुक्रमित स्तंभ द्वारा दिया गया है:$0$$x$

$$x=(c-1)\bmod 6$$

जहाँ अक्षर का ASCII कोड है।$c$

सकारात्मक अंक , हमें इसके बजाय करने की आवश्यकता है:$n$

$$x=(n+1)\bmod 6$$

उदाहरण:

"a" --> (97 - 1) mod 6 = 96 mod 6 = 0
"b" --> (98 - 1) mod 6 = 97 mod 6 = 1
"0" --> (48 - 1) mod 6 = 47 mod 6 = 5
"3" --> ( 3 + 1) mod 6 =  4 mod 6 = 4

टिप्पणी की गई

s =>                       // s = input string (as array)
  s.map(p =                // initialize p to a non-numeric value
  c =>                     // for each character c in s:
    r +=                   //   update the result r:
      p > (                //   compare p with
        p = (              //   the new value of p defined as:
          +c ?             //     if c is a positive digit:
            ~c             //       -(int(c) + 1)
          :                //     else:
            1-Buffer(c)[0] //       -(ord(c) - 1)
        ) % 6              //     apply modulo 6
      ),                   //   yields 1 if the previous value is greater than the new one
    r = 0                  //   start with r = 0
  ) | r                    // end of map(); return r

Comments

यह 46 बाइट्स के

— झबरा

@ शैगी यह नहीं होगा। मेरे सुझाए गए टेस्ट केस देखें "blast2"।

— अरनौलद

आह। उस मामले में: 53 बाइट्स

— झबरा

@ शैगी एक बिटवेट या के लिए असफल, कहना, होगा "234"।

— अरनौलद

कम व्हिस्की कभी जवाब नहीं है!

— झबरा

Answer 2

जेली , 11 बाइट्स

⁾04yO‘%6<ƝS

(अपरकेस) वर्णों की एक सूची को स्वीकार करने वाला एक अद्वैत लिंक।

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

कैसे?

पहले किसी भी '0'एस को एस के साथ बदल देता है '4'(इसलिए बाकी कोड उन्हें सबसे सही कॉलम में माना जाता है)। फिर ऑर्डिनल्स में जाती है, 60-आधारित कॉलम सूचकांकों को प्राप्त करने के लिए एक और modulo's को जोड़ता है । तब पड़ोसियों के साथ तुलना में कम-से-कम है और परिणाम का समर्थन करता है।

⁾04yO‘%6<ƝS - Link: list of characters         e.g. "BLAST20"
⁾04         - list of characters = ['0', '4']
   y        - translate                             "BLAST24"
    O       - ordinals                              [66,76,65,83,84,50,52]
     ‘      - increment                             [67,77,66,84,85,51,53]
       6    - literal six
      %     - modulo                                [ 1, 5, 0, 0, 1, 3, 5]
         Ɲ  - neighbourly:
        <   -   less than?                          [  1, 0, 0, 1, 1, 1  ]
          S - sum                                   4

Comments

ओह माय, यह कला है।

— को आउटगोल्फर

Answer 3

पर्ल 6 , 45 39 बाइट्स

{sum .[1..*]Z<$_}o{(2 X-.ords)X%46 X%6}

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

अपरकेस अक्षरों के साथ काम करता है। (2-ord(c))%46%6उलट एक्स समन्वय स्थापित करता है।

Answer 4

साफ , 85 बाइट्स

import StdEnv
(\s=sum[1\\a<-s&b<-tl s|b>a])o map(\e=(toInt e+if(e-'1'>'/')1 -1)rem 6)

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

Answer 5

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

->s{w=9;s.count{|c|w<w=[*?a..?z,*?1..?9,?0].index(c)%6}}

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

प्रारंभिक भोले संस्करण, गोल्फ होगा।

Answer 6

जाप -x , 14 बाइट्स

®rT4 c Ä u6Ãä<

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

इस जैली जवाब का पोर्ट । अक्षरों की एक सरणी के रूप में इनपुट लेता है, अक्षरों के साथ अपरकेस।

स्पष्टीकरण:

®rT4 c Ä u6Ãä<    :
®          Ã      :Map each character through:
 rT4              : Replace 0 with 4
     c            : Get the char-code
       Ä          : Increment it
         u6       : Modulo 6
            ä<    :Replace with 1 if you had to move right, 0 otherwise
                  :Implicitly sum and output

Answer 7

जावा (ओपनजेडके 8) , 73 बाइट्स

जावा के लिए एक बुरा समाधान नहीं है! दायें हाथ की तरफ शून्य होने से मुझे कई बाइट्स खर्च करने पड़े।

t->{int a=9,c=0;for(int d:t)c+=a<(a=(--d+(d/48==1?2:0))%6)?1:0;return c;}

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

व्याख्या की

t -> {                          // Lambda taking a char array as input
    int a=9,                    // Initialise last column value
        c=0;                    // Initialise frustration count
    for(int d:t)                // Loop through all chars in title
        c+=                     // increment the frustration count if...
          a<                    // The last column is smaller than the current column
            (a=                 // Set last column to current column
              (--d+             // Decrement ascii value of char
                  (d/48==1      // If ascii decremented ascii value is between 48 and 95
                    ?2:0)       // increment by 2 (1 total) or 0 (-1 total)
                )%6)            // Mod 6 to retrieve column index
            ?1:0;               // Increment if to right hand side
    return c;                   // return calculated frustration count
}

Answer 8

05AB1E , 12 11 बाइट्स

-1 बाइट धन्यवाद @ केविन क्रूज़सेन को

¾4:Ç>6%¥1@O

जोनाथन एलन के जेली का एक और जवाब। अपरकेस में इनपुट लेता है।

स्पष्टीकरण:

¾4:Ç>6%¥1@O   //full program
¾4:           //replace all '0's with '4's
   Ç          //get ASCII code points
    >         //increment
     6%       //modulo 6
       ¥      //get deltas
        1@    //is >= 1
          O   //sum

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

Comments

0'4¾4एक बाइट ( प्रासंगिक 05AB1E टिप ) को बचाने के लिए किया जा सकता है ।

— केविन क्रूज़सेन

Answer 9

K (ngn / k) , 32 31 28 बाइट्स

+/>':6!(,/"a10"+!'26 9 1)?0+

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

Answer 10

रेटिना 0.8.2 , 46 बाइट्स

T`l1-90`1-61-61-61-61-61-6
.
;$&$*
&`;(1+);1\1

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

T`l1-90`1-61-61-61-61-61-6

OSK पर क्रम में वर्णमाला और अंकों को सूचीबद्ध करें और प्रत्येक को एक (1-अनुक्रमित) कॉलम नंबर पर मैप करें।

.
;$&$*

प्रत्येक स्तंभ संख्या को एकरूपता में बदलें।

&`;(1+);1\1

स्तंभों की संख्या की गणना करें जिनके बाद एक बड़ा (दाएं ओर) स्तंभ होता है। &`मैचों को ओवरलैप करने की अनुमति देता है।

Answer 11

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

def f(s,k=6):j=(ord(s[0])+('0'<s[0]<':')*2-1)%6;return(j>k)+(~-len(s)and f(s[1:],j))

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

Answer 12

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

Differences[Last@@Join[Alphabet[],ToString/@Range@9,{"0"}]~Partition~6~Position~#&/@#]~Count~_?(#>0&)&

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

Answer 13

PHP, 74 81 77 बाइट्स

for(;$o=ord($argn[$i]);$i++&&$f+=$p<$x,$p=$x)$x=(--$o/48^1?$o:$o+2)%6;echo$f;

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

Answer 14

सी (जीसीसी) ,  82 79  77 बाइट्स

o;c(i){i+=i<60&i>48?1:5;i%=6;}f(char*s){for(o=0;*++s;o+=c(*s)>c(s[-1]));o=o;}

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

यह फ़ंक्शन केवल लोअरकेस इनपुट का समर्थन करेगा

---

असंबद्ध और टिप्पणी:

o; //Used for output
c(i){             //Calculates the column of given character
     i+=          //Correct i to get the correct column
        i<60      //If i is a digit...
        & i>48   //... but not '0'
        ?1           //Then move it one column on the right
        :5;          //Else move it five columns on the right
     i%=6;        //Get the column number
}
f(char*s){                        // The actual "frustrating" function
          for(                    //Loop for each character
              o=0;                //reinitialize output
              *++s;               //move to next character / while this is not '\0'
              o+=c(*s)>c(s[-1])  //Increment if current character is on the right of the previous one
             );
           o=o;                   // Outputs result
}

---

यदि मेरे कार्य को विस्तृत वर्ण स्ट्रिंग्स को स्वीकार करने की अनुमति है, तो इसे 76 बाइट्स के साथ घटाया जा सकता है :

o;c(i){i+=i<60&i>48?1:5;i%=6;}f(int*s){for(o=0;*++s;o+=c(*s)>c(s[-1]));o=o;}

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

इस संस्करण के int*बजाय के रूप में इनपुट स्वीकार करते हैंchar*

---

संपादन:

• स्तंभ की गणना में 3 बाइट्स (फ़ंक्शन c)
• छत के लिए धन्यवाद 2 बाइट्स गोल्फ

Comments

और वहाँ, 77 बाइट्स