डुप्लिकेट और स्विच केस

34

लक्ष्य है, इनपुट के रूप में एक स्ट्रिंग लेना, प्रत्येक लैटिन पत्र को डुप्लिकेट करना और उसका मामला "टॉगल करना" (यानी अपरकेस लोअरकेस और इसके विपरीत हो जाता है)।

उदाहरण इनपुट और आउटपुट:

Input      Output
bad        bBaAdD
Nice       NniIcCeE
T e S t    Tt eE Ss tT
s E t      sS Ee tT
1!1!1st!   1!1!1sStT!
n00b       nN00bB     
(e.g.)     (eE.gG.)
H3l|@!     Hh3lL|@!

इनपुट में मुद्रण योग्य ASCII प्रतीक शामिल हैं।

आपको गैर-लैटिन अक्षरों, संख्याओं, विशेष वर्णों की नकल नहीं करनी चाहिए।

code-golf  string 
— nicael
स्रोत
17
यह एक बहुत अच्छी, सरल-लेकिन-नहीं-तुच्छ चुनौती है।
— मेगो

जवाबों:

17

पायथन, 56 54 बाइट्स

lambda s:''.join(c+c.swapcase()*c.isalpha()for c in s)

Ideone पर इसका परीक्षण करें ।

— डेनिस
स्रोत
डांग! मुझे 4 बाइट्स के लिए बाहर निकाला गया ...
— आर। कप
यह गैर-अक्षर वाले पात्रों को कैसे बनाए रखता है? मुझे लगता है कि वे खाली तारों के रूप में दिखाई देंगे।
— एटलसोलॉजिस्ट
@atlasologist जैसा कि आप Ideone पर देख सकते हैं, वे नहीं करते हैं। *से अधिक पूर्वता है +, इसलिए यह केवल cस्वैप किए गए मामले से प्रभावित होती है ।
— डेनिस
ओह, ठीक है, मैंने ऐसा नहीं सोचा था। अच्छा लगा।
— एटलसोलॉजिस्ट
16

जावास्क्रिप्ट ईएस 6, 70 68 66 64 बाइट्स

सहेजे गए 2 बाइट्स @ केविन लाउ के लिए धन्यवाद - केनी नहीं

2 बाइट्स @ Cʀɪᴇɴ O'Bed की बदौलत बच गए

s=>s.replace(/[A-Z]/gi,l=>l+l[`to${l<"a"?"Low":"Upp"}erCase`]())

व्याख्या

यह वास्तव में हैकी का उपयोग करता है:

l[`to${l<"a"?"Low":"Upp"}erCase`]()

कौन सा अधूरा है:

l[`to${
   l < "a" ?
   "Low" : 
   "Upp"
}erCase`]()

मूल रूप से l < "a"जांचता है कि यदि पत्र का कोड बिंदु कम है तो कोड बिंदु a(इसलिए एक अपरकेस अक्षर है)। यदि ऐसा है तो वह करूँगा to + Low + erCaseजो l['toLowerCase']()चरित्र का स्वागत करता है और चरित्र को कम करता है। `उद्धरण स्ट्रिंग स्वरूपण की अनुमति देता है ताकि आप इसके बारे में सोच सकें:

`to${l < "a" ?"Low" : "Upp"}erCase`

के रूप में: "to" + (l<"a" ? "Low" : "Upp") + "erCase"जो कॉल करने के लिए फ़ंक्शन उत्पन्न करता है (स्ट्रिंग ऊपरी या निचले मामले में)। हम इसे चौकोर कोष्ठक में लगाते हैं, [ ... ]जो हमें एक स्ट्रिंग के रूप में इसके नाम पर दी गई संपत्ति तक पहुंचने देता है। यह उचित फ़ंक्शन देता है और फिर हम इसे कहते हैं।

— Downgoat
स्रोत
3
/[A-Z]/giएक छोटा रेगेक्स है: 3
— वैल्यू इंक
@ केविनलाउ-केकेनी ओह अच्छा कैच, धन्यवाद!
— डाउनगेट
1
to${l<"a"?"Lower":"Upper"}Caseसेto${l<"a"?"Low":"Upp"}erCase
— कॉनर ओ'ब्रायन
@ C @O'Bʀɪᴇɴ ओह अच्छा, धन्यवाद!
— डाउनगेट
4
l[`to${l<"a"?"Low":"Upp"}erCase`]()मुझे लगता है कि हमारे पास बुराई की एक नई परिभाषा है।
— 11 अक्टूबर को gcampbell
10

रूबी, 37 33 (30 + -pझंडा) बाइट्स

swapcaseबचाव के लिए! की तरह। -4 बाइट्स @ लियन से।

gsub(/[a-z]/i){$&+$&.swapcase}
— मूल्य स्याही
स्रोत
gsub(/[a-z]/i){$&+$&.swapcase}साथ ही pझंडा 31 बाइट्स है।
— लिन
1
@ मुझे विश्वास है कि सर्वसम्मति को डिफ़ॉल्ट स्क्रिप्ट से आवश्यक अंतर संपादित किया गया था, इसलिए pझंडा (space)-pउर्फ 3 बाइट्स है।
— वैल्यू इंक।
8

सी, 63 60 बाइट्स

f(char*s){for(;*s;s++)isalpha(putchar(*s))&&putchar(32^*s);}

इस तथ्य का उपयोग करता है कि 'a' XOR 32 == 'A', आदि।

तीन बाइट्स ने FryAmTheEggman को धन्यवाद दिया।

— लिन
स्रोत
आप एक बाइट को बचाने के s++लिए अंतिम putchar( &&putchar(32^*s++)) में स्थानांतरित कर सकते हैं
— जियाको गारबेलो
मुझे लगता है कि आप के &&साथ बदल *सकते हैं, नहीं कर सकते?
— aloisdg का कहना है कि मोनिका
1
मुझे पूरा यकीन है कि वे दोनों काम नहीं करते हैं, अगर मुझे लगता है कि कैसे &&व्यवहार कम करने के लिए काम करता है।
— लिन
f(char*s){isalpha(putchar(*s))&&putchar(32^*s);*s&&f(1+s);}पुनरावर्ती?
— l4m2
1
f(char*s){*s&&f(1+s,isalpha(putchar(*s))&&putchar(32^*s));}पुनरावर्ती?
— l4m2
6

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

l_el_eu.+.|

इसका परीक्षण यहां करें।

व्याख्या

l      e# Read input.
_el    e# Duplicate, convert to lower case.
_eu    e# Duplicate, convert to upper case.
.+     e# Concatenate the two characters in matching positions from those two
       e# strings. E.g. "ab!" "AB!" would give ["aA" "bB" "!!"].
       e# For each character from the original string and the corresponding 
.|     e# string from this list, take the set union (which eliminates duplicates
       e# and keeps the order the values appear in from left to right, so that
       e# the original case of each letter comes first).
— मार्टिन एंडर
स्रोत
5

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

l=['a'..'z']
u=['A'..]
(>>= \c->c:maybe""pure(lookup c$zip l u++zip u l))
— लिन
स्रोत
5

चेडर , 118 104 बाइट्स

(s)->s.chars.map((i)->{if String.letters has i.lower{if i<"a"{i+i.lower}else{i+i.upper}}else{i}}).join()

पहला असली चेडर जवाब !!! यह एक बहुत कम जलवायु है जितना मैंने सोचा था कि यह होगा ...?;

रिलीज़ के साथ काम करता है 1.0.0-Beta.9 , गैर-प्रतिस्पर्धात्मक।

जैसा कि आप बता सकते हैं कि मैंने गदर को गोल्फ बनाने के लिए डिज़ाइन नहीं किया है: /

Ungolfed:

(str) -> str.chars.map(
    (i) -> {
        if String.letters has i {
            if i < "a" { // Check char code, meaning it's upper case if true
                i+i.lower
            }
            else {
                i+i.upper
            }
        } else {
            i
        }
    }
).join()

उपयोग:

var doThing = <code here>;
doThing("input...");

अद्यतन: making/१४/१६ मैंने टर्नरीज़ को समाप्त कर दिया है जिससे यह .४ बाइट्स तक नीचे आ गया है

चेडर, 84 बाइट्स

(s)->s.chars.map((i)->String.letters has i.lower?i<"a"?i+i.lower:i+i.upper:i).join()

संस्करण v1.0.0-beta.14 के रूप में काम करता है

— Downgoat
स्रोत
4
वाह! हम लंबे समय से इस पल का इंतजार कर रहे हैं!
— DJMcMayhem
एक या दो विधि नाम परिवर्तन के साथ,
— कैट
@cat o_o समानता
— असमान है
खैर, वे दोनों पर्ल, पर्ल 6, रूबी, पायथन, आदि से प्रभावित हैं, इसलिए यह आश्चर्य की बात नहीं है: पी
— बिल्ली
1
@ केट ओह नो नो नो नो नो नहीं, चेडर अजगर से प्रभावित नहीं था
— डाउनगेट
4

रेटिना, 28 27 21 बाइट्स

वे टैब हैं, स्पेस नहीं।

.
$&  $&
T`lL    p`Ll_`  .

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

सुझाव के लिए सभी को धन्यवाद।

— mbomb007
स्रोत
एसई द्वारा रिक्त स्थान खाए जाते हैं।
— कॉनर ओ'ब्रायन
[A-Za-z]->i`[A-Z]
— डाउनगोट
मार्टिन और मैं बातचीत कर रहे थे, और हम साथ आए: retina.tryitonline.net/…
— FryAmTheEggman
@FryAmTheEggman आह, मैं भूल गया था _। मैं टैब का उपयोग करने जा रहा हूं, इसलिए मैं एक ही बार में सभी परीक्षण मामलों का परीक्षण कर सकता हूं।
— mbomb007
1
लेकिन परीक्षण सूट को गोल्फ नहीं होना चाहिए: पी बस एक नोट छोड़ते हुए कहता है "पहली पंक्ति इसे प्रत्येक पंक्ति पर अलग-अलग चलाती है" आमतौर पर बहुत पर्याप्त होती है। यहाँ, यह आपको टैब वर्णों के पागलपन से बचाएगा।
— FryAmTheEggman
4

सी, 87 80

इनपुट के रूप में एक स्ट्रिंग पास करें f()और आउटपुट STDOUT को लिखा जाए। स्ट्रिंग को संशोधित नहीं किया गया है।

f(char*v){for(;*v;++v)putchar(*v),isalpha(*v)?putchar(*v-32+64*!islower(*v)):0;}
— owacoder
स्रोत
क्या आप इसे ऑनलाइन आज़माने का एक तरीका प्रदान कर सकते हैं?
— aloisdg
@aloisdg प्रयास करें ideone.com
— बिल्ली
4

sed, 30 बाइट्स

29 बाइट्स कोड + 1 बाइट पैरामीटर -r

s/([a-z])|([A-Z])/&\u\1\l\2/g

उपयोग:

echo -e 'bad\nNice\nT e S t\ns E t\n1!1!1st!\nn00b\n(e.g.)\nH3l|@!' |\
sed -r 's/([a-z])|([A-Z])/&\u\1\l\2/g'
— मार्को
स्रोत
4

जे, 31 29 बाइट्स

[:;]<@~."1@,.tolower,.toupper

व्याख्या

[:;]<@~."1@,.tolower,.toupper  Input: s
                      toupper  Convert s to all uppercase
             tolower           Convert s to all lowercase
                    ,.         Join them as columns in a 2d array
   ]                           Identity function, get s
           ,.                  Prepend s as a column to the 2d array
      ~."1@                    Take the unique chars on each row
    <@                         Box them
[:;                            Unbox the list of boxes and join their contents and return
— मील की दूरी पर
स्रोत
4

हास्केल, 121, 101, 85, 82

import Data.Char
g n|isLower n=toUpper n|1<2=toLower n
(>>= \x->x:[g x|isAlpha x])
— Zylviij
स्रोत
3
गार्ड के द्वारा if-then-अन्यथा की जगह लेने से, आप 15 बाइट्स या तो बचा सकते हैं। और 5 बाइट्स से अधिक के isLowerसाथ निर्माण से कम है elem।
— अर्जन
1
>>=है concatMap(या concat.map) फ़्लिप तर्क के साथ: f n = n >>= (\x->if isAlpha x then[x,r x]else[x])। आप pointfree जाने के लिए और समारोह नाम हटा दें और की परिभाषा बदल सकते हैं fके साथ (>>= \x->if isAlpha x then[x,r x]else[x])।
— nimi
1
इसके बजाय otherwiseआप किसी भी अभिव्यक्ति का उपयोग कर सकते हैं जो इसका मूल्यांकन करता है True, जैसे 1<2। आप if .. then .. elseएक सूची समझ के साथ बदल सकते हैं \x->[x]++[g x|isAlpha x]:। ओह, और वहाँ एक बग है: दूसरे toUpperमें gएक होना चाहिए toLower।
— नीम जूल
1
ओह, एक और: [x]++है x:।
— nimi
4

पर्ल, 36 बाइट्स (35 + -nध्वज)

s/[a-z]/$&.(ord$&<97?lc$&:uc$&)/ige

( -pटैग की जरूरत है)

(-2 बाइट्स @ डॉम हस्टिंग से साभार)

संक्षिप्त विवरण:
ordएक चार्ट का संख्यात्मक मान लौटाता है। ord(any lower case) >= 97, और ord(any upper case) <= 90)।

साथ दौड़ो : 

perl -pe 's/[a-z]/$&.(ord$&<97?lc$&:uc$&)/ige'
— बापू
स्रोत
आपको अभी भी उपयोग करने की आवश्यकता है /iया आपका regexp अक्षरों के बीच कई कोडपॉइंट से मेल खाएगा।
— ओलेग वी। वोल्कोव
@ ओलेगवी. वोलोकोव ओह सही, धन्यवाद, उत्तर संपादित।
— दादा
अपनी विधि का उपयोग करते हुए इसे एक और बाइट प्राप्त करें
— Xcali
4

रूबी, 31 + 1 = 32 30 + 1 = 31 बाइट्स

-pझंडे के साथ , भागो

gsub(/(?<=(.))/){$1.swapcase!}

इस तथ्य का लाभ उठाता है कि swapcase!कोई nilभी चीज वापस आ जाएगी लेकिन एक ASCII पत्र, जो gsubब्लॉक से बाहर लौटने पर एक रिक्त स्ट्रिंग में बदल जाता है। @ जोर्डन ने पिछले चरित्र को लुक-बैक में कैद करके एक बाइट को बचाया।

— histocrat
स्रोत
के साथ मिलान //और फिर उपयोग $`[-1]करना चतुर है।
— जॉर्डन
1
मैं देख रेख के साथ छह बाइट्स दाढ़ी बनाने में कामयाब रहा gsub(/(?<=(.))/){$1.swapcase!}:। एक ही मूल अवधारणा, हालांकि, इसलिए इसका उपयोग करने के लिए स्वतंत्र महसूस करें।
— जॉर्डन
ठंडा! वह एक बाइट मुझे छोटी लगती है।
— 15 अक्टूबर को histocrat
एर, हाँ, एक बाइट। मुझे लगता है कि मेरे पास गलती से गिने जाने वाले परीक्षण के लिए कुछ अतिरिक्त कोड थे।
— जॉर्डन
के स्व-संशोधित संस्करण का उपयोग करने की कोई आवश्यकता नहीं है .swapcase!। (मेरा मतलब है, हटाओ !।)
— manatwork
4

आर, 191 187 168 156 98 99 बाइट्स

फ्रू ग्यूसेप और मिकी के सुधार के कारण 99 बाइट्स ।

paste0(x<-unlist(strsplit(readline(),"")),gsub("[^A-Za-z]","",chartr("a-zA-Z","A-Za-z",x)),collapse="")
— rturnbull
स्रोत
98 बाइट्स - शायद अगले साल कुछ समय बाद, हम इस का एक और गोल्फ पा सकते हैं, हाहाहा।
— ग्यूसेप
1
मुझे बुरे नए के वाहक होने से नफरत है, लेकिन यह रिक्त स्थान के साथ परीक्षण के मामलों में विफल रहता है। readline()इस्तेमाल किया जा सकता है, लेकिन यह
— मिकी टीटी
@ मिक्की धन्यवाद, अब तय हुआ।
— rturnbull
@ मिक्की scanउद्धरणों में लिपटे हुए इनपुट के साथ काम करेगा (जैसा कि अक्सर अन्य भाषाओं में कमांड-लाइन तर्कों के लिए होता है)
— Giuseppe
@Giuseppe क्षमा करें मुझे ऐसा महसूस नहीं हुआ। मैंने सोचा था कि यह स्वचालित रूप से व्हाट्सएप पर विभाजित हो जाता है जब तक आप एक गैर व्हाट्सएप चरित्र निर्दिष्ट नहीं करते हैं। क्षमा करें rturnbull
— मिकी
3

05AB1E , 7 बाइट्स

कोड:

vyyš«Ù?

स्पष्टीकरण:

v       # For each in input.
 yyš    # Push y and y swapcased.
    «Ù  # Concatentate and uniquify.
      ? # Print without a newline.

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

— अदनान
स्रोत
हो सकता है कि आप दुभाषिया को एक लिंक प्रदान कर सकें?
— निकेल
2
@nicael यह जुड़ा है ... यह सही वहाँ पर है।
— mbomb007
तो कोई ऑनलाइन दुभाषिया नहीं? :(
— निकेल
@nicael फिर इसे डाउनलोड करें, और इसे चलाएं। वहाँ एक ऑनलाइन दुभाषिया होने की जरूरत नहीं है , सिर्फ एक दुभाषिया है।
— mbomb007
1
@nicael हाँ, अभी तक कोई ऑनलाइन दुभाषिया उपलब्ध नहीं है :(। ऑफ़लाइन संस्करण को हालांकि काम करना चाहिए।
— Adnan
3

MATL, 11 9 बाइट्स

tYov"@uv!

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

व्याख्या

        % Implicitly grab input as string
t       % Duplicate the input
Yo      % Swap case of all characters
v       % Vertically concatenate the original and swap-cased versions
"       % For each column (letter in the original)
  @u    % Compute the unique values (without sorting)
  v!    % Vertically concatenate with the existing output and transpose
        % Implicit end of for loop and implicit display
— Suever
स्रोत
3

पर्ल, 28 22 21 बाइट्स (20 + -pझंडा)

s/[a-z]/$&.$&^$"/ige
— ओलेग वी। वोल्कोव
स्रोत
मुझे लगता है कि आप $"इसके बजाय का उपयोग करके एक बाइट बचा सकते हैं ' ', लेकिन मैंने परीक्षण नहीं किया है।
— msh210
@ msh210, अच्छा! मैं डिफ़ॉल्ट स्ट्रिंग्स के लिए पर्लवार की जांच करना कैसे भूल सकता हूं? धन्यवाद!
— ओलेग वी। वोल्कोव
3

स्टैक्स , 7 6 बाइट्स

एक बाइट के लिए @recursive को धन्यवाद बचा लिया!

┤§ÆP♦■

भागो और इसे staxlang.xyz पर डीबग करें! (लिंक अनपैक्ड संस्करण के लिए है)

अनपैक्ड (7 बाइट्स):

c:~\{um

स्पष्टीकरण:

c:~\{um
c          Copy the top element of the stack (the input, in this case).
 :~        Switch case of each letter in the copy.
   \       Zip. This produces an array of two-character strings.
    { m    Map a block over this array of two-character strings.
     u       Get all unique elements.
           Implicit concatenate and print.
— खुल्द्रेसथ न’बैरी
स्रोत
एक कोशिश देने के लिए धन्यवाद। एक आसान सुधार जो आप कर सकते हैं वह है uइसके बजाय उपयोग करना :g। यह एक सरणी में सभी अद्वितीय तत्व प्राप्त करेगा, जो इस मामले में वास्तव में आप चाहते हैं। इसके अलावा, यह अच्छी तरह से गोल्फ दिखता है।
— पुनरावर्ती
@recursive धन्यवाद! उस एक के बारे में भूल गए: / जल्द ही संपादित करेंगे।
— खुल्द्रेसथ न'बर्या
के लिए काम नहीं करता है 123। आपको सभी इनपुट के लिए प्रारूप बदलने की आवश्यकता हो सकती है (जैसे कि उन्हें उद्धृत करें)। लिंक भी टूट गया है। आपको m=11साथ बदलने की जरूरत है m=2। एक staxlang.xyz पर PPCG पोस्ट जनरेट करने वाला बटन है, ताकि आप उस एक का उपयोग करना चाहें।
— वीजुन झोउ
@ WeijunZhou धन्यवाद, निश्चित!
— खुल्द्रेसथ ना'बरिया
2

पायथन, 59 बाइट्स

lambda s:''.join((x,x+x.swapcase())[x.isalpha()]for x in s)

गैर-वर्णनात्मक वर्णों को दोहराने के लिए संपादित किया गया

— atlasologist
स्रोत
2

PHP 4.1, 57 बाइट्स

यह कोड डिफ़ॉल्ट कॉन्फ़िगरेशन का उपयोग करके एक वेब सर्वर (उदाहरण के लिए अपाचे) के माध्यम से पहुंच मानता है।

आप कुंजी भेजकर स्ट्रिंग पारित कर सकते हैं Sकिसी भी तरह से ( POST, GET, COOKIE, SESSION...)।

<?for($i=0;$c=$S[$i++];)echo$c,ctype_alpha($c)?$c^' ':'';
— इस्माइल मिगुएल
स्रोत
2

कॉमन लिस्प (लिस्पवर्क्स), 262 बाइट्स

(defun f(s)(let((b""))(dotimes(i(length s))(if(lower-case-p(elt s i))(progn #1=(setf b(concatenate 'string b(string #2=(elt s i))))(setf b(concatenate 'string b(string(char-upcase #2#)))))(progn #1#(setf b(concatenate 'string b(string(char-downcase #2#)))))))b))

ungolfed:

(defun f (s)
  (let ((b ""))
    (dotimes (i (length s))
      (if (lower-case-p (elt s i))
          (progn
           #1=(setf b (concatenate 'string b (string #2=(elt s i))))
           (setf b (concatenate 'string b (string (char-upcase #2#)))))
        (progn
          #1#
          (setf b (concatenate 'string b (string (char-downcase #2#)))))))
    b))

उपयोग:

CL-USER 1 > (f "abc")
"aAbBcC"

CL-USER 2 > (f "bad")
"bBaAdD"
— sadfaf
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.