42

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

hello world

और हर दूसरे पात्र को अपरकेस में बदलें, आपको मिलेगा:

hElLo wOrLd

जैसा कि आप देख सकते हैं, लोअरकेस oएक लोअरकेस द्वारा पीछा किया जाता है w। यह अमान्य है। इसके बजाय, आपको इस परिणाम को देखते हुए, स्थान को अनदेखा करना चाहिए:

hElLo WoRlD

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

HeLlO wOrLd

आपके कार्यक्रम को इनपुट के मामले की परवाह किए बिना काम करना चाहिए।

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

उदाहरण:

ASCII                                   ->  AsCiI
42                                      ->  42
#include <iostream>                     ->  #InClUdE <iOsTrEaM>
LEAVE_my_symbols#!#&^%_ALONE!!!         ->  lEaVe_My_SyMbOlS#!#&^%_aLoNe!!!
PPCG Rocks!!! For realz.                ->  PpCg RoCkS!!! fOr ReAlZ.
This example will start with lowercase  ->  tHiS eXaMpLe WiLl StArT wItH lOwErCaSe
This example will start with uppercase  ->  ThIs ExAmPlE wIlL sTaRt WiTh UpPeRcAsE
A1B2                                    ->  A1b2

चूंकि यह कोड-गोल्फ है , मानक खामियां लागू होती हैं और बाइट्स जीत में सबसे छोटा जवाब होता है!

code-golf string

— DJMcMayhem
स्रोत

33

उह, मैंने केवल यह महसूस किया है कि मेम एक्सडी

— बीटा

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

— DJMcMayhem

4

अगली चुनौती एक cowsay

— एससीआई

1

इसे रफू करें! मैंने इसके लिए (जैसे कल) में सीजेएम स्क्रिप्ट लिखी और उसे डिलीट कर दिया।

— फल खाने का समय

2

शीर्षक के लिए कुछ गलत संभावनाएं हैं या कम से कम कयामत या स्पॉर्क के पेंगुइन का उपयोग करने वाले उदाहरण हैं।

— इयान

19

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

अपरकेस से शुरू होता है।

s=>s.replace(/[a-z]/gi,c=>c[`to${(s=!s)?'Low':'Upp'}erCase`]())

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

कोड स्निपेट दिखाएं

let f =

s=>s.replace(/[a-z]/gi,c=>c[`to${(s=!s)?'Low':'Upp'}erCase`]())

console.log(f("ASCII"))
console.log(f("42"))
console.log(f("#include <iostream>"))
console.log(f("LEAVE_my_symbols#!#&^%_ALONE!!!"))
console.log(f("PPCG Rocks!!! For realz."))
console.log(f("This example will start with lowercase"))
console.log(f("This example will start with uppercase"))
console.log(f("A1B2"))

स्निपेट का विस्तार करें

— Arnauld
स्रोत

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

— झबरा

हाँ, एक टर्नरी का उपयोग करना जो मैं सुझाव देने जा रहा था।

— झबरा

1

s=!sचाल कैसे काम करती है?

— कृति लीथोस

7

@KritiiLithos क्योंकि sइनपुट स्ट्रिंग है, !sपहले मूल्यांकन करता है false(जब तक कि इनपुट स्ट्रिंग खाली नहीं है, इस स्थिति में वह किसका मूल्यांकन करेगाtrue - लेकिन खाली स्ट्रिंग किसी भी तरह से कोई भी मैच उत्पन्न नहीं करेगा)। उसके बाद, यह सिर्फ एक मानक बूलियन ऑपरेशन बन जाता है, falseऔर बीच में बारी-बारी से true। इसके अलावा, हम sइस बिंदु पर सामग्री को खोने का बुरा नहीं मानते हैं क्योंकि यह पहले से ही फ़ीड करने के लिए उपयोग किया गया था .replace()।

— अरनौल

3

@MayorMonty दुर्भाग्य से, यह कुछ प्रतीकों से मेल खाता है। ऐसा इनपुट "A[I"विफल हो जाएगा।

— अरनौल

12

05AB1E , 11 8 बाइट्स

कोड:

lvyJ¤aiš

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

स्पष्टीकरण:

l           # Lowercase the input
 vy         # For each element..
   J        #   Join the entire stack into a single string
    ¤a      #   Check if the last character is alphabetic
      iš    #   If true, swapcase the entire string

— अदनान
स्रोत

मैं प्यार करता हूँ कि मैं कैसे अंधे में जाने की कोशिश करता हूं, यह जानकर कि मुझे 11-बाइट्स को हरा देना है; फिर धीरे-धीरे 17 से 11 बाइट पर जाएं और महसूस करें lvy¾Fš}Da½Jकि आपके पास पहले से ही क्या है ।_

— मैजिक ऑक्टोपस Urn

1

@carusocomputing एक बहुत आसान 8 बाइट समाधान है: पी

— अदनान

4

ओह, हाँ, सुपर आसान हाहा।

— मैजिक ऑक्टोपस Urn

2

@ ओक्टोपस इस बारे में कुछ चर्चा है, लेकिन मैं 'ओसेबल' और 'ओसाबी' दोनों का उपयोग करता हूं।

— अदनान

1

@octopus मैं सचमुच कहता हूं Oh-Five-Ay-Bee-One-Eee, मैं एक रचनात्मक आदमी नहीं हूं।

— मैजिक ऑक्टोपस Urn

11

जीएनयू सैड, 33

5 बाइट्स @TobySpeight की बदौलत बच गए

-rफ्लैग टू सेड के लिए स्कोर में +1 शामिल है ।

s/([a-z])([^a-z]*.?)/\U\1\L\2/gi

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

— डिजिटल आघात
स्रोत

8

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

nŒsTm2
ŒlŒuÇ¦

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

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

ŒlŒsÇ¦  Main link. Argument: s (string)

Œl      Cast to lowercase.
    Ç¦  At indices returned by the helper link...
  Œu        apply uppercase.


nŒsTm2      Helper link. Argument: s (string)

 Œs         Apply swapcase to s.
n           Perform vectorizing not-equal comparison.
   T        Compute the truthy indices.
    m2      Select every other one, starting with the first.

— डेनिस
स्रोत

7

जाप , 16 14 बाइट्स

r"%l"_m"uv"gT°

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

व्याख्या

r              // RegEx replace input
 "%l"          // [A-Za-z] as first arg to replace
     _         // created function Z=>Z as second arg to replace
       "uv"gT° // alternates "u" & "v"
      m        // map Z to either "u" upper or "v" lower

— powelles
स्रोत

बहुत अच्छा! आप निकाल सकते हैं ,। जब तक यह एक संख्या (यानी [12]) नहीं है, तब तक जाप पता है कि वे अलग-अलग आइटम हैं। मेरा मानना है कि आप इसे भी हटा सकते हैं &1।

— ओलिवर

धन्यवाद @obarakon जाप प्रलेखन थोड़ा विरल है।

— पॉवेल्स

जाप का उपयोग करने के लिए धन्यवाद। जाप चैट रूम में प्रश्न, सुझाव आदि पूछने के लिए स्वतंत्र महसूस करें । जाप धागे के लिए एक सुझाव भी है । :)

— ओलिवर

_m"uv"gT°अच्छा लगा। मैं बस सुझाव देने वाला था।

— ओलिवर

@obarakon हाँ, मैंने देखा कि जहाँ ETH ने चैट में आपके प्रश्न का उत्तर दिया और यह मुझे चीजों को आज़माने में मिला।

— पोवेल्स

6

पायथन 3 , 86 76 68 66 63 बाइट्स

^{-2 बाइट्स डीजेएमकेमहेम}
^{-3 बाइट्स के लिए धन्यवाद साइओस को धन्यवाद}

x=0
for i in input():print(end=(2*i).title()[x]);x^=i.isalpha()

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

— छड़ी
स्रोत

अजगर 3 में दो बाइट्स छोटे हैं: इसे ऑनलाइन आज़माएं!

— DJMcMayhem

1

कोई कारण जो आप नहीं कर सकते print(end=(2*i).title()[x])?

— साइओस

5

ऐलिस , 18 बाइट्स

/olZlYuN
@iy.u..//

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

व्याख्या

यह कार्यक्रम विषम-लंबाई वाले कार्यक्रमों के लिए एक कम-ज्ञात टेम्पलेट का अनुसरण करता है जो पूरी तरह से सामान्य मोड में चलते हैं। इस कोड का रैखिक संस्करण है:

il.l.uN.YuZyo@

कोड की व्याख्या:

i - push input onto stack            ["Hello world!"]
l - convert to lowercase             ["hello world!"]
. - duplicate                        ["hello world!", "hello world!"]
l - convert to lowercase (should be no-op, but avoids what seems to be a bug in the TIO implementation)
. - duplicate again                  ["hello world!", "hello world!", "hello world!"]
u - convert to uppercase             ["hello world!", "hello world!", "HELLO WORLD!"]
N - difference between sets          ["hello world!", "helloworld"]
. - duplicate reduced string         ["hello world!", "helloworld", "helloworld"]
Y - unzip (extract even positions)   ["hello world!", "helloworld", "hlool", "elwrd"]
u - convert to uppercase             ["hello world!", "helloworld", "hlool", "ELWRD"]
Z - zip evens back into string       ["hello world!", "helloworld", "hElLoWoRlD"]
y - perform substitution             ["hElLo WoRlD!"]
o - output                           []
@ - terminate

lडुप्लिकेट पर उपयोग किए बिना , स्टैक के बाद Nहोगा ["helloworld", "helloworld"]। मुझे दृढ़ता से संदेह है कि यह एक बग है।

— Nitrodon
स्रोत

5

C (tcc) , 60 57 56 बाइट्स

बिट 5 को सूचित करने के लिए डिजिटलट्रॉमा के लिए धन्यवाद एएससीआईआई ऊपरी / निचले मामले के लिए एकमात्र अंतर है।

तीन और बाइट्स बंद करने के लिए zch के लिए विशेष धन्यवाद।

RJHunter के विचार से एक और बाइट को बचाएं

l;f(char*s){for(;*s=isalpha(*s)?*s&95|++l%2<<5:*s;s++);}

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

— cleblanc
स्रोत

मैंने इसे थोड़ा और गोल्फ दिया , और इसे संशोधित किया इसलिए यह gcc, tcc, clang सभी पर काम करता है। एफडब्ल्यूआईडब्ल्यू, जीसीसी स्ट्रिंग-वाचल्स को रीड-ओनली मेमोरी में रखता है, इसलिए मुझे strdup()टेस्ट-ड्राइवर कोड में मेमोरी पढ़ने-लिखने के लिए पॉइंटर्स मिलते थे।

— डिजिटल ट्रॉमा

1

इसके लिए @DigitalTrauma धन्यवाद। मुझे पहचानना चाहिए था बिट 5 ऊपरी और निचले के बीच का अंतर था। अच्छा लगा!

— क्लेब्लांक

मैंने इस संस्करण को भी पुनरावर्ती बनाने की कोशिश की , लेकिन इसे कोई छोटा नहीं पाया।

— डिजिटल ट्रॉमा

आप *s&~32|++l%2<<53 बाइट्स को बचाने के लिए आंतरिक सशर्त को बदल सकते हैं ।

— zch

के बाद से इनपुट वादों प्रिंट योग्य ASCII होने के लिए आपको जगह ले सकता है &~33के साथ &95एक और बाइट को बचाने के लिए।

— आरजेहंटर

4

जावा 8, 99 बाइट्स

a->{String r="";int i=0;for(int c:a)r+=(char)(c>64&c<91|c>96&c<123?i++%2<1?c|32:c&~32:c);return r;}

स्पष्टीकरण:

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

a->{                          // Lambda with char-array parameter and String return-type
  String r="";                //  Result-String
  int i=0;                    //  Flag for alteration
  for(int c:a)                //  Loop over the characters of the input
    r+=(char)                 //   And append the result-String with the following (converted to char):
      (c>64&c<91|c>96&c<123?  //    If it's a letter:
       i++%2<1?               //     And the flag states it should be lowercase:
        (c|32)                //      Convert it to lowercase
       :                      //     Else (should be uppercase):
        (c&~32)               //      Convert it to uppercase
      :                       //    Else:
       c);                    //     Simply append the non-letter character as is
                              //  End of loop (implicit / single-line body)
  return r;                   //  Return result-String
}                             // End of method

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

मैं इसे छोटा नहीं कर सका, लेकिन आप बाइट्स का उपयोग (c+"").matches("[A-Za-z]")या Character.isLetter(c)सहेजने में सक्षम हो सकते हैं ।

— TheLethalCoder

@TheLethalCoder c>64&c<91|c>96&c<123हालांकि दोनों अब से अधिक लंबे हैं । और जब से मैं और गोल्फ भागों (इन: और ) के intलिए वैसे भी उपयोग करता हूं , मुझे संदेह है कि मैं इसे उन दोनों में से छोटा बना सकता हूं। Character.toUpperCase(...)Character.toLowerCase(...)(char)(c&~32)(char)(c|32)

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

1

मैंने सोचा था कि आप पोस्ट करने में सक्षम नहीं होंगे, यह देखने के लिए कि क्या आप वैसे भी उनका उपयोग कर सकते हैं

— TheLethalCoder

@ द लीथलकोडर आह ठीक है। :) कुछ मामलों में पहले अन्य चुनौतियों के लिए थोड़ा अलग दृष्टिकोण के साथ मदद कर सकता है, लेकिन इस चुनौती के लिए यह छोटा है। फिर भी धन्यवाद।

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

a->{String r="";int i=0,f=32;for(int c:a)r+=(char)(c>64&c<91|c>96&c<123?(f=~f):c);return r;} ??

— रोमन ग्रफ

4

रूबी, 57 55 47 41 बाइट्स

बाइट काउंट में कमांड लाइन विकल्पों के लिए दो बाइट्स शामिल हैं।
इसे इस तरह से उदाहरण के लिए चलाएं:$ ruby -p0 alternate_case.rb <<< "some input"

gsub(/\p{L}/){($&.ord&95|32*$.^=1).chr}

p0विकल्प के साथ , पूरे इनपुट को एक बार में खपत किया जाता है, और जादुई वैश्विक 1 $.में वृद्धि होती है। इसे बाद में 0 और 1 के बीच टॉगल किया जाता है और राज्य रखने के लिए उपयोग किया जाता है।

मल्टीलाइन इनपुट के साथ काम करता है; इसे ऑनलाइन आज़माएं!

अद्भुत इनपुट के लिए वेंटरो के लिए धन्यवाद - विवरण के लिए टिप्पणियों की जांच करें।

— daniero
स्रोत

1

यार, अगर यह इस तथ्य के लिए नहीं था कि $.प्रत्येक getsकॉल के साथ ऑटो-वेतन वृद्धि , -pध्वज के साथ एक पूरा कार्यक्रम छोटा होता ...

— मूल्य स्याही

1

1&$.+=1आपको कोष्ठकों को छोड़ने की अनुमति देता है। और पूर्णता की खातिर, एक और वैश्विक पूर्णांक है - यह दुर्भाग्य से केवल-पढ़ने के लिए है $$:।

— वेंटरो

1

कमांड लाइन ध्वज के बारे में एक और बात: -p0दुभाषिया एक ही बार में सभी उपलब्ध इनपुट को पढ़ता है - इसलिए आपका कोड केवल एक बार लागू होता है, जिससे आप स्वतंत्र रूप से उपयोग कर सकते हैं $.। इस तथ्य के साथ संयोजन करना कि जब gsubस्पष्ट रूप से संचालित होता है, $_.gsub!तो यह निर्दिष्ट -pकरता है कि एक पूर्ण कार्यक्रम काफी छोटा है: ध्वज के gsub(/[a-z]/i){[$&.upcase,$&.downcase][1&$.+=1]}लिए 48 वर्ण और 2 p0।

— वेंटरो

1

अंतिम टिप्पणी, मैं वादा करता हूं :) एक बार जब आप उपयोग कर रहे होते हैं -p0, तो आप वास्तव में कुछ और पात्रों को सहेज सकते हैं कि आप कैसे $.आगे और पीछे फ्लिप करते हैं: चूंकि अब यह गारंटी दी जाती है कि 1जब आपका कोड लागू किया जाता है, तो आप बस उपयोग कर सकते हैं $.^=1।

— वेंटरो

2

मुझे पता है कि मैंने झूठ बोला था, मेरी एक और टिप्पणी है: डी इनपुट के रूप में केवल प्रिंट करने योग्य एएससीआईआई की गारंटी है, हम नियमित अभिव्यक्तियों में यूनिकोड श्रेणियों के लिए रूबी के समर्थन का उपयोग कर सकते हैं: /\p{L}/(यूनिकोड श्रेणी पत्र ) एक चरित्र से कम है /[a-z|/i।

— वेंचरो

3

ब्रेकीलॉग , 25 बाइट्स

{ḷ|ụ}ᵐ.{ḷ∈Ạ&}ˢ¬{s₂{∈Ạ}ᵐ}∧

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

यह लंबा और धीमा दोनों है।

व्याख्या

{   }ᵐ.                       The Output is the result of mapping on each char of the Input:
 ḷ                              Lowecase the char
  |                             Or
   ụ                            Uppercase the char
       {    }ˢ                In the Ouput, select the chars that:
        ḷ∈Ạ&                    when lowercased are in "abc...xyz" (ie are letters)
              ¬{       }∧     In that new string, it is impossible to find:
                s₂              a substring of 2 consecutive chars
                  {∈Ạ}ᵐ         where both of them are in the lowercase alphabet

— Fatalize
स्रोत

3

MATL , 16 15 बाइट्स

Xktkyy-f2L))5M(

इसे ऑनलाइन आज़माएं! या सभी प्रकार के परीक्षण की पुष्टि ।

व्याख्या

इनपुट पर विचार करें 'हैलो वर्ल्ड'

Xk    % To upper case
      % STACK: 'HELLO WORLD'
t     % Duplicate top element
      % STACK: 'HELLO WORLD', 'HELLO WORLD'
k     % To lower case
      % STACK: 'HELLO WORLD', 'hello word'
yy    % Duplicate top two elements
      % STACK: 'HELLO WORLD', 'hello word', 'HELLO WORLD', 'hello word'
-     % Difference (of code points; element-wise)
      % STACK: 'HELLO WORLD', 'hello word', [-32 -32 -32 -32 -32 0 -32 -32 -32 -32 -32]
f     % Indices of nonzeros
      % STACK: 'HELLO WORLD', 'hello word', [1 2 3 4 5 7 8 9 10 11]
2L)   % Keep only even-indexed values (*)
      % STACK: 'HELLO WORLD', 'hello word', [2 4 7 9 11]
)     % Reference indexing (get values at indices)
      % STACK: 'HELLO WORLD', 'elwrd'
5M    % Push (*) again
      % STACK: 'HELLO WORLD', 'elwrd', [2 4 7 9 11]
(     % Assignment indexing (write values at indices). Implicit display
      % STACK: 'HeLlO wOrLd

'

— लुइस मेंडो
स्रोत

3

पर्ल 6 , 32 30 बाइट्स

{S:g/<:L><-:L>*<:L>?/$/.tclc()/}

कोशिश करो

{S:g{<:L><-:L>*<:L>?}=$/.tclc}

कोशिश करो

विस्तारित:

{  # bare block lambda with implicit parameter ｢$_｣

  S            # string replace (not in-place) implicitly against ｢$_｣

  :global

  {

    <+ :L >    # a letter
    <- :L >*   # any number of non-letters
    <+ :L >?   # an optional letter

  }

  =

  $/.tclc()    # uppercase the first letter, lowercase everything else
}

— ब्रैड गिल्बर्ट b2gills
स्रोत

3

q / kdb +, 51 42 38 बाइट्स

समाधान:

{@[x;;upper]1#'2 cut(&)x in .Q.a}lower

उदाहरण:

q){@[x;;upper]1#'2 cut(&)x in .Q.a}lower"hello world"
"HeLlO wOrLd"

टिप्पणियाँ:

.Q.a        // abcde...xyz lowercase alphabet
(&) x in    // where, returns indices for where x (hello world) is an alpha
2 cut       // splits list into 2-item lists
1#'         // takes first item of each 2-item list; ie the indices to uppercase
@[x;;upper] // apply (@) upper to x at these indices

— streetster
स्रोत

2

वी , 17 , 13 बाइट्स

VUÍáƒ¨áü$©/ì&

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

या सभी परीक्षण मामलों को सत्यापित करें!

HeXdUmP:

00000000: 5655 cde1 83a8 e1fc 24a9 2fec 26         VU......$./.&

स्पष्टीकरण:

यह एक संकुचित रेगेक्स ™ ge का उपयोग करता है , इसलिए इसे समझाने से पहले, आइए रेगेक्स का विस्तार करें:

:%s/\v\a.{-}(\a|$)/\l&

VUधर्मान्तरित सब कुछ को अपरकेस में। फिर हम इसे चलाते हैं:

:%                      " On every line:
  s/\v                  "   Substitute:
      \a                "     A letter
        .{-}            "     Followed by as few characters as possible
            (\a|$)      "     Followed by either another letter or an EOL
                  /     "   With:
                   \l   "     The next character is lowercased
                     &  "     The whole text we matched

पुराना / अधिक दिलचस्प जवाब:

:se nows
Vuò~h2/á

— DJMcMayhem
स्रोत

2

PHP, 71 बाइट्स

for(;a&$c=$argn[$i++];)echo ctype_alpha($c)?(ul[$k++&1].cfirst)($c):$c;

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

— जार्ग हुल्सरमन
स्रोत

2

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

qeu{_'[,65>&,T^:T{el}&}%

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

व्याख्या

q         e# Read all input.
eu        e# Uppercase it.
{         e# For each character:
 _        e#  Duplicate it.
 '[,65>&  e#  Set intersection with the uppercase alphabet.
 ,        e#  Length (either 0 or 1 in this case).
 T^:T     e#  XOR with T (T is initially 0), then store the result back in T.
 {el}&    e#  If The result of the XOR is true, lowercase the character.
}%        e# (end for)

— बिजनेस कैट
स्रोत

2

अजगर, 11 बाइट्स

srR~xZ}dGrZ

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

व्याख्या

              # Z = 0; Q = eval(input())
srR~xZ}dGrZQ  # Auto-fill variables
         rZQ  # lowercase the input
 rR           # Apply the r function to each letter of the input with
   ~xZ}dG     # ... this as the other argument
   ~          # use the old value of the variable Z, then update it with the value of ...
    xZ        # Z xor ...
      }dG     # the variable d is a lowercase letter
              # because of how mapping works in pyth, d will contain the current letter
              # This causes Z to flip between 0 and 1, alternately upper and lower casing
              # the current character if it is a letter

— FryAmTheEggman
स्रोत

2

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

-join($args[0]|%{if($_-match"[a-z]"-and($i=!$i)){"$_".toupper()}else{"$_".tolower()}})

इनपुट एक [char[]]सरणी है।

स्पष्टीकरण के लिए कोड में टिप्पणियाँ

# Join the array of string and char back together.
-join
    # Take the first argument and pass each element ([char]) down the pipe. 
    ($args[0]|%{
        # Check if this is a letter. Second condition is a boolean that changes at every pass 
        # but only if the current element is a letter. If not the condition never fires
        if($_-match"[a-z]"-and($i=!$i)){
            # Change the character to uppercase
            "$_".toupper()
        }else{
            # Output the character to lowercase. 
            # Special characters are not affected by this method
            "$_".tolower()
        }
    })

— मैट
स्रोत

2

हास्केल, 105 83 + 2 4 + 1 विभाजक का बाइट = 108 86 88 बाइट्स

import Data.Char
f#(x:y)|isLetter x=([toUpper,toLower]!!f)x:(1-f)#y|1>0=x:f#y
_#l=l

समारोह है (1#), लोअरकेस शुरू होता है। इसे ऑनलाइन आज़माएं!

~~दुःख की बात यह है कि यह जावा और C # से अधिक लंबा है और उत्तर है~~ कि Johan अर्जन जोहान्सन को तीन बर्तनों को एक में मर्ज करके 22 बाइट्स बचाने के लिए धन्यवाद!

— सामान्य प्रदर्शन का नाम
स्रोत

2

मैंने देखा कि इसे उन लंबे आयातित कार्यों की आवश्यकता थी इसलिए मैंने भी कोशिश नहीं की ... लेकिन यह थोड़ा बहुत है, आप कुछ लाइनों को मर्ज कर सकते हैं:f#(x:y)|isLetter x=([toUpper,toLower]!!f)x:(1-f)#y|1>0=x:f#y

— Mayrrr जोहानसन

नाइटपैकिंग के लिए क्षमा करें, लेकिन मुझे लगता 1#है कि यह एक अनाम फ़ंक्शन के रूप में नहीं गिना जाता है। मेरी समझ में, किसी व्यक्ति को एक अनाम फ़ंक्शन को पहचानकर्ता के साथ बाँधने में सक्षम होना चाहिए, लेकिन f=1#यह काम नहीं करेगा। इसके बजाय आपको (1#)+2 बाइट्स के लिए अनुभाग की आवश्यकता है । हास्केल में गोल्फिंग के लिए हमारे समुदाय के दिशानिर्देशों में यह भी स्पष्ट रूप से कहा गया है , हालांकि शायद उन्हें इस मामले का स्पष्ट उल्लेख करने के लिए अनुकूलित किया जाना चाहिए।

— लकोनी

@ लिकोनी ओके, जवाब अपडेट

— जेनेरिक डिस्प्ले नेम

2

Google शीट, 264 बाइट्स

=ArrayFormula(JOIN("",IF(REGEXMATCH(MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1),"[A-Za-z]"),CHAR(CODE(UPPER(MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1)))+MOD(LEN(REGEXREPLACE(LEFT(A1,ROW(OFFSET(A1,0,0,LEN(A1)))),"[^A-Za-z]","")),2)*32),MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1))))

यह एक बड़ी गड़बड़ी है लेकिन अगर आप इसका विस्तार करते हैं तो यह थोड़ा आसान है:

=ArrayFormula(
  JOIN(
    "",
    IF(REGEXMATCH(MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1),"[A-Za-z]"),
      CHAR(
        CODE(UPPER(MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1)))
        +
        MOD(LEN(REGEXREPLACE(LEFT(A1,ROW(OFFSET(A1,0,0,LEN(A1)))),"[^A-Za-z]","")),2)*32
      ),
      MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1)
    )
  )
)

छद्म तर्क इस तरह चलेगा:

For each character {                                    // ArrayFormula()
  If (character is a letter) {                          // REGEXMATCH(MID())
    Return CHAR(                                        // CHAR()
      CODE(UPPER(letter))                               // CODE(UPPER(MID()))
      +
      If (nth letter found and n is odd) {32} else {0}  // MOD(LEN(REGEXREPLACE(LEFT())))
    )
  } else {
    Return character                                    // MID()
  }
}

— इंजीनियर टोस्ट
स्रोत

2

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

के लिए 23 बाइट्स + 1 बाइट -p।

-2 बाइट्स के लिए @ डाडा को धन्यवाद ।

s/\pl/--$|?uc$&:lc$&/eg

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

— डोम हेस्टिंग्स
स्रोत

साफ। 2 बाइट्स थो \plकी बजाय [a-z]:)

— दादा

@ दादा, मैं वास्तव में नहीं जानता था कि! मुझे कैसे पता नहीं चला !! धन्यवाद!

— डोम हेस्टिंग्स

मुझे लगता है कि मैंने इसे टन हास्पेल से सीखा है, और मैं इसे अभी और फिर उपयोग करता हूं (वास्तव में मैं इसके बारे में बहुत बार भूल जाता हूं और [a-z]इसके बजाय उपयोग करता हूं !)। यदि आप आश्चर्य करते हैं, तो यह पेरेलरेचरक्लास से आता है ;)

— दादा

1

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

T`L`l
T`l`L`.(?=([^a-z]*|[a-z][^a-z]*[a-z])*$)

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

— नील
स्रोत

1

सी 64 बाइट्स

B;R(char *s){for(;*s=isalpha(*s)?(B=!B)?*s|=32:*s&=~32:*s;s++);}

एससीआई एन्कोडिंग का लाभ लेता है जहां ऊपरी और निचले मामले पत्र 0x20 द्वारा ऑफसेट होते हैं।

— user230118
स्रोत

आप के बीच की जगह की जरूरत नहीं है charऔर*s

— 19

यह दिखता है बहुत @ cleblanc के समान जवाब ।

— डिजिटल ट्रॉमा

मैंने इसे तब पोस्ट किया था जब @ क्लेब्लांक के पोस्ट ने टॉपर () और टावलर () का उपयोग किया था।

— user230118

1

इस दृष्टिकोण का सुझाव देने वाली मेरी टिप्पणी 18: 29: 34Z में थी। इसे शामिल करने के लिए क्लेब्लांक का संपादन 18: 37: 36Z पर था। आपका उत्तर 18: 38: 21Z पर पोस्ट किया गया था। इसलिए मुझे लगता है कि आपकी पोस्ट से पहले क्लीबल का जवाब एक मिनट से भी कम था। आपका उत्तर मेरे सुझाव के समान उल्लेखनीय है, लेकिन मुझे लगता है कि कोड-गोल्फ की प्रकृति - अक्सर एक ही भाषा में समाधान एक ही चीज़ में परिवर्तित हो जाएगा - तो मैं इसे स्लाइड करने दूँगा :)

— डिजिटल ट्रामा

1

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

T`l`L
01T`L`l`[A-Z][^A-Z]*[A-Z]?

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

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

01दूसरे चरण में करने के लिए मोटे तौर पर अनुवाद: इस स्तर मैच संख्या के आधार पर के व्यवहार में परिवर्तन नहीं करते हैं, लेकिन केवल प्रत्येक मैच के पहले अक्षर के लिए परिवर्तन लागू करें।

— FryAmTheEggman
स्रोत

1

PHP 5, 54 बाइट्स

<?=preg_filter('/\pL/e','($0|" ")^a^aA[$i^=1]',$argn);

— user63956
स्रोत

1

सी #, 100 बाइट्स

s=>{var r="";int m=0;foreach(var c in s)r+=char.IsLetter(c)?(char)(++m%2>0?c|32:c&~32):c;return r;};

— TheLethalCoder
स्रोत

1

ग्रूवी, 79 बाइट्स

{x=0;it.toUpperCase().collect{(it==~/\w/)?x++%2?it:it.toLowerCase():it}.join()}

— जादू ऑक्टोपस Urn
स्रोत

1

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

x=list(input())
s=[]
for i in x[1::2]:
 s.append(i)
 x.remove(i)
s.reverse()
while len(x)<len(s):
 x.append("")
while len(x)>len(s):
 s.append("")
for i in range(len(x)):
 print(end=x[i]+s[i])

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

— केर्ड सिक्काहिरिंग
स्रोत

0

उत्तल , 16 बाइट्स

¯{_U&,R^:R{¬}&}%

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

@Business कैट के उत्तर का उत्तल बंदरगाह ।

— GamrCorps
स्रोत

AlTeRnAtE tHe CaSe

उदाहरण:

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

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

05AB1E , 11 8 बाइट्स

कोड:

स्पष्टीकरण:

जीएनयू सैड, 33

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

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

जाप , 16 14 बाइट्स

व्याख्या

पायथन 3 , 86 76 68 66 63 बाइट्स

ऐलिस , 18 बाइट्स

व्याख्या

C (tcc) , 60 57 56 बाइट्स

जावा 8, 99 बाइट्स

रूबी, 57 55 47 41 बाइट्स

ब्रेकीलॉग , 25 बाइट्स

व्याख्या

MATL , 16 15 बाइट्स

व्याख्या

पर्ल 6 , 32 30 बाइट्स

विस्तारित:

q / kdb +, 51 42 38 बाइट्स

वी , 17 , 13 बाइट्स

PHP, 71 बाइट्स

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

व्याख्या

अजगर, 11 बाइट्स

व्याख्या

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

स्पष्टीकरण के लिए कोड में टिप्पणियाँ

हास्केल, 105 83 + 2 4 + 1 विभाजक का बाइट = 108 86 88 बाइट्स

Google शीट, 264 बाइट्स

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

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

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

PHP 5, 54 बाइट्स

सी #, 100 बाइट्स

ग्रूवी, 79 बाइट्स

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

उत्तल , 16 बाइट्स