14

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

एक रन लगातार अक्षरों या अंकों का एक क्रम है। ध्यान दें कि उस स्थिति में जहां इनपुट स्ट्रिंग अक्षरों के एक रन के साथ समाप्त होती है, यह रन अछूता रह जाता है।

उदाहरण के माध्यम से चलो

उदाहरण के लिए, इनपुट स्ट्रिंग को देखते हुए uV5Pt3I0:

अक्षरों के अलग-अलग रन और अंकों के रन: uV 5 Pt 3 I 0
रन के जोड़े की पहचान करें: (uV 5) (Pt 3) (I 0)
रन के जोड़े जोड़े: (5 uV) (3 Pt) (0 I)
CONCATENATE: 5uV3Pt0I

उदाहरण

uV5Pt3I0 -> 5uV3Pt0I
J0i0m8 -> 0J0i8m
abc256 -> 256abc
Hennebont56Fr -> 56HennebontFr
Em5sA55Ve777Rien -> 5Em55sA777VeRien
nOoP -> nOoP

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

code-golf string

— जिम
स्रोत

9

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

~ṠŒg⁸ṁṭ2/

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

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

~ṠŒg⁸ṁṭ2/  Main link. Argument: s (string)

~          Apply bitwise NOT.
           Bitwise operators attempt to cast to int, so if c is a digit, this
           yields ~int(c), a negative number.
           If c cannot be cast to int, ~ will yield 0.
 Ṡ         Take the sign.
           We've now mapped digits to -1, non-digits to 0.
  Œg       Group consecutive equal elements.
    ⁸ṁ     Mold s as the result, grouping run of digits and runs of non-digits.
       2/  Reduce all pairs of runs by...
      ṭ        tack, appending the first run of the pair to the second run.

— डेनिस
स्रोत

15

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

(\D+)(\d+)
$2$1

यह रेगेक्स (\D+)(\d+)को बदल देता है $2$1। अगर आपको पता नहीं है कि इसका क्या मतलब है तो उसे तोड़ दें।

\D'कुछ भी नहीं है कि एक संख्या मैच' का मतलब है। \d'एक नंबर है कि मैच सब कुछ' का मतलब है। +संकेत का अर्थ है 'एक बार कम से कम इस से मेल खाते हैं, लेकिन संभव के रूप में कई बार के रूप में यह मिलान करने का प्रयास'। कोष्ठक एक समूह को परिभाषित करते हैं। पहला समूह है (\D+)और दूसरा है(\d+)

दूसरी पंक्ति में हम कहते हैं कि हम दूसरे समूह द्वारा जो कुछ भी मिलान किया गया था, उसके बाद पहले समूह द्वारा जो कुछ भी मिलान किया गया था, उसे रखना चाहते हैं। यह प्रभावी रूप से अक्षर और अंकों को चलाता है।

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

— Okx
स्रोत

7

हास्केल , 58 56 बाइट्स

2 बाइट्स से शेविंग करने के लिए @ लिकोनी का धन्यवाद

f""=""
f s|(a,(b,y))<-span(<':')<$>span(>'9')s=b++a++f y

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

Ungolfed:

f "" = ""
f string | (letters, afterLetters) <- span (> '9') string
         , (numbers, afterNumbers) <- span (< ':') afterLetters
         = numbers ++ letters ++ f afterNumbers

— जूलियन वुल्फ
स्रोत

के साथ दो बाइट्स सहेजें (a,(b,y))<-span(<':')<$>span(>'9')s।

— लाइकोनी

1

इसके साथ और भी सहेजें (a,(b,y):_)<-lex<$>span(>'9')s: इसे ऑनलाइन आज़माएं!

— लकोनी

@ लायोनी: टिप के लिए धन्यवाद! मैं वास्तव में स्पष्ट नहीं हूं कि कैसे lexकाम करता है, इसलिए मैं अब तक के लिए इसे शामिल करने से बच रहा हूं। किसी भी मामले में, यह जानने के लिए अच्छा है कि Prelude में कुछ ऐसा है

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

7

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

s=>s.replace(/(\D+)(\d+)/g,"$2$1")

कोशिश करो

o.innerText=(f=
s=>s.replace(/(\D+)(\d+)/g,"$2$1")
)(i.value="uV5Pt3I0");oninput=_=>o.innerText=f(i.value)

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

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

— झबरा
स्रोत

6

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

ss_Mc:z"(\d+)"3 2

व्याख्या

     :z"(\d+)"3      # Split the input z onto matches of numbers (\d+)
    c           2    # Split the resulting list in pieces of length 2
  _M                 # Reverse each pair
ss                   # Concatenate

टेस्ट सूट ।

— लीक नन
स्रोत

6

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

मेरे द्वारा आजमाया गया हर गैर-रेग्ज समाधान। : पी

lambda s:re.sub('(\D+)(\d+)',r'\2\1',s)
import re

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

— totallyhuman
स्रोत

6

जाप (v2.0a0), 16 बाइट्स

q/(\d+/ ò mw c q

इसे ऑनलाइन टेस्ट करें!

नोट: यह एक अस्थिर अल्फा है, इसलिए यदि यह लिंक टूट जाता है, तो आप v1.4.4 में थोड़े लंबे संस्करण का उपयोग कर सकते हैं: इसे ऑनलाइन टेस्ट करें!

व्याख्या

q/(\d+/ ò mw c q  : Implicit input              "uV5Pt3I0"
q                 : Split input on
 /(\d+/           :   runs of digits, keeping each run. (This compiles to the regex /(\d+)/g)
                  : This gives                  ["uV","5","Pt","3","I","0",""]
        ò         : Take every pair of items.   [["uV","5"],["Pt","3"],["I","0"],[""]]
          m       : Map each pair by
           w      :   reversing.                [["5","uV"],["3","Pt"],["0","I"],[""]]
             c    : Flatten into one array.     ["5","uV","3","Pt","0","I",""]
               q  : Join into a single string.  "5uV3Pt0I"
                  : Implicit: output result of last expression

— ETHproductions
स्रोत

अगर यह करने का कोई तरीका था, तो यह पता लगाने की कोशिश कर रहा था ò।

— झबरा

5

CJam , 32 30 28 बाइट्स

q{i_64>X\:X^{])[}&c}/]]2/Wf%

CJam का कोई रेगेक्स नहीं है और कोई "अंकों और अक्षरों में विभाजित नहीं" या व्हाट्सएप नहीं है, इसलिए यह एक तरह से दर्दनाक था।

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

व्याख्या

q      e# Read the input.
{      e# Do the following for every char c:
 i     e#  Get c's codepoint.
 64>   e#  Check if it's greater than 64 (i.e. if it's a letter), pushing 1 or 0.
 X     e#  Push X (variable predefined to 1).
 \:X   e#  Store whether c was a letter or digit into X.
 ^{    e#  If (old X) XOR (new X) is 1:
  ]    e#   Close the current array.
  )    e#   Pull out its last character.
  [    e#   Open a new array.
 }&    e#  (end if)
 c     e#  Turn the codepoint back into a character. This also shoves it into the new array, 
       e#  in case one was opened.
}/     e# (end for)
]      e# Close the final array, since it hasn't been closed yet.
]      e# Wrap the whole stack into an array.
2/     e# Split elements into groups of 2.
Wf%    e# Reverse each group.
       e# Implicitly flatten and print.

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

4

गामा , 11 वर्ण

<L><D>=$2$1

नमूना रन:

bash-4.4$ gema '<L><D>=$2$1' <<< 'Em5sA55Ve777Rien'
5Em55sA777VeRien

— आदमी काम पर है
स्रोत

बहुत छोटा। मेरा मतलब है, यह एक गोल्फ भाषा और सिर्फ 11 नहीं है? वाह।

— को आउटगोल्फ जूल

हाँ, लेकिन केवल उन कार्यों के लिए जिन्हें एक ही इनपुट को दो बार छूने की आवश्यकता नहीं है। फिर यह दुःस्वप्न बन जाता है। ☹

— manatwork

अपने अन्य पदों में से एक के माध्यम से Gema मिला ... शांत भाषा। आप कितना अस्पष्ट कहेंगे कि गामा है?

— जोना

@ जोनाह, मैं कहूंगा कि इसका एकमात्र अस्पष्ट हिस्सा डोमेन है। हालांकि यह आंशिक रूप से है क्योंकि यह सुविधा कमज़ोर है। अन्यथा भाषा महान लेकिन दर्दनाक रूप से सीमित सुविधाओं का एक संग्रह है। (उदाहरण के लिए पहचानकर्ता चट्टानें, लेकिन वे बहुत शक्तिशाली होंगे यदि उन्हें नियमित अभिव्यक्ति चरित्र वर्गों की तरह जोड़ा जा सके।)

— मैनटवर्क

90 के दशक में gema कितना लोकप्रिय था? और क्या इसका कोई आधुनिक समकक्ष / प्रतियोगी है? क्या आप इसे काम के लिए इस्तेमाल करते हैं या सिर्फ इसे मज़े के लिए पाते हैं?

— योना

3

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

s->s.replaceAll("(\\D+)(\\d+)","$2$1")

समझाने के लिए ज्यादा नहीं। @Okx के रेटिना उत्तर के समान विधि का उपयोग करता है , जो कि जावा में कोई छोटा नहीं हो सकता।

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

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

2

जाप, 18 बाइट्स

r"(%D+)(%d+)""$2$1

झसे आज़माओ

— झबरा
स्रोत

क्या आप स्पष्टीकरण जोड़ सकते हैं?

— जिम

@ जिम, यह मेरे जेएस समाधान (जेएसटी ट्रांसपाइल्स को जेएस) का सिर्फ एक बंदरगाह है, जो बहुत आत्म-व्याख्यात्मक होना चाहिए। यदि नहीं, तो ओक्सेक्स के रेटिना समाधान में स्पष्टीकरण देखें; मेरे दोनों एक ही काम करते हैं।

— शैगी

4

??? @Downvoter: कृपया प्रतिक्रिया प्रदान करें।

— झबरा

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

— डाउनगोट

1

@Downgoat, टिप्पणी करने के लिए धन्यवाद। हालांकि, मैंने यह नहीं कहा कि मैंने ओकेएक्स के समाधान की नकल की, मैंने बस जिम को स्पष्टीकरण के लिए निर्देशित किया। यदि आप टाइमस्टैम्प की जांच करते हैं, तो आप देखेंगे कि मैंने अपना जेएस समाधान ओकेक्स के रूप में लगभग उसी समय पोस्ट किया है (मैं भी पहले हो सकता था, लेकिन मैं मोबाइल पर सटीक टाइमस्टैम्प नहीं देख सकता)। मैंने तब दूसरी भाषा में अपना समाधान पेश किया, जो यहां हर समय होता है, जब तक कि आप सभी बंदरगाहों को डाउनवोट नहीं कर रहे हैं , मुझे समझ नहीं आता कि आपने इसे क्यों चुना है।

— झबरा

2

सेड, 29 बाइट्स

s/([^0-9]+)([0-9]+)/\2\1/g

-R के साथ चलाएं।

कैप्चर समूहों का उपयोग करता है और उन्हें विपरीत क्रम में बदल देता है।

— यह लड़का है
स्रोत

आप छोटा कर सकते हैं [A-Za-z]करने के लिए [^0-9]। हालाँकि, आपको ध्वज को अपने कोड के भाग के रूप में गिनना होगा।

— डेनिस

ध्वज की गिनती कितनी है?

— यह गाइ

के बीच अंतर sed <command>और sed -r <command>, इसलिए तीन बाइट्स।

— डेनिस

@ डेनिस, यह sed -f filenameऔर sed -rf filename(या बीच sed -e 'command'और sed -re 'command') का अंतर है : एक एकल बाइट।

— टोबी स्पाइट

मुझे प्रश्न में मुख्य वाक्यांश (" एक अक्षर से शुरू ") याद आया, इसलिए s/([a-z]+)([0-9]+)|([0-9]+)([a-z]+)/\2\1\4\3/gi48 बाइट्स में था। अन्यथा, बहुत कुछ ऐसा ही है।

— टोबे स्पाइट

2

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

e€ØDŒg⁸ṁs2Ṛ€

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

स्पष्टीकरण:

e€ØDŒg⁸ṁs2Ṛ€ Accepts a string
e€ØD         Check if each char is in ['0'..'9']
    Œg       Split runs of 0s and 1s (respectively letter and digit runs)
      ⁸ṁ     Replace with input, keeping the split
        s2   Get pairs of runs, last left alone if letter run
          Ṛ€ Swap each pair

— आउटगोल्फ को एरिक करें
स्रोत

2

क्या आप स्पष्टीकरण जोड़ सकते हैं?

— जिम

@ जय जोड़ा विस्फोट।

— आउटगोल्फ जूल

2

PHP, कोई रेगेक्स, 73 बाइट्स

for(;a&$c=$argn[$i++];$p=$c)$c<A?print$c:$s=($p<A?!print$s:$s).$c;echo$s;

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसका परीक्षण करें ।

टूट - फूट

for(;a&$c=$argn[$i++];  # loop through input
    $p=$c)                  # 2. remember character
    $c<A                    # 1. if digit
        ?print$c            # then print it
        :$s=($p<A           # else if previous character was digit
            ?!print$s           # then print and reset string
            :$s                 # else do nothing
        ).$c;                   # append current character to string
echo$s;                 # print remaining string

— टाइटस
स्रोत

मेरा मतलब है आप उपयोग कर सकते हैं ~के बजायa&

— Jörg Hülsermann

1

PHP , 45 बाइट्स

<?=preg_replace("#(\D+)(\d+)#","$2$1",$argn);

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

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

1

सी #, 71 बाइट्स

s=>System.Text.RegularExpressions.Regex.Replace(s,@"(\D+)(\d+)","$2$1")

बस शर्म की बात है कि नियमित अभिव्यक्ति C # में इतनी लंबी है।

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

पूर्ण / स्वरूपित संस्करण:

using System;

class P
{
    static void Main()
    {
        Func<string, string> f = s => System.Text.RegularExpressions.Regex.Replace(s, @"(\D+)(\d+)", "$2$1");

        Console.WriteLine(f("uV5Pt3I0"));
        Console.WriteLine(f("J0i0m8"));
        Console.WriteLine(f("abc256"));
        Console.WriteLine(f("Hennebont56Fr"));
        Console.WriteLine(f("Em5sA55Ve777Rien"));
        Console.WriteLine(f("nOoP"));

        Console.ReadLine();
    }
}

— TheLethalCoder
स्रोत

क्या आप TIO से लिंक जोड़ सकते हैं ?

— जिम

@ जीम किया। मैं आमतौर पर इसे शुरू में जोड़ने के लिए बहुत आलसी हूं, खासकर जब मैं अभी भी किसी भी सुधार की तलाश में हूं।

— द लीथेलकोडर

1

क्लोजर, 104 88 बाइट्स

ओह regex वास्तव में आसान है ... वैसे भी ( TIO ):

#(apply str(flatten(map reverse(partition-all 2(partition-by(fn[i](< 47(int i)58))%)))))

partition-byउस फ़ंक्शन के वापसी मूल्य के आधार पर लगातार रन partition-allमें विभाजन, 2 के विभाजन में विभाजन (जोड़े हम स्वैप कर रहे होंगे), map reverseउन्हें उलट देता है, flattenनेस्टेड सूची संरचना से छुटकारा पाता है और अंत में हम एक स्ट्रिंग आउटपुट करेंगे। यदि partitionइसके बजाय प्रयोग किया गया था partition-allऔर हमारे पास विषम संख्या थी, तो अंतिम को छोड़ दिया जाएगा।

मूल प्रयुक्त वर्बोज़ लेकिन मज़ा (juxt second first)और (set"0123456789")के बजाय reverseऔर पर्वतमाला पूर्णांक ASCII।

#(apply str(flatten(map(juxt second first)(partition-all 2(partition-by(comp not(set"0123456789"))%)))))

— NikoNyrh
स्रोत

क्या आप TIO और एक स्पष्टीकरण के लिए एक लिंक जोड़ सकते हैं ?

— जिम

1

QuadR , 15 बाइट्स

(\D+)(\d+)
\2\1

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

स्पष्टीकरण तो एकदम Okx से चोरी :

यह रेगेक्स (\D+)(\d+)को बदल देता है \2\1। अगर आपको पता नहीं है कि इसका क्या मतलब है तो उसे तोड़ दें।

\D'कुछ भी नहीं है कि एक संख्या मैच' का मतलब है। \d'एक नंबर है कि मैच सब कुछ' का मतलब है। +संकेत का अर्थ है 'एक बार कम से कम इस से मेल खाते हैं, लेकिन संभव के रूप में कई बार के रूप में यह मिलान करने का प्रयास'। कोष्ठक एक समूह को परिभाषित करते हैं। पहला समूह है (\D+)और दूसरा है(\d+)

दूसरी पंक्ति में हम कहते हैं कि हम दूसरे समूह द्वारा जो कुछ भी मिलान किया गया था, उसके बाद पहले समूह द्वारा जो कुछ भी मिलान किया गया था, उसे रखना चाहते हैं। यह प्रभावी रूप से अक्षर और अंकों को चलाता है।

— एडम
स्रोत

1

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

$args|%{$_ -replace '(\D+)(\d+)','$2$1'}

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

PowerShell इसके लिए बहुत आदर्श है, यह देखते हुए कि यह regex सर्च-एंड-आउट ऑफ़ बॉक्स का समर्थन करता है। प्रॉप्स रेगेक्स सॉल्यूशन के लिए @ ओकेएक्स पर जाते हैं।

— जेफ फ्रीमैन
स्रोत

1

पिप , 17 बाइट्स

aR-C+XL.C+XD{c.b}

कमांड-लाइन तर्क के रूप में इनपुट लेता है। इसे ऑनलाइन आज़माएं!

व्याख्या

यह मानक रेगेक्स-प्रतिस्थापन रणनीति का उपयोग करता है, कुछ हद तक गोल्फ।

रेगेक्स है -C+XL.C+XD, जो इसका मूल्यांकन करता है `(?i)([a-z]+)(\d+)`:

   XL       Preset regex variable for lowercase letter: `[a-z]`
  +         Apply + to the regex: `[a-z]+`
 C          Wrap the regex in a capturing group: `([a-z]+)`
-           Apply the case-insensitive flag: `(?i)([a-z]+)`
        XD  Preset regex variable for digit: `\d`
       +    Apply + to the regex: `\d+`
      C     Wrap the regex in a capturing group: `(\d+)`
     .      Concatenate the two regexes: `(?i)([a-z]+)(\d+)`

प्रतिस्थापन {c.b}, एक कॉलबैक फ़ंक्शन है जो दूसरे समूह ( c) और पहले समूह ( b) को मिलाता है । (फ़ंक्शन के लिए पहला तर्क a, जिसमें पूरा मैच शामिल है।)

यह भोले से तीन बाइट छोटा है aR`(\D+)(\d+)``\2\1`।

— DLosc
स्रोत

1

ब्रेनफक , 98 बाइट्स

,[>>----[---->+<<<-[>]>]>>[.[[-]<]<<[-]+>>]<[[-<<<+>>>]<<<<[-<[<]>[.[-]>]]>[-<+>]>],]<[-]<[<]>[.>]

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

व्याख्या

यह प्रोग्राम अभी तक आउटपुट नहीं होने से पत्रों की एक कतार बनाए रखता है, और उचित होने पर उन्हें आउटपुट करता है।

इस कार्यक्रम की कुंजी है >>----[---->+<<<-[>]>]। इनपुट सेल के दाएं तीन सेल शून्य पर शुरू होते हैं। यदि इनपुट 1 और 63 समावेशी के बीच एक कोड बिंदु है, तो यह पॉइंटर को एक स्थान दाईं ओर ले जाता है और इस नई स्थिति के इनपुट दो स्थानों को सही जगह देता है। अन्यथा, पॉइंटर दो स्पेस को दाएं घुमाता है, नई स्थिति के सेल एक स्पेस राइट 63 हो जाता है, और उसी 63 को इनपुट सेल से घटा दिया जाता है। यह बड़े करीने से इनपुट को अक्षरों (65-122) और अंकों (48-57) में विभाजित करता है।

,[                       Take first input byte and start main loop
  >>                     Move two cells to the right
  ----[---->+<<<-[>]>]   (See above)
  >>                     Move two cells to the right
                         This cell contains the input if it was a digit, and 0 if input was a letter
  [                      If input was a digit:
   .                     Output digit immediately
   [[-]<]                Zero out digit and working cell
   <<[-]+>>              Set flag so we know later that we've output a digit
  ]
  <                      Move one cell left
                         This cell contains 63 if input was a letter, and 0 if input was a digit
  [                      If input was a letter:
   [-<<<+>>>]            Add 63 back to input letter
   <<<<                  Move to flag
   [                     If a digit has been output since the last letter read:
    -                    Clear flag
    <[<]>                Move to start of queue
    [.[-]>]              Output and clear all queued letters
   ]
   >[-<+>]>              Move input to end of queue
  ]
,]                       Repeat until no input remains
<[-]                     Clear flag if present
<[<]>                    Move to start of queue
[.>]                     Output all queued letters

— Nitrodon
स्रोत

एक दिमागी जवाब देने के लिए बधाई जो जवाबों में सबसे लंबा नहीं है!

— जिम

1

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

->x{x.gsub /(\D+)(\d+)/,'\2\1'}

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

— एलेक्स
स्रोत

0

गणितज्ञ, 129 बाइट्स

(n=NumberString;l=Length;s=Riffle[a=StringCases[#,n],b=StringSplit[#,n]];If[l@a==0,s=#,If[l@a<l@b,AppendTo[s,b[[-2;;]]]]];""<>s)&

— J42161217
स्रोत

क्या आप एक स्पष्टीकरण / अनलॉक्ड संस्करण जोड़ सकते हैं?

— जिम

समझाने के लिए ज्यादा कुछ नहीं ... पता लगाता है नंबरस्ट्रीम 2 सेटों में विभाजित होता है और riffles.Plus कुछ "अगर" शर्तों को पूरी तरह से काम करने के लिए

— J42161217

स्वैप पत्र और अंक चलता है

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

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

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

हास्केल , 58 56 बाइट्स

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

कोशिश करो

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

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

जाप (v2.0a0), 16 बाइट्स

व्याख्या

CJam , 32 30 28 बाइट्स

व्याख्या

गामा , 11 वर्ण

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

जाप, 18 बाइट्स

सेड, 29 बाइट्स

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

PHP, कोई रेगेक्स, 73 बाइट्स

PHP , 45 बाइट्स

सी #, 71 बाइट्स

क्लोजर, 104 88 बाइट्स

QuadR , 15 बाइट्स

स्पष्टीकरण तो एकदम Okx से चोरी :

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

पिप , 17 बाइट्स

व्याख्या

ब्रेनफक , 98 बाइट्स

व्याख्या

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

गणितज्ञ, 129 बाइट्स