Regex के साथ संख्याएँ जोड़ना

Question

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

चुनौती

हम सरल शुरू करेंगे: दो धनात्मक पूर्णांक युक्त एक स्ट्रिंग दी गई है, क्योंकि दशमलव संख्याओं को a से अलग किया जाता है ,, एक स्ट्रिंग का निर्माण करते हैं, जिसमें दशमलव संख्या भी होती है। तो, बहुत सरलता से

47,987

में बदल जाना चाहिए

1034

आपका उत्तर मनमाने ढंग से सकारात्मक पूर्णांक के लिए काम करना चाहिए।

प्रारूप

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

Regex    Modifiers   Replacement   Repeat?
\b(\d)   g           |$1           No
|\d      <none>      1|            Yes
\D       g           <empty>       No

इनपुट को देखते हुए 123,456, यह सबमिशन इनपुट को निम्नानुसार संसाधित करेगा: पहला प्रतिस्थापन एक बार लागू होता है और पैदावार होती है:

|123,|456

अब दूसरा प्रतिस्थापन लूप में लागू किया जाता है जब तक कि स्ट्रिंग बदलना बंद न हो जाए:

1|23,|456
11|3,|456
111|,|456
111|,1|56
111|,11|6
111|,111|

और अंत में, तीसरे प्रतिस्थापन को एक बार लागू किया जाता है:

111111

ध्यान दें कि लूप के लिए समाप्ति मानदंड है कि क्या स्ट्रिंग में परिवर्तन होता है, न कि रेगेक्स को एक मैच मिला। (अर्थात, यदि आप मैच पाते हैं तो यह भी समाप्त हो सकता है लेकिन प्रतिस्थापन मैच के समान है।)

स्कोरिंग

आपका प्राथमिक स्कोर आपके सबमिशन में प्रतिस्थापन चरणों की संख्या होगी। हर दोहराया प्रतिस्थापन 10 चरणों के लिए गणना करेगा । तो उपरोक्त उदाहरण स्कोर होगा 1 + 10 + 1 = 12।

एक टाई के मामले में (बहुत कम संभावना नहीं), माध्यमिक स्कोर सभी चरणों के आकार का योग है। प्रत्येक चरण के लिए रेगेक्स ( बिना सीमांकक), संशोधक और प्रतिस्थापन स्ट्रिंग जोड़ें। उपरोक्त उदाहरण के लिए यह होगा (6 + 1 + 3) + (3 + 0 + 2) + (2 + 1 + 0) = 18।

विविध नियम

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

ध्यान दें कि यह आपके स्वाद और संशोधक पर निर्भर करता है कि क्या प्रत्येक एकल प्रतिस्थापन सभी घटनाओं को प्रतिस्थापित करता है या केवल एक ही। उदाहरण के लिए, यदि आप ECMAScript फ्लेवर चुनते हैं, तो एक एकल चरण डिफ़ॉल्ट रूप से केवल एक घटना को प्रतिस्थापित करेगा, जब तक कि आप gसंशोधक का उपयोग नहीं करते । दूसरी ओर, यदि आप .NET फ्लेवर का उपयोग कर रहे हैं, तो प्रत्येक चरण हमेशा सभी घटनाओं को प्रतिस्थापित करेगा।

एकल और वैश्विक प्रतिस्थापन के लिए अलग-अलग प्रतिस्थापन विधियाँ हैं (उदाहरण के लिए रूबी की subबनाम gsub), मान लें कि एकल प्रतिस्थापन डिफ़ॉल्ट है और एक gसंशोधक की तरह वैश्विक प्रतिस्थापन का इलाज करता है ।

परिक्षण

यदि आपका चुना हुआ स्वाद या तो .NET या ECMAScript है, तो आप अपनी सबमिशन का परीक्षण करने के लिए रेटिना का उपयोग कर सकते हैं (मुझे बताया जा रहा है, यह मोनो पर भी काम करता है)। अन्य स्वादों के लिए, आपको संभवतः होस्ट भाषा में एक छोटा कार्यक्रम लिखना होगा जो क्रम में प्रतिस्थापन लागू करता है। यदि आप करते हैं, तो कृपया अपने उत्तर में इस परीक्षा कार्यक्रम को शामिल करें।

Comments

अगर किसी को इस बात का अंदाजा है कि इस प्रकार की चुनौती को क्या कहते हैं, तो एक टिप्पणी छोड़ दें! :) (बस भविष्य में मैं इनमें से अधिक कर रहा हूँ।)

— मार्टिन एंडर

जो लोग इसे पसंद करते हैं, वे बिना जोड़ के भी आनंद ले सकते हैं और संख्याओं के बिना गुणा कर सकते हैं

— टोबी स्पाइट

क्या रेटिना का रेगेक्स "फ्लेवर" एक वैध सबमिशन है? : P (मैं दो नंबर जोड़ने के प्रबंधन के लिए खुद पर काफी गर्व महसूस कर रहा हूं, इसे अकेले ही पूरा करने दें।)

— अमानवीय

@icrieverytim रेटिना का स्वाद सिर्फ .NET फ्लेवर है।

— मार्टिन एंडर

लेकिन रेटिना में विशेषताएं हैं। .NET के पास नहीं है, नहीं?

— पूरी तरह से

Answer 1

.NET स्वाद, स्कोर: 2

Regex        Modifiers  Replacement  Repeat?
<empty>      <none>     9876543210   No
<see below>  x          <empty>      No

मैं इसे अभी तक गोल्फ के लिए परेशान नहीं हूं, और xसिर्फ व्हाट्सएप को नजरअंदाज करने के लिए हूं ।

यह पहले 9876543210प्रत्येक स्थिति में सम्मिलित होता है , फिर मूल वर्ण और वर्ण हटाते हैं जो योग का वर्तमान अंक नहीं है।

बड़ी रेगेक्स (व्हॉट्सएप और टिप्पणियों के बिना 1346 बाइट्स):

# If the length of the left number <= right number, delete every digit on the left.
.(?=.*,(?<=^(?<len>.)*,)(?<-len>.)*(?(len)(?!)))|

# Do the opposite if it is not the case.
.(?<=(?(len)(?!))(?<-len>.)*(?=(?<len>.)*$),.*)|

# Remove leading zeros.
(?<=(^|,).{9})0|

# Delete everything that is not the current digit of the sum.
.(?!
    # For digits in the left part:
    (?<cur>.){0,9}               # cur = the matched digit
    (?=(.{11})*,)                # and find the position before the next digit.
    (?<first>)                   # first = true
    (                            # Loop on the less significant digits:
        (?<cur>){10}             # cur += 10
        (?<=                     # cur -= the current digit in this number.
            (
                0|^|
                1(?<-cur>)|
                2(?<-cur>){2}|
                3(?<-cur>){3}|
                4(?<-cur>){4}|
                5(?<-cur>){5}|
                6(?<-cur>){6}|
                7(?<-cur>){7}|
                8(?<-cur>){8}|
                9(?<-cur>){9}
            )
            .{10}
        )
        (?=
            (?<pos>.{11})*,      # pos = which digit it is.
            .*$(?<=              # cur -= the current digit in the other number.
                (
                    0|,|
                    1(?<-cur>)|
                    2(?<-cur>){2}|
                    3(?<-cur>){3}|
                    4(?<-cur>){4}|
                    5(?<-cur>){5}|
                    6(?<-cur>){6}|
                    7(?<-cur>){7}|
                    8(?<-cur>){8}|
                    9(?<-cur>){9}
                )
                .{10}
                (?(pos)(?!))     # Assert pos = 0.
                                 # Skip pos input digits from the end.
                                 # But stop and set pos = 0 if the comma is encountered.
                ((?<-pos>\d{11})|(?<=(?>(?<-pos>.)*),.{10}))*
            )
        )
        (?(first)                # If first:
            (?>((?<-cur>){10})?) #  cur -= 10 in case there is no carry.
                                 #  Assert cur = 0 or 1, and if cur = 1, set cur = 10 as carry.
            (?(cur)(?<-cur>)(?(cur)(?!))(?<cur>){10})
            (?<-first>)          #  first = false
        |                        # Else:
                                 #  cur is 10 or 20 at the beginning of an iteration.
                                 #  It must be 1 to 11 to make the equation satisfiable.
            (?<-cur>)            #  cur -= 1
            (?(cur)              #  If cur > 0:
                                 #   cur -= max(cur, 9)
                (?(cur)(?<-cur>)){9}
                (?(cur)          #   If cur > 0:
                                 #    Assert cur = 1 (was 11) and set cur = 10.
                    (?<-cur>)(?(cur)(?!))(?<cur>){10}
                |                #   Else:
                    .*(?=,)      #    cur was 2 to 10, break from the loop.
                )
            )                    #  Else cur is 0 (was 1) and do nothing.
        )
        (.{11}|,)                # Jump to the next digit.
    )*(?<=,)(?(cur)(?!))         # End the loop if it is the last digit, and assert cur = 0.
|
    # Do the same to the right part. So the sum will be calculated two times.
    # Both are truncated to the original length of the number on that side + 1.
    # Only the sum on the longer side will be preserved in the result.
    (?<cur>\d){0,9}
    (?=(\d{11})*$)
    (?<first>)
    (
        (?<cur>){10}
        (?<=
            (
                0|,|
                1(?<-cur>)|
                2(?<-cur>){2}|
                3(?<-cur>){3}|
                4(?<-cur>){4}|
                5(?<-cur>){5}|
                6(?<-cur>){6}|
                7(?<-cur>){7}|
                8(?<-cur>){8}|
                9(?<-cur>){9}
            )
            .{10}
        )
        (?=
            (?<pos>.{11})*$
            (?<=
                (
                    0|^|
                    1(?<-cur>)|
                    2(?<-cur>){2}|
                    3(?<-cur>){3}|
                    4(?<-cur>){4}|
                    5(?<-cur>){5}|
                    6(?<-cur>){6}|
                    7(?<-cur>){7}|
                    8(?<-cur>){8}|
                    9(?<-cur>){9}
                )
                .{10}
                (?(pos)(?!))
                ((?<-pos>\d{11})|(?<=^.{10})(?=(?>(?<-pos>.)*)))*
                ,.*
            )
        )
        (?(first)
            (?>((?<-cur>){10})?)
            (?(cur)(?<-cur>)(?(cur)(?!))(?<cur>){10})
            (?<-first>)
        |
            (?<-cur>)
            (?(cur)
                (?(cur)(?<-cur>)){9}
                (?(cur)
                    (?<-cur>)(?(cur)(?!))(?<cur>){10}
                |
                    .*$(?<end>)
                )
            )
        )
        (.{11}|$(?<end>))
    )*(?<-end>)(?(cur)(?!))
)

इसने मुझे एफओबीोरिया के अंतिम स्तर के बारे में सोचा ... लेकिन मुझे लगता है कि .NET रेगेक्स, जो स्पष्ट रूप से अब "नियमित" नहीं है, पीएच में किसी भी समस्या को हल कर सकता है। और यह सिर्फ एल में एक एल्गोरिथ्म है।

Comments

सभी hail .NET बैलेंसिंग ग्रुप्स।

— Sp3000

पहले मैंने सोचा कि मेरी पाँच-चरण की प्रक्रिया बहुत अच्छी थी। फिर मैंने देखा कि किसी ने आधी लंबाई के साथ एक समाधान का दावा किया है। फिर यह। क्या यह एक रेगेक्स के रूप में भी गिना जाता है?

— जॉन ड्वोरक

@JDDvorak सैद्धांतिक "नियमित अभिव्यक्ति" के लिए, नहीं। "रेगेक्स" के लिए, हाँ, हर कोई इसे एक रेगीक्स कहता है, और लगभग हर रेगेक्स स्वाद में कुछ ऐसा होता है। Microsoft अभी भी उन्हें " नियमित अभिव्यक्ति " आधिकारिक रूप से कहता है ।

— jimmy23013

वाह, यह अद्भुत काम है!

— user230910

Answer 2

स्कोर: 24

मुझे लगता है कि यह काम करता है ...

Regex                                                                                                                       Modifiers   Replacement             Repeat?
(?|(\d*)(\d)(,\d*)(\d)|(^,?\d*)(\d)|, |^,)                                                                                  <none>      $1$3 $2$4               Yes
$                                                                                                                           <none>      ;111111111234567890     No
0|(?|(;.*)|9(?=.*(1{9}))|8(?=.*(1{8}))|7(?=.*(1{7}))|6(?=.*(1{6}))|5(?=.*(1{5}))|4(?=.*(1{4}))|3(?=.*(111))|2(?=.*(11)))    g           $1                      No
 1{10}                                                                                                                      <none>      1                       Yes
 (?|1{9}(?=.*(9))|1{8}(?=.*(8))|1{7}(?=.*(7))|1{6}(?=.*(6))|1{5}(?=.*(5))|1{4}(?=.*(4))|1{3}(?=.*(3))|1{2}(?=.*(2))|)       g            $1                     No
 (?!\d)(?=.*(0))| |;.*                                                                                                      g           $1                      No

मैंने अभी तक व्यक्तिगत नियमित अभिव्यक्ति को गोल्फ करने में ज्यादा समय नहीं बिताया है। मैं जल्द ही एक स्पष्टीकरण पोस्ट करने की कोशिश करूंगा, लेकिन अभी देर हो रही है। इस बीच, यहां प्रत्येक चरण के बीच परिणाम है:

'47,987'
' 9 48 77'
' 9 48 77;111111111234567890'
' 111111111 111111111111 11111111111111;111111111234567890'
'1  111 1111;111111111234567890'
'1  3 4;111111111234567890'
'1034'

पूर्ण पर्ल कार्यक्रम:

$_ = <>;
chomp;

do {
    $old = $_;
    s/(?|(\d*)(\d)(,\d*)(\d)|(^,?\d*)(\d)|, |^,)/$1$3 $2$4/;
} while ($old ne $_);

s/$/;111111111234567890/;

s/0|(?|(;.*)|9(?=.*(1{9}))|8(?=.*(1{8}))|7(?=.*(1{7}))|6(?=.*(1{6}))|5(?=.*(1{5}))|4(?=.*(1{4}))|3(?=.*(111))|2(?=.*(11)))/$1/g;

do {
    $old = $_;
    s/ 1{10}/1 /;
} while ($old ne $_);

s/ (?|1{9}(?=.*(9))|1{8}(?=.*(8))|1{7}(?=.*(7))|1{6}(?=.*(6))|1{5}(?=.*(5))|1{4}(?=.*(4))|1{3}(?=.*(3))|1{2}(?=.*(2))|)/ $1/g;

s/ (?!\d)(?=.*(0))| |;.*/$1/g;

print "$_\n";

Comments

यह मेरी अवधारणा का अपना प्रमाण जैसा दिखता है। :) मेरे पास 7 गैर-लूप प्रतिस्थापन थे, लेकिन मैंने उन्हें रखने के लिए विशेष रूप से कठिन प्रयास नहीं किया।

— मार्टिन एंडर

@ मार्टिनबटनर हाहा अच्छा! मुझे पूरा यकीन है कि मेरे अंतिम दो उप के रूप में अच्छी तरह से विलय किया जा सकता है, लेकिन मैंने एक दिन के लिए पर्याप्त है ...

— gr

सभी प्रमुख रिक्त स्थान जानबूझकर?

— ऑप्टिमाइज़र

@ ओप्टिमाइज़र हाँ। मुझे एक बेहतर किरदार सॉरी चुनना चाहिए था।

— grc

Answer 3

कोई रेगेक्स स्वाद, 41

    s/0/d/g
    ...
    s/9/dxxxxxxxxx/g
rep s/xd/dxxxxxxxxxxx/g
    s/[d,]//g
rep s/(^|d)xxxxxxxxxx/xd/g
    s/(^|d)xxxxxxxxx/9/g
    ...
    s/(^|d)x/1/g
    s/d/0/g

आइए, कोशिश करते हैं। dअंकों के क्रम विभाजक के लिए कार्य करता है, xमूल्य संग्रहीत करता है। पहले हम प्रत्येक अंक को अलग करते हैं, फिर हम बाईं ओर x10 मल्टीप्लायरों को निचोड़ते हैं, फिर सभी विभाजकों को छोड़ते हैं, फिर मल्टीप्लायरों को वापस सम्मिलित करते हैं, फिर प्रत्येक क्रम को अंकों में परिवर्तित करते हैं।

Answer 4

.NET रेगेक्स, 14

उपयोगकर्ता 23013 के समाधान के रूप में अच्छा नहीं है, लेकिन यह मजेदार था। किसी भी प्रतिस्थापन में संशोधक नहीं हैं।

.NET रेगेक्स का कारण एक बार के लिए समूहों को संतुलित करने के कारण नहीं है - मैंने अभी रेटिना के साथ परीक्षण किया है , जो .NET का उपयोग करता है, और मैंने यह भी पाया कि चर लंबाई लुकबाइंड ने बहुत मदद की।

प्रतिस्थापन 1 (दोहराने = नहीं)

regex:

\d(?=\d+$)|\d(?=\d+,)|\d(?=,(\d+)$)|(?<=(\d+),\d*)\d$

प्रतिस्थापन

0$1$2

दो नंबरों की अदला-बदली करें, जिसमें अग्रणी ज़ीरो की समान संख्या हो।

प्रतिस्थापन 2 (दोहराने = नहीं)

regex:

(\d+)

रिप्लेसमेंट:

 $1

प्रत्येक संख्या से पहले एक स्थान जोड़ें

प्रतिस्थापन 3 (दोहराने = नहीं)

$

रिप्लेसमेंट:

&0 ~00000 ~00101 ~00202 ~00303 ~00404 ~00505 ~00606 ~00707 ~00808 ~00909 ~01001 ~01102 ~01203 ~01304 ~01405 ~01506 ~01607 ~01708 ~01809 ~01910 ~02002 ~02103 ~02204 ~02305 ~02406 ~02507 ~02608 ~02709 ~02810 ~02911 ~03003 ~03104 ~03205 ~03306 ~03407 ~03508 ~03609 ~03710 ~03811 ~03912 ~04004 ~04105 ~04206 ~04307 ~04408 ~04509 ~04610 ~04711 ~04812 ~04913 ~05005 ~05106 ~05207 ~05308 ~05409 ~05510 ~05611 ~05712 ~05813 ~05914 ~06006 ~06107 ~06208 ~06309 ~06410 ~06511 ~06612 ~06713 ~06814 ~06915 ~07007 ~07108 ~07209 ~07310 ~07411 ~07512 ~07613 ~07714 ~07815 ~07916 ~08008 ~08109 ~08210 ~08311 ~08412 ~08513 ~08614 ~08715 ~08816 ~08917 ~09009 ~09110 ~09211 ~09312 ~09413 ~09514 ~09615 ~09716 ~09817 ~09918 ~10001 ~10102 ~10203 ~10304 ~10405 ~10506 ~10607 ~10708 ~10809 ~10910 ~11002 ~11103 ~11204 ~11305 ~11406 ~11507 ~11608 ~11709 ~11810 ~11911 ~12003 ~12104 ~12205 ~12306 ~12407 ~12508 ~12609 ~12710 ~12811 ~12912 ~13004 ~13105 ~13206 ~13307 ~13408 ~13509 ~13610 ~13711 ~13812 ~13913 ~14005 ~14106 ~14207 ~14308 ~14409 ~14510 ~14611 ~14712 ~14813 ~14914 ~15006 ~15107 ~15208 ~15309 ~15410 ~15511 ~15612 ~15713 ~15814 ~15915 ~16007 ~16108 ~16209 ~16310 ~16411 ~16512 ~16613 ~16714 ~16815 ~16916 ~17008 ~17109 ~17210 ~17311 ~17412 ~17513 ~17614 ~17715 ~17816 ~17917 ~18009 ~18110 ~18211 ~18312 ~18413 ~18514 ~18615 ~18716 ~18817 ~18918 ~19010 ~19111 ~19212 ~19313 ~19414 ~19515 ~19616 ~19717 ~19818 ~19919

एक कैरी बिट ( &0) और साथ ही विशाल लुकअप तालिका जोड़ें <c> <a> <b> <carry of a+b+c> <last digit of a+b+c>।

प्रतिस्थापन 4 (दोहराएं = हां)

regex:

(?<=(\d),.*(\d)&)(\d)(?=.*~\3\1\2(.))|(\d)(?=,.*\d&)|(?<=\d,.*)(\d)(?=&)|^(?=.* .*(\d),.*(\d)&(\d).*~\9\7\8.(.))

रिप्लेसमेंट:

$4$10

प्रत्येक संख्या के अंतिम अंक लेते रहें, और उनकी (राशि, वहन) खोजें। राशि को स्ट्रिंग की शुरुआत में रखें और कैरी को बदलें।

प्रतिस्थापन 5 (दोहराने = नहीं)

regex:

^0*| .*

रिप्लेसमेंट:

<empty>

साफ - सफाई।

उदाहरण चलाते हैं

Repl no.        String
(input)         1428,57
1               000057,001428
2                000057, 001428
3                000057, 001428&0 <lookup table>
4               5 00005, 00142&1 <lookup table>
4               85 0000, 0014&0 <lookup table>
4               485 000, 001&0 <lookup table>
4               1485 00, 00&0 <lookup table>
4               01485 0, 0&0 <lookup table>
4               001485 , &0 <lookup table>
5               1485

---

^{(कुछ चरणों के संयोजन से मैं 12 प्राप्त कर सकता हूं, लेकिन चूंकि यह बहुत गन्दा हो जाता है और वैसे भी नहीं जीतेगा क्योंकि मुझे लगता है कि मैं इसके बजाय इसे और अधिक सुरुचिपूर्ण संस्करण बनाकर रखूँगा।)}

Answer 5

स्कोर: 50 40 31 21

इस उत्कृष्ट चुनौती के लिए धन्यवाद। यह समाधान बहुत सुरुचिपूर्ण नहीं है, लेकिन, प्रतिबंधों को देखते हुए, मैं आउटपुट में एक अंक को उदारता से संभालने का कोई तरीका नहीं देख सकता।

यह समाधान उन कैप्चर समूहों को दिखाता है जो कभी-कभी मेल नहीं खाते और उन पर निर्भर होते हैं जब ऐसा होता है। यह पर्ल में काम करता है, हालांकि यह आम तौर पर एक चेतावनी पैदा करता है।

Regex 1:     (((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0                                            
Modifiers:   g
Replacement: <$1$2$3$4$5$6$7$8$9>             
Repeat:      no

Regex 2:     (.*)<(\d*)>(,.*)<(\d*)>|(.*)<(\d*)>(.*)|(?:(^[^<]*)b(\d*)c)?(b)\d{9}(\d)(\d*)(c)
Modifiers:   none 
Replacement: \8\1\5\3b$9$11\2\6\4c\7$10$12$13 
Repeat:      yes

Regexes 3-12: ,?baaaaaaaaac
Modifiers:    g
Replacement:  9 etc. (one for each digit)

पूर्ण पर्ल कोड नमूना, मध्यवर्ती परिणामों की व्याख्या और मुद्रण के साथ:

no warnings;
use 5.16.0;

$_ = '47,987';

#Convert numbers to beans
s/(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0/<$1$2$3$4$5$6$7$8$9>/g;

say;
my $last;

#Combine pairs of digits, starting with least significant.
do {
    $last=$_;
    s/(.*)<(\d*)>(,.*)<(\d*)>|(.*)<(\d*)>(.*)|(?:(^[^<]*)b(\d*)c)?(b)\d{9}(\d)(\d*)(c)/\8\1\5\3b$9$11\2\6\4c\7$10$12$13/;
    say;
}
while ($last ne $_);

#Convert beans back to numbers.
s/,?b\d{9}c/9/g;
s/,?b\d{8}c/8/g;
s/,?b\d{7}c/7/g;
s/,?b\d{6}c/6/g;
s/,?b\d{5}c/5/g;
s/,?b\d{4}c/4/g;
s/,?b\d{3}c/3/g;
s/,?b\d{2}c/2/g;
s/,?b\d{1}c/1/g;
s/,?bc/0/g;

say;

अपडेट: मैं दो लूपिंग रेगेक्स को एक साथ जोड़ सकता था, जिससे 10 की बचत हुई।

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

अद्यतन 3: मैंने एक एकल लूपिंग रेगेक्स में कमी की।

Comments

दिलचस्प समाधान। :) प्रतिस्थापन तार में ब्रेसिज़ क्या करते हैं? है ${1}से अलग $1? इसके अलावा, आप संबंधों के मामले में बाइट की गिनती को शामिल करना चाह सकते हैं।

— मार्टिन एंडर

@ मार्टिनबटनर, ब्रेसिज़ केवल अन्य वर्णों से चर नाम को अलग करते हैं जो एक चर में हो सकते हैं।

आह, यह समझ में आता है। धन्यवाद।

— मार्टिन एंडर

@ मार्टिनबटनर, मैंने इसे \1कुछ पात्रों को बचाने के बजाय, आदि का उपयोग करने के लिए बदल दिया ।