केस के साथ और भी मज़ेदार- (बहुत) -सेंसिटिव स्ट्रिंग्स

28

इस चुनौती से प्रेरित (या, विशेष रूप से, इसे गलत तरीके से फैलाकर), मैं निम्नलिखित चुनौती लेकर आया हूं:

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

नमस्ते दुनिया!

ध्यान दें कि अपरकेस W(पहला अपरकेस अक्षर) को Hअंतिम (अंतिम) से बदल दिया गया था । एक ही लोअरकेस अक्षरों के लिए जाता है: 'd' (पहला) के साथ स्वैप किया जाता है e(अंतिम), l(दूसरा) को l(पेन-अल्टिमेट) से बदल दिया जाता है ... सभी गैर-अक्षर वर्णों को छोड़ दिया जाता है।

इनपुट

  • इनपुट 32-126 की सीमा में केवल ASCII वर्णों के साथ एक स्ट्रिंग है।
  • इनपुट कम से कम 1 वर्ण लंबा होने की गारंटी है, और आपकी भाषा की सीमा से अधिक नहीं होगी।

उत्पादन

  • वर्णों के साथ उसी स्ट्रिंग को स्वैप किया गया, जैसा कि वर्णित है।

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

  • मानक खामियों को मना किया जाता है
  • उत्तर एक पूर्ण कार्यक्रम या एक फ़ंक्शन होना चाहिए, न कि एक स्निपेट या एक REPL- प्रवेश।
  • कोड-गोल्फ , बाइट्स जीत में सबसे छोटा जवाब।

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

A
A

Ok
Ok

OK
KO

Hello, World!
Wdlro, Holle!

0123456789
0123456789

The quick brown Fox jumps over the lazy doge
Feg odyza lehtr Tev ospmu jxon wor bkci uqeh

odd
ddo

racecar
racecar

EtOn Em OsN R AaToNsIsIhT!!1!
ThIs Is NoT A RaNsOmEnOtE!!1!
code-golf  string 
— steenbergh
स्रोत
आप एक 2-चार टेस्टकेस को शामिल करना चाह सकते हैं, मेरा मूल समाधान उस पर पहली बार में विफल रहा। (बदलकर किसी कीमत पर फिक्स्ड .+करने के लिए .*)
— ETHproductions
"आलसी डॉग" ने मुझे यह याद दिलाया: youtube.com/watch?v=W-d6uUSY9hk
— FinW

जवाबों:

5

MATL , 14 बाइट्स

2:"t@Y2myy)Pw(

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

व्याख्या

        % Impicitly grab input as a string
2:      % Push the array [1, 2] to the stack
"       % For each value in this array
  t     % Duplicate the top element of the stack (S)
  @     % Get the current loop index
  Y2    % Load the predefined literal 1Y2 ('ABC...Z') on the first loop
        % and the predefined literal 2Y2 ('abc...z') on the second loop (M)
  m     % Create a logical array the length of S that is TRUE when a character is in the
        % array M and FALSE otherwise (B)
  yy    % Make a copy of both S and B
  )     % Grab just the letters of S that were in M using B as an index
  P     % Reverse this array
  w     % Flip the top two stack elements
  (     % Assign them back into the string
        % Implicit end of for loop and implicit display
— Suever
स्रोत
1
अच्छा काम! मेरे पास 2:"tttXk>f)5MP(Yo17 बाइट्स के लिए
— लुइस मेन्डो
11

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

रेटिना में एक स्ट्रिंग को उल्टा करने का एक सीधा तरीका नहीं है, लेकिन हम इसे छंटाई के चरण का उपयोग करके कर सकते हैं:

O^#`[a-z]
O^#`[A-Z]

सॉर्ट ( O), उन्हें संख्याओं के रूप में पढ़ना ( #), और फिर ^दिए गए रेगेक्स (पहली पंक्ति के निचले अक्षर, और दूसरे के लिए बड़े अक्षर) से मेल खाते हुए सभी तारों के क्रम ( ) को उल्टा करें ।

यह काम करता है क्योंकि जब हम संख्यात्मक वर्णों के बिना स्ट्रिंग को पढ़ने की कोशिश करते हैं, क्योंकि वे संख्याओं का इलाज किया जाता है 0, इसलिए सभी वर्णों को छांटने के लिए समान मूल्य होता है। चूंकि छंटाई स्थिर है, उन्हें उसी क्रम में छोड़ दिया गया है, और उन्हें उलट देने से मूल स्ट्रिंग उलट हो जाती है।

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

— सिंह
स्रोत
10

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

कोड + -pध्वज के 44 बाइट्स ।

for$c(u,l){@T=/\p{L$c}/g;s/\p{L$c}/pop@T/ge}

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

यूनिकोड अक्षर \p{Lu}और कक्षाएं \p{Ll}क्रमशः अपरकेस और लोअरकेस अक्षर।
तो /\p{L$c}/सभी ऊपरी (या निचले) केस पत्रों की सूची वापस कर देंगे (और इसे अंदर स्टोर करेंगे @T)।
और फिर, रेगेक्स इसे हटाते समय s/\p{$c}/pop@T/geप्रत्येक अक्षर (ऊपरी, फिर निचले मामले) पत्र को अंतिम अक्षर @Tसे बदल देगा @T।

— बापू
स्रोत
7

जावास्क्रिप्ट (ईएस 6), 74 73 71 70 बाइट्स

f=
s=>(g=r=>s=s.replace(r,_=>a.pop(),a=s.match(r)))(/[A-Z]/g,g(/[a-z]/g))
<input oninput=o.textContent=f(this.value)><pre id=o>
स्निपेट का विस्तार करें

संपादित करें: @Arnauld के लिए 1 बाइट धन्यवाद सहेजा गया।

— नील
स्रोत
4
मुझे पता था कि एक बेहतर तरीका था ...
— ETHproductions
5

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

s=>(F=(r,s)=>s.replace(r,([x],a,y)=>y+F(r,a)+x))(/[a-z](.*)([a-z])/,F(/[A-Z](.*)([A-Z])/,s))

वहाँ regexes के बीच समानता का लाभ लेने के लिए एक रास्ता मिल गया है ...

टेस्ट स्निपेट

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

— ETHproductions
स्रोत
क्या यह मान लिया जाता है कि फ़ंक्शन को वैरिएबल में असाइन किया गया है f? नहीं, कि बाइट गिनती में हो?
— स्टैनबर्ग
@steenbergh फंक्शन गुमनाम है, इसे आप जो चाहें
— कह
1
@steenbergh नहींं, यह एक अनाम फ़ंक्शन है जो एक और फ़ंक्शन बनाता है और Fफिर इसे दो बार पुन: कॉल करता है। बाहरी फ़ंक्शन वास्तव में किसी भी बिंदु पर खुद को कॉल नहीं करता है।
— ETHproductions
आप .*रेगीज़ में कोष्ठक का उपयोग क्यों करते हैं ?
— ल्यूक
@ उन पात्रों ( aमें ([x],a,y)=>) पर कब्जा करने के लिए
— ETHproductions
4

पर्ल 6 , 75 69 बाइट्स

{my @a=.comb;@(grep $_,@a).&{@$_=[R,] $_} for /<:Lu>/,/<:Ll>/;[~] @a}

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

  1. my @a=.comb;
    स्ट्रिंग को वर्णों में विभाजित करें, और उन्हें एक सरणी में संग्रहीत करें।

  2. for /<:Lu>/,/<:Ll>/
    ऊपरी और निचले मामलों के पत्रों से मेल खाते दो रेगीज़ के लिए, क्रमशः ...

    • @(grep $_,@a)
      Regex से मेल खाते सभी सरणी प्रविष्टियों का एक टुकड़ा प्राप्त करें।

    • .&{@$_=[R,] $_}
      खुद को स्लाइस के रिवर्स असाइन करें।

  3. [~] @a
    एक स्ट्रिंग को फिर से बनाने के लिए संशोधित सरणी को फिर से व्यवस्थित करें, और इसे वापस लौटाएं।

@ दादा के समाधान से, चरित्र श्रेणियों के बजाय यूनिकोड कक्षाओं का उपयोग करने के विचार को चुराकर 6 बाइट्स।

— SMLS
स्रोत
3

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

nŒlT,Ṛ$yJịŒsµ⁺

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

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

nŒlT,Ṛ$yJịŒsµ⁺  Main link. Argument: s (string)

 Œl             Convert to lowercase.
n               Test for inequality.
   T            Truth; yield all indices of 1's.
    ,Ṛ$         Pair with its reverse. Yields [A, B] (pair of lists).
        J       Indices; yield I := [1, ..., len(s)].
       y        Translate; replace the integers of I that occur in A with the
                corresponding integers in B.
          Œs    Swapcase; yield s with swapped case.
         ị      Use the translated index list to index into s with swapped case.
            µ   Combine all links to the left into a chain.
             ⁺   Duplicate the chain, executing it twice.
— डेनिस
स्रोत
— Gizmo
@Gizmo जेली एक कोडपेज का उपयोग करता है । देखें इस मेटा पोस्ट अधिक जानकारी के लिए।
— Suever
@Suever ओह यह साफ-सुथरा है, आज कुछ सीखा ^। ^
— Gizmo
3

बैश + यूनिक्स उपयोगिताओं, 122 121 बाइट्स

f()(p=[^$1*
v="\)\([$1\)\("
for((n=99;n;n--)){
q="$q;s/^\($p$v.*$v$p\)$/\1\4\3\2\5/"
p=[^$1*[$1$p
}
sed $q)
f a-z]|f A-Z]

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

वास्तव में बहुत कम नहीं; हो सकता है कि कोई और इसे आगे बढ़ा सकता है।

स्टड पर इनपुट, स्टडआउट पर आउटपुट।

यह 200 से कम वर्णों के इनपुट पर सही ढंग से काम करेगा।

(वास्तव में यह किसी भी स्ट्रिंग को 200 से कम लोअर-केस लेटर्स और 200 से कम अपर-केस लेटर्स के साथ हैंडल करता है।)

यदि आप कोड को 99 से 102 तक बढ़ाते हैं (एक अतिरिक्त बाइट की कीमत पर), तो यह 205 वर्णों तक तार को संभाल लेगा।

हालाँकि, आप 102 से आगे कोड में 99 नहीं बढ़ा सकते हैं क्योंकि आप फिर सेड की अधिकतम तर्क लंबाई से अधिक हो जाएंगे।

यहां किसी विशेष इनपुट आकार सीमा के बिना एक संस्करण है, लेकिन गिनती थोड़ी लंबी है, 137 बाइट्स। (यह लंबा संस्करण t नामक एक सहायक फ़ाइल को लिखता है।)

f()(p=[^$1*
v="\)\([$1\)\("
for((n=`wc -c<t`;n;n--)){
sed -i "s/^\($p$v.*$v$p\)$/\1\4\3\2\5/" t
p=[^$1*[$1$p
})
cat>t
f a-z]
f A-Z]
cat t

टेस्ट रन:

for x in A Ok OK 'Hello, World!' 0123456789 'The quick brown Fox jumps over the lazy doge' odd racecar 'EtOn Em OsN R AaToNsIsIhT!!1!'
  do
    echo "$x"
    ./swapping3 <<<"$x"
    echo
  done

A
A

Ok
Ok

OK
KO

Hello, World!
Wdlro, Holle!

0123456789
0123456789

The quick brown Fox jumps over the lazy doge
Feg odyza lehtr Tev ospmu jxon wor bkci uqeh

odd
ddo

racecar
racecar

EtOn Em OsN R AaToNsIsIhT!!1!
ThIs Is NoT A RaNsOmEnOtE!!1!
— मिशेल स्पेक्टर
स्रोत
दिलचस्प है कि यह टीआईओ में विफल रहता है। ☹ मई sedआपके सिस्टम पर स्थापित कार्यान्वयन पर निर्भर करता है, लेकिन जीएनयू में sedआप -rविकल्प जोड़ सकते हैं और \सभी कोष्ठकों के भागने को हटा सकते हैं ।
— मैनटवर्क
2

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

s=input();u=str.isupper
exec"r='';i=0\nfor c in s:r+=c[u(c):]or filter(u,s)[~i];i+=u(c)\ns=r.swapcase();"*2
print s

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

— डेनिस
स्रोत
क्या आप \ n को बदल सकते हैं?
— टिम
दुर्भाग्यवश नहीं। तर्क execको सामान्य पायथन कोड के रूप में पार्स किया जाता है, इसलिए लूप की अपनी लाइन पर होना चाहिए।
— डेनिस
2

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

s->new String(new Error(){char[]o=s.toCharArray();char c;int b;{while(b++<2)for(int l=0,r=o.length;l<r;l++){for(--r;r>l&&f(r);r--);for(;l<r&&f(l);l++);if(l<r){o[l]=o[r];o[r]=c;}}}boolean f(int i){c=o[i];return b>1?!Character.isUpperCase(c):!Character.isLowerCase(c);}}.o)

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

— DmitrySamoylenko
स्रोत
आप इसे मेमने में बनाकर कुछ बाइट्स बचा सकते हैं। s->new String...
— NonlinearFruit
1
@NonlinearFruit आपका धन्यवाद! 294 -> 272, एक निश्चित गलती भी हुई जब आर एक एल को पुन: उपयोग के बिना उपयोग किया गया था।
— दिमित्रीसमोयेलेंको
PPCG में आपका स्वागत है! कुछ चीजें जो आप अभी भी गोल्फ कर सकते हैं: char[]o=s.toCharArray();char c;int b;से char o[]=s.toCharArray(),c,b;; और दोनों &&को &'; और c=o[i];return b>1?!Character.isUpperCase(c):!Character.isLowerCase(c);करने के लिए c=o[i];Character x=c;return b>1?!x.isUpperCase(c):!x.isLowerCase(c);( कुल में 259 बाइट्स )। और मैं शायद इसे और अधिक गोल्फ के लिए कुछ चीजें याद किया। इसके अलावा, यदि आपने इसे अभी तक नहीं देखा है, तो जावा में गोल्फिंग के लिए युक्तियाँ पढ़ना दिलचस्प हो सकता है।
— केविन क्रूज़सेन
1

आर , 107 बाइट्स

u=utf8ToInt(scan(,''));for(i in c(65,97)){l=which(u%in%i:(i+25));u[l]=u[rev(l)]};cat(intToUtf8(u,T),sep="")

लिंक्ड चैलेंज के लिए मेरी प्रतिक्रिया से अनुकूलित। यह बस स्वैपिंग जोड़े की तुलना में काफी आसान है। मुझे आश्चर्य है कि अगर मैं कुछ गोल्फों के साथ उप 100 प्राप्त कर सकता हूं ...

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

— Sumner18
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.