रिक्तियां निकालें, पूंजीकरण बनाए रखें

Question

आपका इनपुट एक अंग्रेजी वाक्य, वाक्यांश या शब्द होगा। इसमें केवल शामिल होगा a-zA-Z' -,.!?। आपका कार्य इनपुट लेना, रिक्त स्थान निकालना, और फिर पूंजीकरण को पुनर्वितरित करना है जैसे कि अनुक्रमित अक्षरों को पहले कैपिटल किया गया था (और पहले इंडेक्स में केवल अक्षरों को कैपिटल में कैपिटल किया गया था)।

उदाहरण के लिए, यदि इनपुट है A Quick Brown Fox Jumped Over The Lazy Dog, तो बड़े अक्षरों के (0-आधारित) सूचकांक हैं 0, 2, 8, 14, 18, 25, 30, 34, 39। अगला, इनपुट से रिक्त स्थान निकालें AQuickBrownFoxJumpedOverTheLazyDog:। इसके बाद, सभी अक्षरों को नीचे करें, लेकिन उन पर अपरकेस 0, 2, 8, 14, 18, 25, 30, 34, 39: AqUickbrOwnfoxJumpEdovertHelazYdogजो आपका आउटपुट है।

इनपुट

आपका इनपुट एक अंग्रेजी वाक्य, वाक्यांश या शब्द होगा। इसमें केवल लोअरकेस अक्षर, अपरकेस अक्षर, हाइफ़न, एपॉस्ट्रॉफ़, अल्पविराम, अवधि, प्रश्न चिह्न, विस्मयादिबोधक चिह्न और रिक्त स्थान हो सकते हैं।

उत्पादन

इनपुट अपरकेस-डी में बड़े अक्षरों के सूचकांक में अक्षरों के साथ रिक्त स्थान को हटा दिया गया, लोअरकेस-डी।

नोट: आपका प्रोग्राम किसी IndexOutOfRange या इसी तरह की त्रुटि के साथ क्रैश (इस तरह के निष्पादन को समाप्त करता है) को क्रैश नहीं कर सकता है।

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

Hi! Test!
Hi!tEst!

A Quick Brown Fox Jumped Over The Lazy Dog
AqUickbrOwnfoxJumpEdovertHelazYdog

testing TESTing TeStING testing testing TESTING
testingtESTIngteStInGTEstingtestingtestiNG

TESTING... ... ... success! EUREKA???!!! maybe, don't, NOOOOO
TESTING.........success!eureKA???!!!maybe,don't,nooooo

Enter        PASSWORD ---------
Enterpassword---------

A a B b C c D d E e F f G g H h I i J j K k L l M m N n O o P p Q q R r S s T t U u V v W w X x Z z
AabbCcddEeffGghhIijjKkllMmnnOoppQqrrSsttUuvvWwxxZz

  TEST
teST

Comments

सैंडबॉक्स

— स्टीफन

'उदाहरण के लिए, यदि इनपुट "ए क्विक ब्राउन फॉक्स जंप ओवर द लेजी डॉग" है, (0-आधारित) बड़े अक्षरों के इंडेक्स हैं 0, 2, 8, 14, 18, 23, 27, 32' वे हैं0, 2, 8, 14, 18, 25, 30, 34, 39

— ल्यूक सवाक

@LukeSawczak आपका शुक्रिया, मेरा बुरा

— स्टीफन

रिक्त स्थान की अनुमति नहीं है, मुझे लगता है?

— लुइस मेंडो

@LuisMendo आपकी धारणा सही है। यह कोड-गोल्फ है, है ना? : पी

— स्टीफन

Answer 1

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

nŒlTɓḲFŒlŒuṛ¦

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

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

nŒlTɓḲFŒlŒuṛ¦  Main link. Argument: s (string)

 Œl            Convert s to lowercase.
n              Perform character-wise "not equal" comparison.
   T           Get the indices of all truthy elements, i.e., the indices of all
               uppercase letters in s. Let's call the resulting array J.
    ɓ          Begin a dyadic chain with left argument s and right argument J.
     ḲF        Split s at spaces and flatten, removing the spaces.
       Œl      Convert s to lowercase.
            ¦  Sparse application:
         Œu        Convert s to uppercase.
           ṛ       Take the resulting items of the uppercased string at all indices
                   in J, the items of the lowercased string at all others.

Answer 2

C (gcc) , 82 79 74 72 69 67 66 बाइट्स

f(c){for(char*s=c,*p=c;c=*s++;c&&putchar(c^(*p++|~c/2)&32))c&=95;}

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

Answer 3

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

x=input()
X=x.replace(' ','')
print''.join([X[i].upper()if x[i].isupper()else X[i].lower()for i in range(len(X))])

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

इसके तुल्य:

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

lambda x:''.join([[str.lower,str.upper][x[i].isupper()](x.replace(' ','')[i])for i in range(len(x)-x.count(' '))])

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

Comments

''.join([(X[i].lower,X[i].upper)[x[i].isupper()]()for i in range(len(X))])-5 बाइट्स के लिए।

— अंडा

Answer 4

पायथन 3 , 78 75 72 बाइट्स

s=input()
for c in s:s=s[c>' '!=print(end=(c+c).title()[s<'@'or'['<s]):]

6 बाइट बंद करने के लिए @xnor को धन्यवाद!

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

Comments

क्या आप sइसके बजाय सिर्फ तुलना कर सकते हैं s[0]?

— xnor

हां बिल्कुल। धन्यवाद!

— डेनिस

(c*2).title()आप दोनों मामलों को प्राप्त कर सकते हैं, हालांकि स्विच किया हुआ।

— xnor

एक और 3 बाइट्स। एक बार फिर धन्यवाद!

— डेनिस

मुश्किल! मुझे यह पता लगाने में थोड़ा समय लगा कि c>' '!=f()इसके बराबर है (c>' ') and (' '!=f())।

— चास

Answer 5

05AB1E , 15 14 बाइट्स

-1 बाइट एमिग्ना के लिए धन्यवाद

ðKuvy¹Nè.lil}?

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

ðK             # Remove spaces
  u            # Convert to uppercase
   vy          # For each character...
     ¹Nè       #   Get the character at the same index from the original input
        .lil}  #   If it was a lowercase letter change this one to lowercase
             ? # Print without a newline

Comments

आप एक बाइट को बचाते हैं यदि आप अंतरिक्ष से हटाए गए स्ट्रिंग को ऊपर ले जाते हैं और इसे स्थिति में कम करते हैं।

— इमीना

Answer 6

हास्केल , 98 95 89 88 81 बाइट्स

कुल 14 बाइट्स से दाढ़ी बनाने में मदद करने के लिए @name, @nimi, @Zgarb, और @ लैकोनी का धन्यवाद

import Data.Char
\s->zipWith(\p->last$toLower:[toUpper|isUpper p])s$filter(>' ')s

Ungolfed:

import Data.Char
\sentence -> zipWith (\oldChar newChar ->
                        if isUpper oldChar
                        then toUpper newChar
                        else toLower newChar)
                     sentence
                     (filter (/= ' ') sentence)

Comments

मोबाइल पर, लेकिन ऐसा लगता है कि आप फ़िल्टर (/ = '') के साथ कुछ बाइट्स बचा सकते हैं

— हेनरी

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

— जूलियन वुल्फ

filter(>' ')एक बाइट के लिए कम

— nimi

मुझे लगता है कि last(toLower:[toUpper|isUpper p])c

— लंबोदर

तर्क को स्विच zipWithकरना चाहिए एक और बाइट को बचाना चाहिए f s=zipWith(\p->last$toLower:[toUpper|isUpper p])s$filter(>' ')s:।

— लकोनी

Answer 7

वी , 24 बाइट्स

ÄVuÓó
ejlDò/¥2lõ
vuk~òGd

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

इस तरह की चुनौतियां ठीक वही हैं जो वी के लिए बनाई गई थीं। :)

स्पष्टीकरण:

Ä           " Duplicate this line
 Vu         " Convert it to lowercase
   Óó       " Remove all spaces
e           " Move to the end of this line
 j          " Move down a line (to the original)
  l         " Move one char to the right
   D        " And delete the end of this line
    ò       " Recursively:
     /      "   Search for:
         õ  "     An uppercase character
      ¥2l   "     On line 2
            "     (This will break the loop when there are no uppercase characters left)
vu          "   Convert it to lowercase
  k         "   Move up a line
   ~        "   Convert this to uppercase also
    ò       " Endwhile
     G      " Move to the last line
      d     " And delete it

Comments

@DLosc अच्छा सवाल! Newlines एक regex कमांड के अंत का संकेत देता है, जैसे कि एक विकल्प (निकालें) या खोज कमांड। अधिक विस्तार इस पृष्ठ पर है: github.com/DJMcMayhem/V/wiki/Regexes

— DJMcMayhem

Answer 8

अजगर 2, 100 बाइट्स

s=input()
print"".join([c.lower(),c.upper()][s[i].isupper()]for i,c in enumerate(s.replace(" ","")))

Comments

PPCG में आपका स्वागत है, और बहुत अच्छा पहला जवाब!

— ETHproductions

Answer 9

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

/..- ~l+u~mSloy
\ia''-y.'Qa.+a@/

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

व्याख्या

यह उन कार्यक्रमों के लिए एक मानक टेम्पलेट है जो पूरी तरह से सामान्य मोड में काम करते हैं। अनवांटेड, प्रोग्राम इस प्रकार है:

i.' -l.uQm.lay.a-'~y+'~aS+o@

i       take input as string
.       duplicate
' -     remove spaces from copy
l.u     create all-lowercase and all-uppercase versions
Q       reverse stack, so original string is on top
m       truncate original string to length of spaces-removed string
.lay    convert everything except uppercase characters to \n
.a-'~y  convert everything except \n (i.e., convert uppercase characters) to ~
+       superimpose with lowercase string
        \n becomes the corresponding lowercase character, and ~ remains as is
'~aS    convert ~ to \n
+       superimpose with uppercase string
        lowercase in existing string stays as is because it has a higher code point
        \n becomes corresponding uppercase character
o       output
@       terminate

Answer 10

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

s=>s.replace(/./g,c=>c==" "?"":c[`to${"@"<s[x]&s[x++]<"["?"Upp":"Low"}erCase`](),x=0)

• 6 बाइट्स ETHproductions और Arnauld की सहायता से बचाए गए।

---

कोशिश करो

o.innerText=(f=

s=>s.replace(/./g,c=>c==" "?"":c[`to${"@"<s[x]&s[x++]<"["?"Upp":"Low"}erCase`](),x=0)

)(i.value="Hi! Test!");oninput=_=>o.innerText=f(i.value)

<input id=i><pre id=o>

Comments

निनजाद: पी कोडगोल्फ.स्टैकएक्सचेंज.

— स्टीफन

क्या आप कर सकते हैं '@'<s[i]&s[i]<'['??

— ETHproductions

@StepHen: अरे, यार, कल रात नहीं देखा था जब मैं इस पर काम कर रहा था।

— झबरा

@ETHproductions: मैं सोच रहा था कि अगर यह छोटा हो सकता है, लेकिन मैं यह देखने के लिए बहुत आलसी था कि मुझे किन वर्णों का उपयोग करने की आवश्यकता होगी: D इसे बाइट को बचाने के लिए बंद कर देता है; धन्यवाद।

— झबरा

Answer 11

रेटिना , 77 71 बाइट्स

.+
$&¶$&
T`L `l_`.+$
+`((.)*)[A-Z].*(¶(?<-2>.)*)
$1$3 
.+¶

T`l `L_` .?

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण सूट शामिल है। स्पष्टीकरण: पहला चरण लाइन को डुप्लिकेट करता है जबकि दूसरा चरण डुप्लिकेट को कम करता है और इसके रिक्त स्थान को हटाता है। तीसरा चरण फिर प्रत्येक बड़े अक्षर के माध्यम से दाएं से बाएं और दूसरी पंक्ति पर संबंधित वर्ण से पहले एक स्थान रखने का प्रयास करता है। पहली पंक्ति को हटा दिया गया है और रिक्त स्थान का उपयोग परिणाम के प्रासंगिक पात्रों को अपरकेस करने के लिए किया जाता है। संपादित करें: सहेजे गए 6 बाइट @Kobi के लिए धन्यवाद।

Comments

छोटा प्रश्न: क्या (.?)और $4भागों की आवश्यकता है? ऐसा लगता है कि अंत में एक वैकल्पिक समूह होने से कुछ नहीं होता है।

— कोबी

@ कोबी उस सवाल के बारे में कुछ भी छोटा नहीं है! यह मूल रूप से वर्णों का उपयोग करने के प्रयास के लिए एक अलग चरण के रूप में अनुवाद करने के बजाय सीधे अक्षरों के मिलान के लिए एक प्रयास का हिस्सा था।

— नील

Answer 12

पर्ल, 95 94 + 1 = 95 बाइट्स

-N के लिए +1 बाइट जुर्माना

से बदलने के द्वारा एक बाइट सहेजें s/\s//gकरने के लिएs/ //g

$s=$_;s/ //g;$_=lc($_);while(/(.)/gs){$p=$&;$p=uc($p)if(substr($s,$-[0],1)=~/[A-Z]/);print$p;}

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

स्पष्टीकरण:

1. इनपुट स्ट्रिंग की प्रतिलिपि बनाएँ।

2. सभी रिक्त स्थान निकालें और स्ट्रिंग को निचले मामले में बदलें।

3. फिर प्रत्येक अक्षर पर लूप शुरू करें। ऊपरी स्थिति के लिए सहेजे गए स्ट्रिंग में समान स्थिति में परीक्षण पत्र। यदि यह ऊपरी है - तो वर्तमान पत्र को वशीकरण करें। प्रिंट पत्र।

ध्यान दें कि पर्ल को "-n" कमांड लाइन स्विच के साथ चलाने की आवश्यकता है

Comments

PPCG में आपका स्वागत है! यदि आप चाहें, तो आप इसे आज़माने के लिए एक लिंक जोड़ सकते हैं: tio.run/# (मैं इसे जोड़ूंगा , लेकिन मुझे नहीं पता कि यह पर्ल 5 है या पर्ल 6)

— स्टीफन

मुझे लगता है कि आपको ध्वज के +1लिए बाइट गिनने की आवश्यकता है -n। इसके अलावा, यह अच्छा लग रहा है! साइट पर आपका स्वागत है! :)

— डीजेमेक्मे

@ यह 5 पर्ल है, आप लिंक जोड़ सकते हैं? मैं प्रॉपर तरीके से वहां अपना कोड चलाने में विफल रहा।

— वीटसेल

एक नया पर्ल गोल्फर देखने के लिए खुश! मैंने आपके उत्तर में TIO लिंक जोड़ दिया है और स्वरूपण में सुधार किया है।

— दादा

Answer 13

MATL , 18 बाइट्स

kXz"@GX@)tk<?Xk]&h

रिले के 05AB1E उत्तर के रूप में समान दृष्टिकोण ।

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

Answer 14

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

s=input()
y=list(s.replace(' ','').lower())
i=0
for c in y:
 if s[i].isupper():y[i]=c.upper()
 i+=1
print(''.join(y))

यह ऑनलाइन की कोशिश करो!

यह मेरा पहला कोड गोल्फ है, इसलिए यह खराब होने की संभावना है, नीचे टिप्पणी से माइनस मदद करें!

PS हाँ, यह गूंगा है कि परिभाषित करना और बढ़ाना iबाइट्स को रेंज (len (y)) से बचाता है। ओह अच्छा।

Comments

PPCG में आपका स्वागत है! अच्छा प्रथम प्रस्तुत! हालाँकि, हमारी साइट के I / O मानकों का अनुपालन करते हुए, आपका सबमिशन या तो एक स्ट्रिंग का कार्य होना चाहिए या इनपुट लेना चाहिए; आप यह नहीं मान सकते कि इनपुट एक चर में है। आशा है कि आपने अपने ठहरने का आनन्द लिया होगा! :)

— हाइपरन्यूट्रीनो

धन्यवाद; एक समारोह में संपादित, लेकिन यह भी शरीर में 5 बाइट्स बचाया: डी

— ल्यूक Sawczak

@LukeSawczak इंडेंटेशन के लिए एक स्थान पर बदलकर एक टन बाइट बचाते हैं, और शायद इसे ऑनलाइन आज़माएं! लिंक अगर आप चाहते हैं

— स्टीफन

आप के बाद अंतरिक्ष निकाल सकते हैं return।

— कैलक्यूलेटरफैनलाइन

@LukeSawczak यह कैसे है? tio.run/…

— स्टीफन

Answer 15

सी # (.NET कोर) , 108 101 बाइट्स

using System.Linq;s=>s.Replace(" ","").Select((c,i)=>s[i]>64&s[i]<91?char.ToUpper(c):char.ToLower(c))

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

• 7 बाइट्स को यह महसूस करने के बाद बचाया गया कि charकक्षा में स्थैतिक ToUpper()और ToLower()विधियाँ हैं।

Answer 16

चारकोल , 33 बाइट्स

Ａ⁰χＦＬθ¿⁼§θι Ａ⁺¹χχ¿№α§θ⁻ιχ↥§θι↧§θι

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

जैसा कि मुझे अभी भी पता नहीं है कि चारकोल कोड में सिंगल इनपुट पैरामीटर के रूप में व्हाट्सएप के साथ एक स्ट्रिंग कैसे पास की जाती है, मैं सिर्फ हेडर में परीक्षण स्ट्रिंग को चारकोल चर में असाइन करता हूं जो यह दर्शाता है कि पहला इनपुट क्या होगा ( θ):

ＡA Quick Brown Fox Jumped Over The Lazy Dogθ

तो कोड में बाइट्स की संख्या समान है जैसे कि स्ट्रिंग को पहले इनपुट के रूप में पारित किया गया था।

आप यहां कोड का वर्बोज़ संस्करण देख सकते हैं ।

Comments

मैंने एक अन्य उत्तर में कहा लेकिन सिर्फ अगर आप भूल जाते हैं, तो एक तत्व के साथ अजगर सरणी के रूप में इनपुट

— केवल

मैं सिर्फ एक अनुगामी newline के लिए इनपुट की आवश्यकता है।

— नील

Answer 17

PHP, 181 बाइट्स

मैं कोशिश करता हूं कि बाइट्स की संख्या कम हो, यह मेरा कोड है:

<?php
$s=readline();
preg_match_all('/[A-Z]/',$s,$m,PREG_OFFSET_CAPTURE);
$s=strtolower(str_replace(' ','',$s));
while($d=each($m[0]))$s[$d[1][1]]=strtoupper($s[$d[1][1]]);
echo $s;

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

Comments

एक निरंतरता के बजाय PREG_OFFSET_CAPTUREआप मान का उपयोग कर सकते हैं 256, एक इनपुट के लिए $argnएक छोटा सा चर है readline()और मुझे लगता है ctype_upperऔर इसका उपयोग करें lcfirstऔर ucfirstएक लूप $$iऔर टर्नरी ऑपरेटर के उपयोग के साथ बहुत सारे बाइट्स

— बचाएंगे

Answer 18

जावा 8, 184 177 161 बाइट्स

s->{String r="";for(int i=0,j=i,t,u;i<s.length;){t=s[i++];if(t>32){u=s[j++];r+=(char)(t<65|t>90&t<97|t>122?t:u>64&u<91?t&~32:u>96&u<123|u<33?t|32:t);}}return r;}

निश्चित रूप से कुछ और गढ़ा जा सकता है ..
- 16 बाइट्स धन्यवाद @ OlivierGrégoire केchar[] बजाय इनपुट लेने के बजाय String।

स्पष्टीकरण:

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

s->{                           // Method with char-array parameter and String return-type
  String r="";                 //  Result-String
  for(int i=0,j=i,t,u;         //  Some temp integers and indices
      i<s.length;){            //  Loop over the String
    t=s[i++];                  //   Take the next character and save it in `t` (as integer)
                               //   and raise index `i` by 1
    if(t>32){                  //   If `t` is not a space:
     u=s[j++];                 //   Take `u` and raise index `j` by 1
     r+=                       //   Append the result-String with:
      (char)                   //    Integer to char conversion of:
       (t<65|t>90&t<97|t>122?  //     If `t` is not a letter:
        t                      //      Simply use `t` as is
       :u>64&u<91?             //     Else if `u` is uppercase:
        t&~32                  //      Take `t` as uppercase
       :u>96&u<123|u<33?       //     Else if `u` is lowercase or a space:
        t|32                   //      Take `t` as lowercase
       :                       //     Else:
        t);                    //      Take `t` as is
    }
  }                            //  End of loop
  return r;                    //  Return result-String
}                              // End of method

Comments

char[]इस एक के लिए एक स्ट्रिंग के बजाय ले लो , तुम बहुत बाइट बचाओगे!

— ओलिवियर ग्रेजायर

दूसरी ओर, मैंने दूसरे एल्गोरिथम के साथ भी उत्तर दिया । और यहाँ, मैं इसके विपरीत तर्क देता हूँ: in = String, out = char[]:-)

— ओलिवियर ग्रेजायर

Answer 19

आम लिस्प, 104 बाइट्स

(defun f(s)(map'string(lambda(x y)(if(upper-case-p x)(char-upcase y)(char-downcase y)))s(remove #\  s)))

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

वर्डी कॉमन लिस्प के लिए असामान्य रूप से कम!

सीधा कोड:

(defun f (s)                     ; receive the string as parameter
  (map 'string                   ; map the following function of two arguments
       (lambda (x y)             ; x from the original string, y from the string with removed spaces
         (if (upper-case-p x)    ; if x is uppercase
             (char-upcase y)     ; get y uppercase
             (char-downcase y))) ; else get y lowercase
       s
       (remove #\  s)))

Answer 20

जावा (ओपनजेडके 8) , 150 117 113 97 बाइट्स

s->{for(int i=0,j=0,c;i<s.length;)if((c=s[i++]&95)>0)System.out.printf("%c",c^(s[j++]|~c/2)&32);}

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

अधिक गोल्फिंग करते हुए, मैं 102 बाइट्स पर आया:

s->{for(int i=0,j=0,c;i<s.length;)if((c=s[i++]&95)>0)System.out.printf("%c",c<64?c|32:c|s[j]&32,j++);}

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

लेकिन मुझे याद है कि यह डेनिस सी के उत्तर की तरह लग रहा था इसलिए मैंने बस उसकी बिट-ट्विडलिंग और ... जादू हुआ। बंदरगाह से बड़ा लाभ शाखाओं और उनके अंदर की पुनरावृत्ति को दूर कर रहा है।

Comments

@ceilingcat जो काम नहीं करता है: Hi! Test!बन जाना चाहिए Hi!tEst!, लेकिन आपके समाधान के साथ यह बन जाता है Hi!Test।

— ओलिवियर ग्रेजायर

Answer 21

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

=ArrayFormula(JOIN("",IF(REGEXMATCH(MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1),"[A-Z]"),MID(UPPER(SUBSTITUTE(A1," ","")),ROW(OFFSET(A1,0,0,LEN(A1))),1),MID(LOWER(SUBSTITUTE(A1," ","")),ROW(OFFSET(A1,0,0,LEN(A1))),1))))

इनपुट सेल में है A1और सूत्र इस तरह टूट जाता है:

• ArrayFormula()हमें ROW()स्वतंत्र रूप से प्रत्येक पद का मूल्यांकन करने देता है
• JOIN() उन सभी स्वतंत्र परिणामों को एक ही स्ट्रिंग में सम्मिलित करता है
• IF(REGEXMATCH(),UPPER(),LOWER() इनपुट में उस स्थिति पर क्या मामला था, इसके आधार पर ऊपरी या निचले मामले का उपयोग करके इसे वैकल्पिक बनाता है
• ROW(OFFSET())मूल्यों की एक सरणी रिटर्न 1के लिए A1.lengthकि में खिलाया जा सकता है MID()समारोह तो हम बदले में प्रत्येक चरित्र का मूल्यांकन कर सकते

परीक्षण मामलों के परिणाम: (यदि आप बड़े संस्करण के लिए क्लिक करते हैं, तो यह पढ़ना आसान है)

Answer 22

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

->a{n=a.downcase.delete' '
n.size.times{|i|(?A..?Z)===a[i]&&n[i]=n[i].upcase}
n}

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

Comments

आप का उपयोग करके एक जोड़े बाइट्स बचा सकता है n.gsub(/./){}के बजाय n.size.times{};n: n.gsub(/./){(?A..?Z)===a[i]?$&.upcase: $&}।

— जॉर्डन

Answer 23

पर्ल, 92 बाइट्स

$p[$i++]=$-[0]while s/[A-Z]/lc($&)/e;s/\s//g;for$c(@p){substr($_,$c,1)=~tr[a-z][A-Z]};print;

स्पष्टीकरण:

$p[$i++]=$-[0]while s/[A-Z]/lc($&)/e;   #get locations of caps into an array at the same time converting letters to lowercase

s/\s//g;   #delete all spaces

for$c(@p){substr($_,$c,1)=~tr[a-z][A-Z]};   #convert lowercase letters to uppercase where uppercase letters were present

print;   # print (of course) :)

Comments

PPCG में आपका स्वागत है! :)

— स्टीफन

आपको -nअपना उत्तर मान्य करने के लिए ध्वज जोड़ने की आवश्यकता है। कुछ गोल्फ की चीजें: s/ //gपर्याप्त है (कोई ज़रूरत नहीं है \s), y/a-z/A-Z/उसी तरह है tr[a-z][A-Z], आप -pध्वज का उपयोग कर सकते हैं ताकि आपको आखिरी printज़रूरत न हो, आपको कोष्ठक की आवश्यकता नहीं है lc$&।

— दादा

Answer 24

सी, 103 बाइट्स

i,j,c;f(char*s){for(i=j=0;c=tolower(s[j++]);)c-32&&putchar(c-32*(s[i]>64&&s[i]<91&&c>96&&c<123))&&++i;}

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

Answer 25

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

lambda s:''.join(c.upper()if i in(s.find(q)for q in s if q.isupper())else c for i,c in enumerate(s.replace(' ','').lower()))

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

Answer 26

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

s=input()
print''.join(map(lambda(c,u):[c.lower,c.upper][u](),zip(s.replace(' ',''),map(str.isupper,s))))

संपादित करें: एक बाइट को print ''.join=> के माध्यम से सहेजें print''.join।

लैंबडा फॉर्म, 99 बाइट्स

lambda s:''.join(map(lambda(c,u):[c.lower,c.upper][u](),zip(s.replace(' ',''),map(str.isupper,s))))

Answer 27

SCALA, 128 चार्ट, 128 बाइट्स

var l=s.toLowerCase().filter(x=>x!=32)
for(i<-0 to l.size-1){if(s(i).isUpper)l=l.substring(0,i)+l(i).toUpper+l.substring(i+1)}
l

इस चुनौती के लिए धन्यवाद। इसे ऑनलाइन आज़माएं!

Answer 28

क्यू / केडीबी +, ४ ९ बाइट्स

समाधान:

{@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}

उदाहरण:

q){@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}"Hi! Test!"
"Hi!tEst!"

q){@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}"A Quick Brown Fox Jumped Over The Lazy Dog"
"AqUickbrOwnfoxJumpEdovertHelazYdog"

q){@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}"testing TESTing TeStING testing testing TESTING"
"testingtESTIngteStInGTEstingtestingtestiNG"

q){@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}"TESTING... ... ... success! EUREKA???!!! maybe, don't, NOOOOO"
"TESTING.........success!eureKA???!!!maybe,don't,nooooo"

q){@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}"Enter        PASSWORD ---------"
"Enterpassword---------"

q){@[a;(&)(#:[a:lower x except" "]#x)in .Q.A;upper]}"A a B b C c D d E e F f G g H h I i J j K k L l M m N n O o P p Q q R r S s T t U u V v W w X x Z z"
"AabbCcddEeffGghhIijjKkllMmnnOoppQqrrSsttUuvvWwxxZz"

q){@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}"  TEST"
"teST"

स्पष्टीकरण:

upperउन सूचकांकों का पता लगाएं जहां इनपुट अपरकेस है और फिर इनपुट स्ट्रिंग के लोअरकेस, स्पेस-हटाए गए संस्करण पर उन सूचकांकों पर फ़ंक्शन लागू करें । ध्यान दें कि हम फ़ंक्शन को स्ट्रिंग की लंबाई से परे लागू नहीं कर सकते, इसलिए #लोअरकेस, स्पेस-हटाए गए संस्करण की इनपुट स्ट्रिंग को छोटा करने के लिए take ( ) का उपयोग करें ।

{@[a;where count[a:lower x except " "]#x in .Q.A;upper]} / ungolfed
{                                                      } / lambda function
 @[ ;                                           ;     ]  / apply FUNC to VAR at INDICES: @[VAR;INDICES;FUNC]
                                                 upper   / uppercase, upper["abc"] -> "ABC"
                                       x in .Q.A         / boolean list where input is in uppercase alphabet ABC..XYZ
                                      #                  / take this many elements from list on the right (ie truncate)
           count[                    ]                   / returns length of the stuff inside the brackets, count["ABC"] -> 3                                        
                         x except " "                    / remove " " from string
                   lower                                 / lowercase, lower["ABC"] -> "abc"
                 a:                                      / save in variable a
     where                                               / returns indices where true where[101b] -> 0 2
   a                                                     / our lowercased, space-stripped input

बोनस:

जवाब पढ़ने के बाद, सोचा कि मैं एक समाधान की कोशिश करूंगा, जहां मैं इनपुट पर पुनरावृति करता हूं, अब तक मैंने केवल 53 बाइट समाधान का प्रबंधन किया है:

{a{$[y in .Q.A;upper x;x]}'#:[a:lower x except" "]#x}

Answer 29

स्विफ्ट 3.0, 199 बाइट्स

var s="AS Ff",i=[String](),p=[Int](),j=0;for c in s.characters{if c>="A"&&c<="Z"{p.append(j)};if c != " "{i.append(String(c).lowercased())};j=j+1};for c in p{i[c]=i[c].uppercased()};print(i.joined())

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

Answer 30

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

कोड + -Fध्वज के 37 बाइट्स । (ध्यान दें कि पर्ल के पुराने संस्करणों पर, आपको -anझंडे जोड़ने की आवश्यकता हो सकती है )

print$F[$i++]=~/[A-Z]/?uc:lc for/\S/g

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

स्पष्टीकरण:
धन्यवाद -F, @Fइनपुट के हर वर्ण की एक सूची है।
for/\S/gइनपुट के हर गैर-अंतरिक्ष वर्ण पर पुनरावृत्त करता है। हम $iयह गिनने के लिए उपयोग करते हैं कि हम किस पुनरावृत्ति में हैं। यदि $F[$i++]एक अपरकेस वर्ण ( /[A-Z]/) है, तो हम अपरकेस वर्तमान वर्ण ( uc) को प्रिंट करते हैं, अन्यथा, हम इसे लोअरकेस ( lc) में प्रिंट करते हैं । ध्यान दें कि ucऔर lcवापसी उनके तर्क में कोई बदलाव नहीं करता है, तो यह एक पत्र नहीं है।

---

पिछला संस्करण (कम गोल्फ वाला: 47 बाइट्स):

 s/ //g;s%.%$_=$&;$F[$i++]=~/[A-Z]/?uc:lc%ge

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