वर्णमाला स्वैप करें

48

इस चुनौती में, आप वर्णमाला को "उलट" करेंगे या उसके a-zसाथ स्वैप करेंगे z-a। इसे आमतौर पर अटबाश साइबरफोर के रूप में जाना जाता है ।

क्योंकि यह परिवर्तन आउटपुट को कुछ विदेशी भाषा की तरह बनाता है, इसलिए आपका कोड यथासंभव छोटा होना चाहिए।

उदाहरण

abcdefghijklmnopqrstuvwxyz
zyxwvutsrqponmlkjihgfedcba

Programming Puzzles & Code Golf
Kiltiznnrmt Kfaaovh & Xlwv Tlou

Hello, World!
Svool, Dliow!

विशिष्टता

  • इनपुट में कई लाइनें हो सकती हैं, और ASCII- केवल होगा
  • आउटपुट में कोई अतिरिक्त व्हाट्सएप नहीं जोड़ा जाना चाहिए
  • केस को संरक्षित किया जाना चाहिए

लीडरबोर्ड

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

यह कोड-गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा कोड है

code-golf  string 
— Downgoat
स्रोत
24
औचित्य के लिए +1 "क्योंकि यह परिवर्तन आउटपुट को कुछ विदेशी भाषा की तरह बनाता है, आपके कोड को यथासंभव छोटा होना होगा।"
— बिल्ली
11
कुछ सामान्य ज्ञान: यह Atbash है , जो बाइबिल के रूप में पुराने रूप में जाना जाता है।
— जैकब
6
"क्योंकि यह परिवर्तन आउटपुट को कुछ विदेशी भाषा की तरह बनाता है, आपके कोड को यथासंभव छोटा होना चाहिए।" इसके पीछे क्या वजह है?? क्योंकि आपका विवरण उतने ही प्रश्नचिन्ह खड़ा करता है, जितना कि यह किसी विदेशी भाषा में लिखा गया हो, इस प्रश्न का उत्तर समझदार प्राकृतिक भाषा में होना चाहिए और कुछ शब्दशः की सराहना की जाती है।
— बार्ट
Kiltiznnrmt Kfaaovh & Xlwv Tlou "प्रोग्रामिंग ट्राइबल्स एंड कोड बॉलिंग" के लिए नई साइट होनी चाहिए ...
— ऑग आउट द आउटफ्लर
आप अतिरिक्त व्हाट्सएप की अनुमति क्यों नहीं देते? यह कुछ भाषाओं में असंभव बना देता है जिसमें हमेशा एक नई अनुगामी होती है। मैं इसे चुनौती के लिए कुछ भी जोड़कर नहीं देख सकता।
— फल फूल

जवाबों:

11

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

XXzG)rG1

@xnor ने @ FryAmTheEggman के Pyth उत्तर पर इस सरल दृष्टिकोण का सुझाव दिया, फिर मैंने इसका Pyth में अनुवाद किया।

यह Xकेवल दो तर्कों को दिए जाने पर (अनुवाद) के आसान व्यवहार का उपयोग करता है: यह दूसरे तर्क से उलट दूसरे तर्क में अनुवाद करता है। हम इसे पहले लोअरकेस वर्णमाला ( G) के साथ करते हैं , और फिर अपरकेस के साथ G।

— lirtosiast
स्रोत
16

सी, 59 बाइट्स

सी को फिर से लाने के लिए खेद है, लेकिन मैं केवल सी फ़ंक्शन को देखने के लिए थोड़ा निराश था । मैं इस धारणा के तहत था कि ओपी एक उपयोगी उत्पाद की तलाश में था।

main(c){while(~(c=getchar()))putchar(isalpha(c)?c+4^31:c);}

एक सरल के साथ Ubuntu 14.04 पर संकलित:

cc swalpha.c

परिणामी निष्पादन योग्य स्टड से किसी भी संख्या को पढ़ता है, और परिणाम को स्टडआउट लिखता है।

XOR चाल के लिए अन्य पोस्टर के इतने सारे धन्यवाद।

— रूड हेलडरमैन
स्रोत
11

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

मैं GamrCorps गोल्फ को अपने CJam समाधान में मदद करना चाहता था, लेकिन परिणाम इतना अलग हो गया कि मैंने एक अलग जवाब देने का फैसला किया।

q'[,_el^_W%32f^er

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

व्याख्या

q     e# Read all input.
'[,   e# Get a character range from the null byte up to and including "Z".
_el   e# Duplicate and convert to lowercase.
^     e# Symmetric set difference. Due to the lowercase operation only letters will not
      e# appear in both sets, and so we get a string with all uppercase letters followed
      e# by all lowercase letters, i.e "ABC...XYZabc...xyz".
_W%   e# Duplicate and reverse. Gives: "zyx...cbaZYX...CBA".
32f^  e# Take each character XOR 32 which swaps the case, so now we have:
      e#                               "ZYX...CBAzyx...cba"
er    e# Transliterate: substitute each character in the first string with the correspoding
      e# character in the second string.
— मार्टिन एंडर
स्रोत
4
खैर, मुझे खुशी है कि आप मदद करने की कोशिश कर रहे थे! यही वह समाधान है जिसे मैं बनाने की कोशिश कर रहा था, मैं अभी XOR का पता नहीं लगा सका। अच्छी नौकरी!
— GamrCorps
1
एसई का सिंटैक्स हाइलाइटिंग हैट एसोलैंग्स।
— साइओस
@ कैओस वे शायद समय नहीं है; इस साइट पर कितनी भाषाएं हैं। उस ने कहा, सीजाम शायद सबसे आसान लोगों में से एक है, क्योंकि यह आत्म-संशोधन नहीं है और इसमें एक बहुत ही स्पष्ट संरचना है। मैं उन्हें /// जैसी स्व-संशोधित भाषा में सिंटैक्स-हाइलाइटिंग जोड़ने की कोशिश करना चाहूंगा।
— फल तोड़ना
@ Challenger5 afaik, सिंटैक्स हाइलाइटिंग केवल Google के प्रीटाइफ़ का उपयोग करता है, विभिन्न एसोलैंग्स के लिए समर्थन वहां जोड़ना होगा।
— मार्टिन एंडर
11

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

x=>x.replace(/[A-Z]/gi,c=>String.fromCharCode(c.charCodeAt()+4^31))

मेरे जाप उत्तर के रूप में उसी रणनीति का उपयोग करता है :

x=>x.replace(/[A-Z]/gi,C=>   // Replace each letter C with
 String.fromCharCode(        //  the character with char code
  C.charCodeAt()+4^31))      //   the char code of C, plus 4, with the last 5 bits flipped.

अपने अविश्वसनीय रूप से लंबे संपत्ति के नाम, जेएस ...

— ETHproductions
स्रोत
1
जेएस की असाधारण लंबी संपत्ति के नामों का उल्लेख करने के लिए +1। मेरा पसंदीदा अभी भी बदनाम हैdocument.getElementById
— Cyoce
2
@Cyoce कोशिश करो document.getElementsByClassNameया, फ़ायरफ़ॉक्स और क्रोम पर,document.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC
— इस्माईल मिगुएल
ऐसा लगता है कि केवल 66 बाइट्स 67 नहीं
— डाउनगोट
@ Do @ आप इसके बारे में सही हैं, धन्यवाद!
— ETHproductions
ऐसा लगता है कि आप गोल्फ कोड के अंत में एक समापन कोष्ठक को याद कर रहे हैं।
— स्टारबिम्रेनबोलाब्स
10

रेटिना , 17 14 13 बाइट्स

कोड:

\T`w`_dZ-Az-a

स्पष्टीकरण:

\             # This suppresses the trailing linefeed
 T            # Switches to transliterate mode
  `w          # w is short for _0-9A-Za-z
    `_d       # d is short for 0-9
       Z-Az-a # Z-Az-a

यह कुछ जादुई सामान करता है और कार्य को पूरा करता है।

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

— अदनान
स्रोत
2
भाग्यशाली है कि मैंने हाल ही में जोड़ा \। आप बदकिस्मत हैं कि मुझे अक्षरों के लिए वर्ण वर्गों को जोड़ने के लिए चारों ओर नहीं मिला और चरित्र वर्ग अभी तक उलट दिए।
— मार्टिन एंडर
@ मार्टिनबटनर वास्तव में बहुत भाग्यशाली हैं, जिन्होंने मेरे जवाब को लगभग अमान्य कर दिया :)
— अदनान
संदर्भ के लिए, रेटिना 0.7.2 के रूप में आप कर सकते हैं \T`lL`RlRL।
— मार्टिन एंडर
9

अजगर, १० ९

uXGr;H)2z

की नई सुविधा के साथ एक बाइट बचाने के लिए Jakube के लिए धन्यवाद ;!

परीक्षण सूट

एक त्वरित व्याख्या: संख्या 0 और 1. पर इनपुट के साथ शुरू करना कम करें। किया जाने वाला ऑपरेशन निचले केस के वर्णमाला का अनुवाद r...0या तो होता है या r...1जो क्रमशः अजगर से निचले और ऊपरी कार्य होते हैं, इसे लागू किया जाता है, और फिर उलट दिया जाता है।

— FryAmTheEggman
स्रोत
1
एक नई सुविधा के कारण 9 बाइट्स (एक दिन पुरानी भी नहीं):uXGr;H)2z
— जेक्यूब
5
क्या आप एक स्पष्टीकरण जोड़ सकते हैं?
— तन्माथ
1
क्या आप Xवर्णमाला के साथ और फिर पूंजीकृत वर्णमाला के साथ उपयोग नहीं कर सकते हैं ?
— xnor
1
@xnor XXzG)rG1? वह काम करने लगता है।
— lirtosiast
या, शायद लोअरकेस पर एक्स और अपरकेस अक्षर संक्षिप्त किए गए, फिर स्वैप केस? यह शायद लंबा है, वास्तव में।
— 21
6

जूलिया, 74 61 47 बाइट्स

s->replace(s,r"[a-z]"i,t->Char(31$Int(t[1])-4))

यह एक लंबोतरा फ़ंक्शन है जो एक स्ट्रिंग को स्वीकार करता है और एक स्ट्रिंग लौटाता है। इसे कॉल करने के लिए, इसे किसी वैरिएबल पर असाइन करें।

हम एक नियमित अभिव्यक्ति का उपयोग करके प्रत्येक अक्षर से मेल खाते हैं और प्रत्येक पत्र को ASCII वर्ण के साथ 31 XOR ASCII कोड के अक्षर, माइनस 4 के लिए बदलते हैं।

— एलेक्स ए।
स्रोत
वाह, यह बहुत सुंदर है। मुझे इस बात के लिए एक चेतावनी चेतावनी मिलती है $ताकि आप उसे अपडेट करना चाहें ⊻। पता नहीं था कि आप किसी फ़ंक्शन का उपयोग कर सकते हैं replace।
— निकुज़
5

सी, 150 129 बाइट्स

void rev(char*s){int i,t;for(i=0;i<strlen(s);i++){t=s[i]+25;t=t<116?180-t:244-t;isalpha(s[i])?printf("%c",t):printf("%c",s[i]);}}

यह फ़ंक्शन सिर्फ char को int में कनवर्ट करता है और प्रिंटिंग से पहले int को उपयुक्त ऑफसेट जोड़ता है। मुझे पता है कि यह सबसे छोटा नहीं है, लेकिन मैंने सी कार्यान्वयन नहीं देखा।

उदाहरण उपयोग

#include<stdio.h>
#include<string.h>
#include<ctype.h>

void rev(char*s){int i,temp;for(i=0;i<strlen(s);i++){temp=s[i]+25;temp=temp<116?180-temp:244-temp;isalpha(s[i])?printf("%c",temp):printf("%c",s[i]);}}


int main(){
   char *s = "hello, there";
   rev(s);
   return 0;
}

अद्यतन: एक चर नाम छोटा।

— Danwakeem
स्रोत
प्रोग्रामिंग पहेलियाँ और कोड गोल्फ स्टैक एक्सचेंज में आपका स्वागत है! यह एक बहुत अच्छा दृष्टिकोण है। यह tempवास्तव में एक वर्ण लंबे (सभी सहित ) बनाकर अधिक गोल्फ हो सकता है ।
— wizzwizz4
आह आप सही कह रहे हैं! मैं इसे एक बार फिर प्राप्त करूंगा
— डैनवाकेम
1
क्या आपको लगता है कि आप मेरी चुनौती पर जा सकते हैं? अपने चेयर का विश्लेषण करें
— wizzwizz4
1
हाँ यह हेडर के बिना काम करेगा आप बस एक संकलक चेतावनी प्राप्त करें @ edc65 मुझे लगा क्योंकि यह संकलन करता है और चलाता है इसे धोखा नहीं माना जाएगा लेकिन वास्तविक दुनिया में उपयोग में आपको हमेशा हेडर शामिल करना चाहिए।
— दानवेकेम
1
107 बाइट्स:i,t;r(char*s){for(;i<strlen(s);i++){t=s[i]+25;t=t<116?180-t:244-t;isalpha(s[i])?putchar(t):putchar(s[i]);}}
— स्पिकैट्रिक्स
5

जाप, 23 22 बाइट्स

Ur"[A-Za-z]"_c +4^31 d

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

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

Ur"[A-Za-z]"_  // Take the input and replace each letter with:
 c +4          //  Take its char code and add 4. This results in
               //  the string      "ABC...XYZabc...xyz"
               //  becoming        "EFG...\]^efg...|}~".
 ^31           //  XOR the result by 31. This flips its last five 5 bits.
               //  We now have     "ZYX...CBAzyx...cba".
 d             //  Convert back from a char code.
               // Implicit: output last expression
— ETHproductions
स्रोत
अच्छा विचार (जो मैंने उधार लिया ...) इसके लिए XOR का उपयोग करने के लिए
— लुइस मेंडो
5

सी, 64

एक शून्य फ़ंक्शन जो स्ट्रिंग को जगह में संशोधित करता है।

t(char*p){for(int c;c=*p;)*p++=c>64&c<91|c>96&c<123?(c^31)-4:c;}

टेस्ट: आइडोन

— edc65
स्रोत
1
c;t(char*p){for(;c=*p;)*p++=c>64&c<91|c>96&c<123?(c^31)-4:c;}
— स्पिकट्रिक्स
@CoolGuy सही है, लेकिन मुझे एक समारोह के अंदर वैश्विक पसंद नहीं है ... यह सिर्फ मेरे लिए है
— edc65
क्या यह 64 बाइट्स नहीं है?
— डाउनगोत
@ Do @ हाँ यह है .. धन्यवाद ..
— edc65
5

आर, 69 61 बाइट्स

कुछ अतिरिक्त बाइट्स को हटाने के लिए @Giuseppe का धन्यवाद :

function(s)cat(chartr("a-zA-Z",intToUtf8(c(122:97,90:65)),s))

पुराना वर्जन:

function(s)cat(chartr("a-zA-Z",rawToChar(as.raw(c(122:97,90:65))),s))

यह एक अनाम फ़ंक्शन है। उपयोग:

> f=function(s)cat(chartr("a-zA-Z",rawToChar(as.raw(c(122:97,90:65))),s))
> f("Hello, World!")
Svool, Dliow!
> f("Programming Puzzles & Code Golf")
Kiltiznnrmt Kfaaovh & Xlwv Tlou
> f("This is
+ a multiline
+ example.")
Gsrh rh
z nfogrormv
vcznkov.
— plannapus
स्रोत
1
intToUtf8(c(122:97,90:65))rawरूपांतरणों के बजाय , और आप इससे भी छुटकारा पा सकते हैं cat। मैं इसे एक आदत बना रहा हूँ गोल्फ आने के लिए 1 + साल पुराने जवाब आपके ...
— Giuseppe
4

गंभीरता से, 31 बाइट्स (गैर-प्रतिस्पर्धात्मक)

úúû+╗úRúûR+╝,`;╜íuWD╛E(X0WX`Mεj

हेक्स डंप:

a3a3962bbba352a396522bbc2c603bbda1755744be452858305758604dee6a

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

Expl:

úúû+╗                             Put UPPERCASElowercase in reg0
     úRúûR+╝                      Put ESACREPPUesacrewol in reg1
            ,                     Fetch input.
             `             `Mεj   Map over the characters in string as list, joining result
              ;╜íu                Find 1-index of character in UPPERCASElowercase
                  W     0WX       If it is positive (present): 
                   D              Convert back to 0-index
                    ╛E            Look it up in ESACREPPUesacrewol
                      (X          Delete the original character.
                                  (Else just leave the original character unchanged.)

मुझे सिर्फ यह एहसास हुआ कि कोई अतिरिक्त व्हाट्सएप नहीं है, लेकिन गंभीर रूप से आउटपुट में अनुगामी newlines को दबाने का कोई तरीका नहीं है, इसलिए कोई गंभीर समाधान नहीं है।

— quintopia
स्रोत
1
क्या ESACREPPUesacrewolमतलब है?
— डाउनगोट
3
@ Do @ UPPERCASE का उलटा LOWERCASE उलटा
— मामा फन रोल
2
उल्टा अपरकेस वर्णमाला उलटी हुई
— निचली
4

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

नया समाधान: यहां कुछ अन्य पोस्टों से जादू की छटपटाहट को चुराएं:

->s{s.gsub(/[a-z]/i){($&.ord+4^31).chr}}

रूबी, 55 46 बाइट्स

->s{s.tr'a-zA-Z',[*?A..?Z,*?a..?z].reverse*''}

9 बाइट्स @manatwork की बदौलत

परीक्षण चालन:

->s{s.gsub(/[a-z]/i){($&.ord+4^31).chr}}["Kiltiznnrmt Kfaaovh & Xlwv Tlou"]
=> "Programming Puzzles & Code Golf"
— daniero
स्रोत
3

जोल्फ, 15 बाइट्स

~Ai+plpu+_pl_pu
~A              I don't know what to call this, besides "dictionary replace"
  i              the input
   +plpu         previous dictionary: lower + upper alphabet
        +_p1_pu  new dictionary: reversed lower + reversed upper

टेस्ट सूट , या इसे अपने स्वयं के इनपुट के साथ आज़माएं

— कोनोर ओ ब्रायन
स्रोत
इसके लिए शब्द "लिप्यंतरण" है, FYI करें।
— एक
3

𝔼𝕊𝕄𝕚𝕟 2, 12 चार्ट / 26 बाइट्स (गैर-प्रतिस्पर्धी)

ïĪ(ᶐ+ᶛ,ᶐᴙ+ᶛᴙ

Try it here (Firefox only).

चुनौती पोस्ट होने के बाद जोड़ा गया ट्रांसपेरेट फ़ंक्शन।

व्याख्या

ïĪ(ᶐ+ᶛ,ᶐᴙ+ᶛᴙ // implicit: ï=input
ïĪ(           // transliterate ï...
   ᶐ+ᶛ,       // from uppercase+lowercase alphabet...
       ᶐᴙ+ᶛᴙ  // ... to reversed uppercase+reversed lowercase alphabet
              // implicit output
— मामा फन रोल
स्रोत
मैंने सोचा कि ∞ 2 को 𝔼𝕊𝕄𝕚𝕟 was कहा जा रहा है?
— डाउनगोट
1
नहीं, मैंने 𝔼𝕊𝕄𝕚𝕟 के लिए एक पूरक (लेकिन अलग) भाषा के लिए इसे बचाने का फैसला किया।
— मामा फन रोल
IIRC एक ब्लैकबोर्ड बोल्ड है 2.
— कॉनर ओ'ब्रायन
@) इसे ESMax (डब्लूस्ट्रस में) कहते हैं।
— mbomb007
3

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

q'[,65>__el_@+W%@@+er

इष्टतम समाधान नहीं ... फिर भी ... इसे ऑनलाइन आज़माएं

चीजों को समूहीकृत किए बिना इसकी व्याख्या करना कठिन है, इसलिए यहां एक सामान्य विवरण दिया गया है: इनपुट मिलता है, अपरकेस वर्णमाला को दो बार धक्का देता है और दो बार कम करता है, चीजों को चारों ओर घुमाता है, अपरकेस और लोअरकेस स्ट्रिंग्स को जोड़ती है, एक को उलट देता है, और लिप्यंतरण (रेटिना उत्तर के समान)।

— GamrCorps
स्रोत
क्या यह आउटपुट एक अनुगामी न्यूलाइन है?
— लीजनमोनमल
@ LegionMammal978 यह तब तक नहीं होना चाहिए जब तक कि विज्ञापन बदल न जाए कि कैसे स्टैक आउटपुट किया जाता है।
— गेमक्रॉप्स
@ LegionMammal978 मैं नहीं।
— मार्टिन एंडर
3

सी (फ़ंक्शन), 50

f(char*s){for(;*s;s++)*s=isalpha(*s)?*s+4^31:*s;}

इस पर बनाता है सभी तीन पिछले सी जवाब है, तो क्रेडिट @Ruud, @Danwakeem और @ edc65 करने के लिए।

यह फ़ंक्शन जगह में एक चार सरणी को संशोधित करता है।

मेरी समझ में फंक्शन एंट्रीज की अनुमति है जब तक कि प्रश्न में स्पष्ट रूप से प्रतिबंधित नहीं किया गया है।

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

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

PostgreSQL, 118 125 बाइट्स

SELECT s,TRANSLATE(s,t||UPPER(t),REVERSE(t)||REVERSE(UPPER(t)))
FROM(SELECT text'Programming Puzzles & Code Golf's,text'abcdefghijklmnopqrstuvwxyz't)r

SqlFiddleDemo

आउटपुट:

╔══════════════════════════════════╦═════════════════════════════════╗
║                s                 ║            translate            ║
╠══════════════════════════════════╬═════════════════════════════════╣
║ Programming Puzzles & Code Golf  ║ Kiltiznnrmt Kfaaovh & Xlwv Tlou ║
╚══════════════════════════════════╩═════════════════════════════════╝

इनपुट: SELECT text'...'s

संपादित करें:

तालिका के रूप में इनपुट:

SELECT s,TRANSLATE(s,t||UPPER(t),REVERSE(t)||REVERSE(UPPER(t)))
FROM i,(SELECT text'abcdefghijklmnopqrstuvwxyz't)r
GROUP BY s,t

SqlFiddleDemo

आउटपुट:

╔══════════════════════════════════╦═════════════════════════════════╗
║                s                 ║            translate            ║
╠══════════════════════════════════╬═════════════════════════════════╣
║ Hello, World!                    ║ Svool, Dliow!                   ║
║ Programming Puzzles & Code Golf  ║ Kiltiznnrmt Kfaaovh & Xlwv Tlou ║
║ abcdefghijklmnopqrstuvwxyz       ║ zyxwvutsrqponmlkjihgfedcba      ║
╚══════════════════════════════════╩═════════════════════════════════╝
— lad2025
स्रोत
अरे lad2025, मुझे लगता है कि यह 118 से कम है, लेकिन मैं गिनती के नियमों में कोई विशेषज्ञ नहीं हूं
— t-clausen.dk
2

पायथन 3, 195 169 168 166 बाइट्स

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

मैंने यह कैसे नहीं देखा कि मैं इससे पहले नीचे जा सकता था? 

x=__import__('string').ascii_letters;y,z=x[26:],x[:26];a,b=y[::-1],z[::-1];print(''.join(b[z.index(i)]if i in b else a[y.index(i)]if i in a else i for i in input()))

(सॉर्ट) अनलॉल्फ़्ड:

x = __import__('string').ascii_letters;
y, z = x[26: ], x[: 26];
a, b = y[::-1], z[::-1];
print(''.join(b[z.index(i)]
    if i in b
    else a[y.index(i)]
    if i in a
    else i
    for i in input()
))

Ideone पर यह कोशिश करो!

— बिल्ली
स्रोत
1
आप बाहरी []से हटाकर 2 बाइट्स बचा सकते हैं join।
— त्रांग ऊल
@ TrangOul सच में? यह एक सूची की समझ है, इसलिए मैंने सोचा कि यह एक सूची होनी चाहिए या फिर आपको मिल जाएगी generator object <genexpr> at..., लेकिन मैं इसका परीक्षण करूँगा
— बिल्ली
@ ट्रोंगऑल नेवरमाइंड, मैंने कुछ सीखा, धन्यवाद!
— बिल्ली
किसी भी चलने योग्य [ strमानों] को join()कार्य करने के लिए पारित किया जा सकता है ।
— तुरंग ऊल
2

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

lambda x:''.join([c,chr(ord(c)+4^31)][c.isalpha()]for c in x)

एक अनाम फ़ंक्शन। अक्षरों पर, 4 को जोड़कर बिट प्रतिनिधित्व पर उलटा संचालन करता है, फिर पिछले पांच बिट्स को फ्लिप कर रहा है , जो ETHproductions के जावास्क्रिप्ट उत्तर के समान है ।

— XNOR
स्रोत
बस ठीक यही बात हाहा ने लिखी
— sagiksp
2

हास्केल, 119 104 बाइट्स

@Nimi की बदौलत 15 बाइट्स बचाए। 

c=fromEnum;s=toEnum;f[]="";f(x:y)|64<c x&&c x<91=s(155-c x):f y|96<c x&&c x<123=s(219-c x):f y|0<1=x:f y

उपयोग:

f "abcdefghijklmnopqrstuvwxyz"
"zyxwvutsrqponmlkjihgfedcba"

f "Programming Puzzles & Code Golf"
"Kiltiznnrmt Kfaaovh & Xlwv Tlou"

f "Hello, World!"
"Svool, Dliow!"

व्याख्या 

let c=fromEnum;s=toEnum;--wrap names for later use, fromEnum gets ascii code from char, toEnum gets char from ascii code
f[]=[];                 --feed empty list (of chars in this case), get empty list
f(x:y)                  --feed a list, separate the first element and...
|64<c x&&c x<91=        --if its an uppercase char (using ascii code range)...
s(c x*(-1)+155)         --  inverse its ascii code value, move it to the range of uppercase and get the new char
                        --  (like rotating half turn a ruler by the side and then sliding it to the space it previously occupied)
:f y                    --  feed the rest of the list and stick the new char in front of the result
|96<c x&&c x<123=       --if its a lowercase char (using ascii code range)...
s(c x*(-1)+219)         --  inverse its ascii code value, move it to the range of lowercase and get the new char
:f y                    --  feed the rest of the list and stick the new char in front of the result
|True=x:f y             --otherwise feed the rest of the list and stick the char in front of the result

मैं हास्केल के लिए नया हूं ... कार्यात्मक प्रोग्रामिंग के लिए ... और साइट पर, और मुझे पता है कि इस प्रश्न के बेहतर उत्तर हैं (लेकिन बहुत सारे) मेरे साथ हैं।

— शराबी कान
स्रोत
कुछ गोल्फ युक्तियाँ: क) का उपयोग करने की कोई जरूरत नहीं है let। से सीधे शुरुआत करें c=fromEnum। का उपयोग करें (155-c x)और (219-c x)। c) Trueद्वारा प्रतिस्थापित किया जा सकता है 1<2। - कोड मेरे लिए "अस्पष्ट प्रकार चर" कार्यों cऔर s(ghci 7.10.2) के साथ लोड करने में विफल रहता है , लेकिन f[]=""इसके बजाय आसानी से तय किया जा सकता है f[]=[]।
— नौ
धन्यवाद !, मैं वास्तव में सोच रहा था कि क्या यह "चलो" के बिना वैध था, क्योंकि यह सीधे जीएचसी पर नहीं चलता है।
— शराबी कान
2

पर्ल 6 , 28 बाइट्स

{S:g/\w/{chr $/.ord+4+^31}/}

उपयोग:

# give it a lexical name
my &swap = { … }

say swap 'Programming Puzzles & Code Golf';
# Kiltiznnrmt Kfaaovh & Xlwv Tlou

say swap ('a'..'z').join
# zyxwvutsrqponmlkjihgfedcba
— ब्रैड गिल्बर्ट b2gills
स्रोत
जब मैं इसे चलाता हूं तो यह कहता है: Warning: Use of "ord" without parentheses is ambiguous at (eval 8)[/System/Library/Perl/5.18/perl5db.pl:732] line 2.मुझे पता है कि मैं कुछ गलत नहीं कर रहा हूं? मैं इसे कैसे चलाऊंगा?
— डाउनगेट
@ Doᴡɴɢᴏᴀᴛ अगर आप देखते हैं यह कहना है कि यह में लिखा है पर्ल 6 आप freenode और प्रकार पर # perl6 पर जा सकते हैंm: my &swap = {S:g/\w/{chr $/.ord+4+^31}/}; say swap ('a'..'z').join
— ब्रैड गिल्बर्ट b2gills
आह ठीक है, जाहिरा तौर पर मैं नहीं पढ़ सकता: पी
— डाउनगाट
@ Do @ मैंने एक नोट जोड़ा है कि आप इसे freenode पर # perl6 पर परीक्षण कर सकते हैं
— ब्रैड गिल्बर्ट b2gills
2

जावा, 136 बाइट्स

void x(String i){for(char c:i.toCharArray()){if(Character.isLetter(c))c=c<91?(char)(90-(c-65)):(char)(122-(c-97));System.out.print(c);}}

उदाहरण का उपयोग:

class Test {
  static void x(String i){for(char c:i.toCharArray()){if(Character.isLetter(c))c=c<91?(char)(90-(c-65)):(char)(122-(c-97));System.out.print(c);}}
  public static void main(String[] args) {
    x("Programming Puzzles & Code Golf");
    // produces "Kiltiznnrmt Kfaaovh & Xlwv Tlou"
  }
}

बाइट के आकार के संदर्भ में संभवतः सबसे खराब इस्तेमाल की जाने वाली भाषा है।

— शॉन
स्रोत
1
— डाउनवोट
मुझे पता है कि यह लगभग 1.5 साल पहले पोस्ट किया गया था, लेकिन आप इस तरह से कुछ चीजें गोल्फ कर सकते हैं: void x(String i){for(Character c:i.toCharArray())System.out.print(c.isLetter(c)?(char)(c<91?90-(c-65):122-(c-97)):c);}( 118 बाइट्स )
— केविन क्रूज़सेन
या इससे भी कम: void y(String i){for(int c:i.getBytes())System.out.print((char)(c>65&c<91|c>96&c<123?c<91?90-(c-65):122-(c-97):c));}( 116 बाइट्स )
— केविन क्रूज़सेन
1
@KevinCruijssen तुम भी बनाकर कोष्ठकों के लिए की जरूरत नकारना करने के लिए गणना पुनर्व्यवस्थित कर सकते हैं 90-(c-65)में -c+65+90 और 122-(‌​c-97)में -c+97+122जो एक बाइट प्रत्येक बचाता है,।
— ज़ावड़ा
2

यूनिक्स शेल + ट्र + प्रिंटफ, 35 बाइट्स

tr A-Za-z `printf %s {Z..A} {z..a}`

यहाँ आप हैं, tr में एक विहित जवाब। मैंने सोचा था कि कैसे करने के लिए एक विहित उत्तर के बिना वर्णमाला जाने लिप्यन्तरण के लिए एक प्रश्न सकता tr ansliterate वर्णमाला?

tr अपने आप में एक "हैलो, वर्ल्ड" भी नहीं करता है। और जैसा कि एक प्रोग्रामिंग भाषा नहीं है, इसलिए मैंने उत्तर को गैर-जटिल [1] के रूप में चिह्नित किया ।

[१]: संपादित करें: वास्तव में, यूनिक्स खोल भाषा है और tr मानक पुस्तकालय है । मुझे यह पता लगाने में मदद करने के लिए डाउनगेट और डिजिटल ट्रामा के लिए धन्यवाद।

— user48538
स्रोत
3
मुझे लगता है कि भाषा के रूप में शेल या बैश का दावा करना ठीक है, और trमानक पुस्तकालय के रूप में आम उपयोगिताओं ( कोर्यूटिल्स में) है। मेरे जवाबों के अनगिनत देखें ;-)
— डिजिटल ट्रॉमा
1
लेकिन यह काम नहीं करता है tr: range-endpoints of 'Z-A' are in reverse collating sequence order:। मुझे लगता है कि आपको कुछ करना है tr A-Za-z $(printf %s {Z..A} {z..a})(और $( )बैकटिक्स के साथ बदलें )
— डिजिटल ट्रॉमा
@DigitalTrauma लेकिन हर किसी के पास अपने सिस्टम पर प्रिंट नहीं है।
— user48538
7
मुझे लगता है कि आपके पास एक यूनिक्स प्रणाली खोजने में काफी मुश्किल समय होगा printf- जो कि नहीं है - आखिरकार, पॉज़िक्स द्वारा निर्दिष्ट । इसके अलावा एक बाश में बनाया गया है जो इन दिनों बहुत सर्वव्यापी है। भले ही, हर किसी के सिस्टम पर प्री-इंस्टॉल्ड होना कोड-गोल्फ के लिए कोई शर्त नहीं है - हर किसी के सिस्टम में CJam नहीं है;;
— डिजिटल ट्रॉमा
1
के बीच की जगह }और {आवश्यक है - अन्यथा विस्तार की तरह कुछ हो जाता हैZz Zy Zx ... Za Yz ... Aa
— डिजिटल ट्रामा
1

MATL , 21 28 बाइट्स

संस्करण 6.0.0 का उपयोग करता है , जो इस चुनौती से पहले है। ऑक्टेव में कोड चलता है।

jttk2Y2mXK)o31Z~4-cK(

उदाहरण

>> matl
 > jttk2Y2mXK)o31Z~4-cK(
 >
> Hello, World!
Svool, Dliow!

व्याख्या

j             % input string
t             % duplicate
tk            % duplicate and convert to lowercase
2Y2           % string 'abc...xyz'
m             % "ismember" function: produces logical index of letter positions
XK            % copy to clipboard K
)             % index into string to get its letters
o31Z~4-       % bitwise XOR with 31 and subtract 4
c             % convert to char
K             % paste logical index from clipboard K
(             % put back modified letters into original string

पुराना दृष्टिकोण, 28 बाइट्स

j1Y2!tkh"t@2#m@0v27b-)wXK)K(
— लुइस मेंडो
स्रोत
1

MATLAB, 61 बाइट्स

@(x)[abs(-x+ismember(x,65:90)*155+ismember(x,97:122)*219),'']

मैंने कोशिश की f=@ismember, और रेंज को a=65:90एक चर बनाकर 32+aदूसरे ismember-कल में किया। यह सब कोड को छोटा कर दिया, लेकिन एक कार्यक्रम में परिणाम होगा और इस प्रकार दोनों की आवश्यकता होती है dispऔर input।

यह देता है:

ans('Hello, World!')
ans =
Svool, Dliow!

ans('Programming Puzzles & Code Golf')
ans =
Kiltiznnrmt Kfaaovh & Xlwv Tlou
— स्टीवी ग्रिफिन
स्रोत
1

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

_|hH(:64>:91<,77-H+78=X;H:96>:123<,109-H+110=X;HX),[X]:"~c"w,?b:0&

बिल्ट-इन की कमी वास्तव में यहाँ तकलीफ देती है, इसलिए हमें अच्छे पुराने ASCII कोड अभिकलन का सहारा लेना पड़ता है।

विधेय brachylog_mainइनपुट के रूप में एक चरित्र कोड स्ट्रिंग की उम्मीद करता है और कोई आउटपुट नहीं, उदाहरण के लिएbrachylog_main(`Hello, World!`,_).

व्याख्या

_                                                                  § If the input is empty,
                                                                   § return true
                                                                   §
 |                                                                 § Else
                                                                   §
  hH(                                            ),[X]:"~c"w       § Print variable X which
                                                                   § depends on the head of
                                                                   § the input as a char code
                                                                   §
                                                            ,?b:0& § Recursive call on the
                                                                   § tail of the input
                                                                   §
     :64>:91<,77-H+78=X                                            § If H is capital, X =
                                                                   § 77 - H + 78
                       ;                                           § Else if H is non-cap, X=
                        H:96>:123<,109-H+110=X                     § 109 - H + 110
                                              ;                    § Else (not a letter)
                                               HX                  § H = X
— Fatalize
स्रोत
1

पर्ल 6, 40 39 बाइट्स

चूंकि बाकी सभी अनाम कार्य कर रहे हैं:

my &f=*.trans(/\w/=>{chr $/.ord+4+^31})

(टिप के लिए धन्यवाद @ b2gills)

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

उपयोग:

> f "zyxwvutsrqponmlkjihgfedcba"
abcdefghijklmnopqrstuvwxyz
> f "Kiltiznnrmt Kfaaovh & Xlwv Tlou"
Programming Puzzles & Code Golf
> f "Svool, Dliow!"
Hello, World!
— हॉटकी
स्रोत
आप *.trans(…)इसे छोटा करने के लिए उपयोग कर सकते हैं ।
— ब्रैड गिल्बर्ट 6
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.