प्रोज्राममिंज पुसलस और कोडे ____

Question

इनपुट

एक गैर-खाली एन्कोडेड स्ट्रिंग, जिसमें मुद्रण योग्य ASCII वर्ण (32-12 रेंज में) होते हैं, जहां कुछ लापता अक्षरों को बदल दिया गया है _।

उत्पादन

लापता लोगों सहित लोअरकेस में सभी अक्षरों के साथ एक ही लंबाई का एक डिकोड्ड स्ट्रिंग।

कैसे?

संपादित करें: जैसा कि @Deusovi द्वारा टिप्पणियों में उल्लेख किया गया है, यह बेकन के सिफर का एक प्रकार है ।

• सभी पत्रों को मूल स्ट्रिंग में इकट्ठा करें और उन्हें 5 से समूह दें। 5 के पूर्ण समूह में फिट नहीं होने वाले अतिरिक्त पत्रों को अनदेखा किया जाता है।
• प्रत्येक समूह को बाइनरी में कनवर्ट करें: लोअरकेस = 0 , अपरकेस = 1 । यह पूर्णांक की एक सूची की ओर जाता है।
• उपस्थिति के क्रम में वर्णमाला (0-अनुक्रमित) के एन- वें अक्षर के साथ मूल स्ट्रिंग में प्रत्येक को बदलने के लिए इस सूची में प्रत्येक मान एन का उपयोग करें ।_

उदाहरण: prOGraMMIng PuZZleS & cOde ____

prOGr --> 00110 -->  6 -->  7th letter = 'g'
aMMIn --> 01110 --> 14 --> 15th letter = 'o'
gPuZZ --> 01011 --> 11 --> 12th letter = 'l'
leScO --> 00101 -->  5 -->  6th letter = 'f'

लापता पत्रों को बदलने और सब कुछ वापस लोअरकेस में बदलने से, मूल स्ट्रिंग का अनावरण किया जाता है:

programming puzzles & code golf

यह अपेक्षित आउटपुट है।

स्पष्टीकरण और नियम

• गायब अक्षरों को स्ट्रिंग के अंत में दिखाई देने की गारंटी है। औपचारिक रूप से: _इनपुट स्ट्रिंग में पहले के बाद कोई अक्षर नहीं होगा । हालाँकि, अन्य मुद्रण योग्य ASCII वर्ण हो सकते हैं जैसे रिक्त स्थान और विराम चिह्न।
• इनपुट की गारंटी है कि किसी भी बेकार पूंजी पत्र को शामिल नहीं किया जाना चाहिए : सभी कैपिटल अक्षरों को 1 पर सेट किया जाता है जो लापता अक्षरों को डीकोड करने के लिए आवश्यक होते हैं। बाकी सब लोअरकेस में है।
• इनपुट स्ट्रिंग मान्य होने की गारंटी है। विशेष रूप से:
  • इसमें अंडरस्कोर को डिकोड करने के लिए हमेशा 5 अक्षरों के पर्याप्त समूह होंगे।
  • बाइनरी-एन्कोडेड पूर्णांकों की सीमा [0-25] में होने की गारंटी है ।
• _इनपुट स्ट्रिंग में कुछ भी नहीं हो सकता है , जिस स्थिति में आपको इनपुट वापस करना होगा।
• यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है!

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

Input : hello!
Output: hello!

Input : helLO, worl_!
Output: hello, world!

Input : i aM yoUr faTh__.
Output: i am your father.

Input : prOGraMMIng PuZZleS & cOde ____
Output: programming puzzles & code golf

Input : Can YOu gUesS tHE ENd oF This ____?
Output: can you guess the end of this text?

Input : THe qUICk brown FOx JUMps oVEr the la__ ___.
Output: the quick brown fox jumps over the lazy dog.

Input : RoadS? wHERe we're goinG WE doN't need _____.
Output: roads? where we're going we don't need roads.

Input : thE greatESt Trick thE DeVIl EVer PUllEd wAs CONvInciNg tHe WorLD h_ ____'_ _____.
Output: the greatest trick the devil ever pulled was convincing the world he didn't exist.

कुछ अतिरिक्त परीक्षण-मामले:

Input : BInar_
Output: binary

Input : 12 MonKey_
Output: 12 monkeys

Input : hyPerbolIZ__
Output: hyperbolized

Input : {[One Last Test ca__]}
Output: {[one last test case]}

Comments

क्या हमें केवल 5 के कई समूहों पर विचार करना चाहिए क्योंकि इनपुट में अंडरस्कोर हैं?

— फलों

उस स्थिति में, नियम जब _इनपुट स्ट्रिंग में नहीं है , तो एक विशेष मामले का एक सा है।

— १

ऊह, बेकन सिफर!

— देसोवि

@SztupY The input is guaranteed not to contain any useless capital letter, यदि कोई अंडरस्कोर नहीं है, तो कैपिटल लेटर भी नहीं होगा।

— लकोनी

@KirillL। हाँ, में कुछ भी [32-126]। मैंने एक और टेस्ट केस जोड़ा है।

— अरनौलद

Answer 1

05AB1E , 18 बाइट्स

कोड:

áS.u5ôJC>.bv'_y.;l

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

á                       # Remove non-letters from the input string.
 S                      # Split the result into individual characters.
  .u                    # Check if is uppercase for each character.
    5ôJ                 # Split into binary numbers of length 5.
       C                # Convert from binary to decimal.
        >               # Add one.
         .b             # Map 1 → A, 2 → B, 3 → C, ..., 25 → Y, 26 → Z.
           v            # For each letter:
            '_y.;       #   Replace the first occurrence of '_' with the current letter.
                 l      #   Convert the string to lowercase.

Answer 2

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

s=input()
i=k=0
for c in s:
 if c.isalpha():k+=k+(c<'a');i+=1;s=s.replace('_',chr(k%32+97),i%5<1)
print s.lower()

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

Answer 3

पर्ल 5 -pF -MList::Util=sum, 75 बाइट्स

@a=grep!/\W|\d/,@F;s!_!(a..z)[sum map{a gt shift@a&&16/2**$_}0..4]!eg;$_=lc

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

स्पष्टीकरण:

• -pFचर में इनपुट की एक पंक्ति पढ़ता है $_और, वर्णों में विभाजित करता है, सरणी में @F।
• @a=grep!/\W|\d/,@Fसरणी @aको उन सदस्यों के बराबर सेट करता है @Fजो रेगेक्स को संतुष्ट नहीं करते हैं \W|\d। \Wअक्षर, संख्या और _; \dसंख्या है। तो \W|\dकुछ भी है लेकिन अक्षर और _, और @aसभी अक्षर और _वर्ण हैं। हम _पात्रों की जांच कभी नहीं करेंगे @a। (ध्यान दें कि यह केवल इसलिए काम करता है क्योंकि इनपुट की गारंटी ASCII है।)
• map{a gt shift@a&&16/2**$_}0..44 के माध्यम से निम्न के लिए करता है: यह अगले तत्व को बंद कर देता है @a, इसे छोटा कर देता है, और मूल्यांकन करता aहै कि क्या यह उस तत्व की तुलना में अधिक से अधिक है (अर्थात क्या वह तत्व अपरकेस है)। यदि ऐसा है, तो &&शॉर्ट-सर्कुलेट नहीं किया जाता है, इसलिए हम इनपुट वैल्यू (0 से 4 के माध्यम से) की पावर को 2 से विभाजित करते हैं। अन्यथा &&कम परिचालित है और हमें 0. mapपांच नंबरों की सूची मिलती है sum, जो उन्हें जोड़ता है।
• यही वह तत्व है जो हम सूची से चाहते हैं a..z, और यही हमें मिलता है (a..z)[…]।
• s!_!…!egप्रत्येक _को $_, बदले में, उपयुक्त अक्षर को परिवर्तित करता है।
• $_=lc$_खुद के निचले संस्करण में कनवर्ट करता है, और -pइसे प्रिंट करता है।

Answer 4

जे , 62 61 बाइट्स

tolower u:@]`(I.@t=.'_'=[)`[}+/@t$97+_5#.\3|0 2 4-.~'@Z`z'&I.

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

Answer 5

जेली ,  28 27  26 बाइट्स

-1 एग आउट द आउटफेलर एंड डायलन के लिए धन्यवाद

^{बहुत जेली-फ्रेंडली चुनौती नहीं!}

ḟŒs$Ƈ<”[s5Ḅ+97Ọż@ṣ”_$FṁLŒl

वर्णों की सूची को स्वीकार करने और लौटाने वाली एक विचित्र कड़ी।

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

कैसे?

ḟŒs$Ƈ<”[s5Ḅ+97Ọż@ṣ”_$FṁLŒl - Link: list of characters    e.g. "MfUNE_?"  (shorthand for ['M','f','U','N','E','_','?'])
    Ƈ                      - filter keep each if:
   $                       -   last two links as a monad:
 Œs                        -     swap-case
ḟ                          -     filter discard
                           - ...i.e. keep A-Z,a-z since they change when the case is swapped
                           -                                  "MfUNE"
      ”[                   - literal character                '['
     <                     - less than? (i.e. is upper-case?) [1,0,1,1,1]
        s5                 - split into fives                 [[1,0,1,1,1]]
          Ḅ                - from base two (vectorises)       [[23]]
           +97             - add (vectorises) ninety-seven    [[120]]
              Ọ            - from ordinals (vectorises)       [['x']]
                    $      - last two links as a monad:
                  ”_       -   literal character              '_'
                 ṣ         -   split at                       [['M','f','U','N','E'],['?']]
               ż@          - swapped @rgument zip             [[['M','f','U','N','E'],'x'],['?']]
                     F     - flatten                          "MfUNEx?"
                       L   - length (of input)                7
                      ṁ    - mould like                       "MfUNEx?"
                           - ...removes any excess characters
                        Œl - lower-case                       "mfunex?"

Answer 6

रेटिना , 91 90 बाइट्स

T`l`a
T`L`A
[^Aa]

L`.{5}
A
aA
+`Aa
aAA
+T`_lA`l_`[^A]A
^
$+¶
+`_(.*)¶a+(.)
$2$1
0G`
T`L`l

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

T`l`a
T`L`A
[^Aa]

aऔर Aसब कुछ हटाने के लिए अक्षरों को ऊपर और बड़े अक्षरों में अनुवाद करें ।

L`.{5}

Aa5 के समूहों में विभाजित करें ।

A
aA
+`Aa
aAA

बाइनरी से एकरी में रूपांतरित करें, A1 के रूप में और a0. के रूप में 0. चूंकि 5 Aaएस मूल रूप से थे , इसलिए 5 aएस शेष हैं, साथ Aही वर्णमाला में वांछित स्थिति के आधार पर एस की संख्या ।

+T`_lA`l_`[^A]A

aनिम्नलिखित As की संख्या के अनुसार अंतिम वृद्धि ।

^
$+¶

मूल इनपुट को प्रस्तुत करें।

+`_(.*)¶a+(.)
$2$1

किसी भी _s को अगले डीकोड किए गए अक्षर से बदलें ।

0G`

किसी भी खाली डिकोड किए गए अक्षरों को हटा दें।

T`L`l

सब कुछ लोअरकेस।

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

.+
$&¶$&
T`L`l`^.*
T`l`a`.*$
T`L`A
T`aAp`aA_`.*$
(.*¶)?.{5}
$&;
A
aA
+`Aa
aAA
+T`_lA`l_`[^A]A
+`_(.*¶)a+(.);
$2$1
1G`

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

.+
$&¶$&

इनपुट डुप्लिकेट करें।

T`L`l`^.*

पहली प्रति लोअरकेस करें।

T`l`a`.*$

aदूसरी कॉपी में लोअरकेस अक्षरों का अनुवाद करें ।

T`L`A

के लिए बड़े अक्षरों का अनुवाद करें A। ये दूसरी कॉपी में होना चाहिए क्योंकि पहली कॉपी पहले से ही नीची थी।

T`aAp`aA_`.*$

दूसरी कॉपी में बाकी सब डिलीट कर दें।

(.*¶)?.{5}
$&;

Aa5 के समूहों में दूसरी प्रति (अब सिर्फ एस) विभाजित करें।

A
aA
+`Aa
aAA
+T`_lA`l_`[^A]A
+`_(.*¶)a+(.);
$2$1
1G`

पत्रों को डिकोड करें और उन्हें पहले की तरह डालें।

Answer 7

एपीएल (Dyalog यूनिकोड) , 46 बाइट्स ^SBCS

अनाम लैम्ब्डा, ⎕IOमाना जाता है (सूचकांक मूल) 0।

{_←'_'=⊢⋄819⌶A[2⊥⍉(+/_⍵)5⍴A∊⍨⍵∩A,819⌶A←⎕A]@_⍵}

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

{... ⋄... } दो-कथन फ़ंक्शन; ⍵तर्क है, ⋄बयानों को अलग करता है

 ⊢ तर्क (नो-ऑप फंक्शन)
 '_'= जहां अंडरस्कोर (यानी बूलियन मैपिंग फंक्शन) के बराबर है,
 _← उस फंक्शन को असाइन करें_

 A[... ]@_⍵ के निम्न वर्णों डाल A पर बहस में अंडरस्कोर के पदों
  ⎕A अपरकेस एक lphabet
  A← असाइन कि करने के लिए A
  819⌶ यह लोअरकेस ( 819 ≈ के बिग , कोई बाईं तर्क साधन बड़ा नहीं, यानी लोअरकेस) के साथ
  A, आगे जोड़ते अपरकेस वर्णमाला; इससे हमें
  ⍵∩ तर्क के सभी पत्र प्रतिच्छेदन मिलते हैं और यह कि; केवल
  A∊⍨ उन तर्कों के अक्षर जो अपरकेस वर्णमाला के सदस्य हैं; अपरकेस बिट्स
  (... )5⍴ r eshape कि निम्नलिखित पंक्तियों की संख्या, और पांच कॉलम:
   _⍵ तर्क
   +/ राशि में अंडरस्कोर का मुखौटा ; अंडरस्कोर की संख्या
  ⍉ पारगमन (प्रत्येक पंक्ति को एक बिट स्थिति के बजाय संख्या के रूप में मानने के लिए)
  2⊥ आधार -2 के रूप में मूल्यांकन करते हैं
 819⌶ जो सब कुछ कम करता है

Answer 8

स्काला , 189 बाइट्स

def f(s:Array[Char])={var j=0;s.zipWithIndex.collect{case(95,i)=>s(i)=(Integer.parseInt(s.filter(_.isLetter)slice(j,j+5)map(k=>if(k<91)1 else 0)mkString,2)+97)toChar;j+=5};s.map(_.toLower)}

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

स्पष्टीकरण:

def f(s: Array[Char]) = {                // takes a String in input
  var j = 0                              // j stores at which block of 5 letters we're currently at
  s.zipWithIndex.collect {               // Array('h', 'e', ...) => Array(('h', 0) ('e', 1), ...) and we apply a collect transformation (filter/map)
    case (95, i) =>                      // we only handle cases where the char is '_' (95)
      s(i) = (                           // we modify the char at index i with the following
        Integer.parseInt(                // Integer.parseInt("00110", 2) = 6
          s                              //
            .filter(_.isLetter)          // filter out non letter chars (spaces, punct, figures, ...) from the input string (thanks @Arnauld for the fix)A
            .slice(j, j+5)               // "substring" the array to the block of 5 letters in question
            .map(                        // map on the current block of 5 letters
              k =>                       // the index of the next char in the block f 5 (e.g. 13)
                if (k < 91) 1 else 0     // if the current char is upper case (<91) then we replace it by a bit true, otherwise by a bit false
            )mkString,                   // Array(0, 1, 1, ...) => "011..."
          2                              // cast string to binary
        )                                //
        + 97                             // +97 to create a lower case char
      )toChar                            // cast from int to char
      j += 5                             // update the starting index of the next block of 5 letters
    }                                    //
  s.map(_.toLower)                       // return the updated seq of chars all in lower case
}                                        //

Answer 9

जावास्क्रिप्ट (Node.js) , 125 124 बाइट्स

x=>x.replace(s=/./g,c=>parseInt(c,36)>9?c.toLowerCase(s+=+(c<{})):c=='_'?('0b'+s.slice(4,9)-~9).toString(36,s=s.slice(5)):c)

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

Answer 10

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

xn¥Œs<”[s5Ḅ‘ịØaṛi”_ḟ0Ɗ¦ƒŒl

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

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

Answer 11

सीजेएम , 43 बाइट्स

q'_/_0={el_eu=!},_eu.=5/2fb65f+:c1$,(<.+:el

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

Answer 12

साफ , 180 ... 150 बाइट्स

import StdEnv
?s=['a'+sum[i\\i<-:""&c<-s|c<'a']: ?(drop 5s)]
@['_':b][x:y]=[x: @b y]
@[a:b]z=[toLower a: @b z]
@e _=e
$s= @s(?(filter isAlpha s))

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

अंडरस्कोर को बदलने के लिए सहायक के रूप में फ़ंक्शन $ :: [Char] -> [Char]को परिभाषित करता है @ :: [Char] [Char] -> [Char], और ? :: [Char] -> [Char]प्रतिस्थापन पात्रों को उत्पन्न करने के लिए सहायक के रूप में।

Comments

i<-:""भाग कैसे काम करता है ? क्या संक्षेप में संख्याओं को संक्षेप में परिवर्तित किया जाता है जब उन्हें जोड़ते या जोड़ते हैं?

— लकोनी

@ लिकोनी नहीं, कोई अंतर्निहित रूपांतरण नहीं है। यद्यपि आप चार्ट जोड़ और घटा सकते हैं।

— Οवस

Answer 13

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

s=>s.toLowerCase(c=/[a-z]/gi).replace(/_/g,_=>(g=n=>n?(c.exec(s)<{})*n+g(n>>1):10)(16).toString(36))

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

@Arnauld के लिए धन्यवाद, 2 बाइट्स बचाता है।

Comments

@ अरनुलद आप सही कह रहे हैं। /[a-z]/giअब संपादित किया गया ।

— tsh

Answer 14

आर , 153 135 113 बाइट्स

function(s,S=utf8ToInt(s)){S[S==95]=2^(4:0)%*%matrix(S[S%in%c(65:90,97:122)]<95,5)+97
cat(tolower(intToUtf8(S)))}

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

उपयोग के साथ कुछ चेतावनी जारी करता है, matrixलेकिन परिणाम को प्रभावित नहीं करना चाहिए। साथ ही चेतावनी जारी करता है कि [<-असाइनमेंट विलुप्त असाइन ऑब्जेक्ट्स को डिफ़ॉल्ट रूप से हटा देगा।

40 (!) JayCe के सुधारों के लिए धन्यवाद बाइट्स

Comments

मुझे नहीं लगता कि आपको जरूरत है,length(L)%/%5

— JayCe

इसके अलावा एल को परिभाषित करने की कोई आवश्यकता नहीं है?

— JayCe

@JayCe ठीक है आज मैंने सीखा कि [<-तत्वों को सूचकांक की लंबाई से बाहर फेंक देगा ...

— Giuseppe

मुझे भी वास्तव में!

— JayCe

अपने दृष्टिकोण का अनुवादintToUtf8

— JayCe

Answer 15

सी (जीसीसी) , 111 109 101 100 बाइट्स

संपादित करें: @ FrownyFrog की टिप्पणी के अनुसार लोअरकेसिंग; उनके सुझावों के लिए लिन, क्रिस्टोफ़ और user5329483 का धन्यवाद!

f(s,t,i)char*s,*t;{for(t=s;t=strchr(t,95);*t=i+1)for(i=3;i<64;s++)isalpha(*s)?i=2*i|*s<97,*s|=32:0;}

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

Comments

आप के साथ 2 बाइट्स बचा सकते हैं i+=i+(*s<97)।

— लिन

आप के रूप में jएक मार्कर बिट शुरू करने iऔर के रूप में दूसरे के लिए फिर से लिखना द्वारा समाप्त कर सकता है for(i=1;i<32;s++)। और बाहरी 32 के लिए अतिरिक्त क्षतिपूर्ति करें। यहाँ एक newbee के रूप में मैं एक सात बाइट स्पेयर की गिनती करता हूँ।

— user5329483

एक और बाइट मिला: for(i=3;i<96;s++)एक एकल-अंक संख्या, उर्फ ​​के लिए 65 को नीचे लाता है 1।

— user5329483

Answer 16

गो, 219 217 192 210 209 156 बाइट्स

@Lynn को धन्यवाद 25 बाइट्स बचाए! 53 बाइट्स @ovs की बदौलत बच गए!

बग के बिना बग के कारण 18 बाइट्स गंवाने पड़े:

func p(s string){b:=0;n:=0;for _,c:=range s{if IsLetter(c){b+=b;if IsUpper(c){b+=1};n++;s=g.Replace(s,"_",string('a'+b%32),(5-n%5)/5)}};Print(g.ToLower(s))}

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

Answer 17

स्टेक्स , 22 बाइट्स

â╟▓ïMeee¶▐f◄┴≈┘n╛äyΩ○N

इसे चलाएं और डीबग करें

सामान्य दृष्टिकोण "_"कॉलबैक फ़ंक्शन का उपयोग करने का एक नियमित अभिव्यक्ति प्रतिस्थापन है जो प्रत्येक प्रतिस्थापन चरित्र की गणना करने के लिए इनपुट के पत्रों को स्लाइस करता है।

v       convert to lower case
'_      "_" string literal
{       begin block for regex replacement
  yVl|& all the letters only from the original input
  5/    split into chunks of 5
  i@    keep the ith one, where i is the 0-based number of times this block has run
  {97<m map 5-letter chunk to bits to indicate which are lowercase
  :b    decode as 5-bit integer
  97+]  add 97 and wrap in array to convert to lower case character
}       end block for regex replacement
R       do regex replacement

इसको चलाओ

Answer 18

लाल , 247 बाइट्स

func[s][a: charset[#"a"-#"z"#"A"-#"Z"]v: copy""parse s[any[copy c a(append v to-string c)|
skip]]k: 0 t: copy""repeat n(length? v)/ 5[c: 0 p: 16
loop 5[if v/(k: k + 1) <#"a"[c: c + p]p: p / 2]append t#"a"+ c]foreach c
t[replace s"_"c]lowercase s]

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

अधिक पठनीय:

f: func[s][
    a: charset[#"a"-#"z"#"A"-#"Z"]
    v: copy ""
    parse s[any[copy c a(append v to-string c)| skip]]
    k: 0
    t: copy ""
    repeat n (length? v) / 5[
        c: 0
        p: 16
        loop 5[
            if v/(k: k + 1) < #"a" [c: c + p]
            p: p / 2
        ]
        append t #"a" + c
    ]
    foreach c t[replace s "_" c]
    lowercase s
]

Answer 19

जावा 10, 186 बाइट्स

s->{var b="";for(int i=0,c;i<s.length();)if((b+=(c=s.charAt(i++))>64&c<91?1:c>96&c<123?0:"").length()>4)s=s.replaceFirst("_",(char)(97+Byte.valueOf(b,2))+(b=""));return s.toLowerCase();}

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

स्पष्टीकरण:

s->{                            // Method with String as both parameter and return-type
  var b="";                     //  Binary-String, starting empty
  for(int i=0,c;i<s.length();)  //  Loop over the characters of the input-String
    if((b+=(c=s.charAt(i++))>64&c<91?
                                //   If the current character is a lowercase letter:
            1                   //    Append "1" to the binary-String
           :c>96&c<123?         //   Else-if it's an uppercase letter:
            0                   //    Append "0" to the binary-String
           :                    //   Else (not a letter):
            "")                 //    Append nothing to the binary-String
       .length()>4)             //   And if the length is now 5:
      s=s.replaceFirst("_",     //    Replace the first "_" in the input-String with:
           (char)(97+Byte.valueOf(b,2))
                                //     The binary-String as character
           +(b=""));            //    And reset the binary-String
  return s.toLowerCase();}      //  Return the modified input-String as lowercase

Answer 20

रूबी , 107 106 103 बाइट्स

->s{s.chars.map{|c|c !~/\W|\d/?c<?a?1:0:p}.join.scan(/.{5}/){|b|s[?_]&&=(b.to_i(2)+97).chr};s.downcase}

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

Answer 21

जाप, 25 बाइट्स

r'_@r\L mè\A sTT±5 ÍdIÄÃv

कोशिश करो

---

व्याख्या

r'_                           :Replace underscores
   @                          :Pass each match through a function
    r                         :  From original input remove
     \L                       :    /[^a-zA-Z]/g
        m                     :  Map
         è                    :    Count
          \A                  :      /[A-Z]/g
             s                :  Slice
              T               :    From index T (initially 0)
               T±5            :    To index T+=5
                   Í          :  Convert from base-2 string to base-10 integer
                     IÄ       :  Add 64+1
                    d         :  Get character at that codepoint
                       Ã      :End function
                        v     :Lowercase

Answer 22

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

Km@Gim!}kGd2c@+r1GGQ5VQp?qN\_.(KZr0N

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

व्याख्या

Km@Gim!}kGd2c@+r1GGQ5VQp?qN\_.(KZr0N
             @+r1GGQ                   Get the letters from the input...
            c       5                  ... in chunks of 5.
 m        d                            For each chunk...
     m!}kG                             ... check if each letter is uppercase...
    i      2                           ... converted to binary...
  @G                                   ... and get the corresponding letter.
                     VQp               For each character in the input...
K                       ?qN\_.(KZ      ... if the character is '_', replace it...
                                 r0N   ... otherwise, lowercase it.

Answer 23

पायथन 3.5 , 296 बाइट्स

u=input();f=u.find('_');m=''.join([c for c in u if c.isalpha()]);z=[chr(int(''.join(['0'if o.islower() else'1' for o in l]),2)+65)for l in[m[h:h+5]for h in range(0,len(m),5)]if len(l)==5];[z.insert(v,d)for v,d in enumerate(u[f:])if d!="_"];u=list(u);u[f:]=z[:len(u[f:])];print(''.join(u).lower())

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

पहला कोड गोल्फ :)

(मुझे पता है कि यह बाइट्स में छोटा नहीं है, मुझे सिर्फ 1 लाइन कोड बनाने में मज़ा आ रहा था)

यहाँ स्पष्टीकरण है:

---

उपयोगकर्ता का निवेश

यू = इनपुट ()

---

स्ट्रिंग में पहले _ के सूचकांक को ढूँढता है और उसे संग्रहीत करता है

च = u.find ( '_')

---

सभी गैर-अल्फा वर्णों की स्ट्रिप्स स्ट्रिंग

m = ''। Join ([c के लिए c में यदि c.isalpha ())]

---

5 वर्णों वाले प्रत्येक तत्व के साथ एक सरणी में अल्फा स्ट्रिंग को विभाजित करता है

पूर्व। ['थेकेयू', 'आईसीकेब्र', 'खुद एफएफओ', 'एक्सजुम', 'सोवेन्र', 'इला']

फिर लोअरकेस वर्णों को 0 और अपरकेस वर्णों को 1 में परिवर्तित करता है

पूर्व। ['11001', '11000', '00011', '01110', '00110', '00000']

और बाइनरी स्ट्रिंग को एक पूर्णांक में परिवर्तित करता है, 65 जोड़ता है और एक वर्ण में परिवर्तित करता है

पूर्व। [[z ’,, y’, 'd ’,, o’,, g ’,' a’]

z = [chr (int (''। join (['0' if o.islower () '1 in o in l]), २) +65) l के लिए [m [h: h + ५] h में सीमा के लिए (0, len (m), 5)] अगर len (l) == 5]

---

पहले _ के बाद सभी वर्णों को पाता है और उन्हें अपने संबंधित स्थानों पर सरणी z में धकेलता है (ऊपर परिभाषित)

पूर्व। [[z ’,, y’, z ’,, d’,, o ’,, g’, ’।’, 'a ’]

[z.insert (v, d) v के लिए, d in enumerate (u [f:]) अगर d! = "_ _]

---

हमारे स्ट्रिंग को वर्णों की सूची में विभाजित करें

यू = सूची (यू)

---

हमारी स्ट्रिंग को पहले _ से सूची के अंत तक स्लाइस करें और इसे सरणी z के साथ बदलें। मुझे पहले से अंत तक विभाजित स्ट्रिंग की लंबाई के लिए सरणी z को स्लाइस करना था क्योंकि मुझे आलसी कुत्ते के उदाहरण में एक अतिरिक्त चरित्र मिला (ऊपर दिए गए उदाहरणों के अंत में "a")

यू [च:] = z [: LEN (सूची (यू [च:]))]

---

* उत्तर का प्रिंट आउट लें *

प्रिंट ( ''। में शामिल होने के (यू) .lower ())

---

Comments

वहाँ सिर्फ एक लाइन पर सब कुछ प्राप्त करने की तुलना में अधिक गोल्फिंग है। 165 बाइट्स

— जो किंग

आप के बीच की जगह को हटा सकते हैं o.islower()और elseहै, और मुझे लगता है कि '1'और for। इसके अलावा, आप बदल सकते हैं if d!="_"करने के लिए if"_"!=dहै, लेकिन इसके बाद के संस्करण टिप्पणी पहले से ही है कि नहीं करता है।

— ज़ाचरी

Answer 24

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

g""
import Data.Char
f t(x:s)('_':r)=x:f t s r
f[0,a]s r=g(s++[chr a])r
f[n,a]s(c:r)=toLower c:f[div n$1+sum[1|isAlpha c],a+sum[n|isUpper c]]s r
f _ s e=e
g=f[16,97]

इसे ऑनलाइन आज़माएं! उदाहरण उपयोग: g"" "BInar_"पैदावार "binary"।

Answer 25

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

switch -r($args|% t*y){_{$_=$a[$n++]+97}[a-z]{$x+=$x+($_-le96);if(!(++$i%5)){$a+=,$x;$x=0};$_=$_-bor32}.{$r+=[char]$_}}$r

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

कम गोल्फ वाला:

switch -Regex ($args|% toCharArray){
    _ {                     # is underscore
        $_=$a[$n++]+97      # get a char from the array of letter
    }

    [a-z] {                 # is letter
        $x+=$x+($_-le96)    # $x=2*$x+($_-le96)
        if(!(++$i%5)){      # if(++$i%5 -eq 0)
            $a+=,$x         # add an element to the array of letters
            $x=0            # init
        }
        $_=$_-bor32         # to lower
    }

    . {                     # is any char ('_' and letters included)
        $r+=[char]$_        # add the char to result
    }
}
$r

Answer 26

पर्ल 5 -p , 78 बाइट्स

for$h(s/\W|\d//gr=~y/a-z/0/r=~y/A-Z/1/r=~/.{5}/g){s%_%chr 65+oct"0b$h"%e}$_=lc

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

Comments

मैंने इसे 3 और बाइट्स के साथ तय किया, जो वर्तमान नियमों के तहत आपके उत्तर को थोड़ा बेहतर बनाता है।

— Xcali

बेहतर नहीं लेकिन अलग। प्रत्येक भाषा + विकल्पों को अलग-अलग माना जाता है, समान भाषा + अन्य विकल्पों के साथ प्रतिस्पर्धा नहीं करता है, जैसा कि मैं इसे समझता हूं।

— msh210