রেজেক্সের সাথে নম্বর যুক্ত করা হচ্ছে

Question

আমি একটি নতুন ধরণের রেজেক্স গল্ফ চ্যালেঞ্জ চেষ্টা করতে চাই, যা আপনাকে রেজেক্সের প্রতিস্থাপন ছাড়া কিছুই না করে অযৌক্তিক কম্পিউটিং সংক্রান্ত কাজগুলি সমাধান করতে বলে। এটি আরও সম্ভব এবং কম কাজ শুরু করার জন্য, আপনাকে একের পর এক বেশ কয়েকটি বিকল্প প্রয়োগ করার অনুমতি দেওয়া হবে।

চ্যালেঞ্জ

আমরা সহজ শুরু করব: দুটি ধনাত্মক পূর্ণসংখ্যাযুক্ত একটি স্ট্রিং দেওয়া হ'ল দশমিক সংখ্যা হিসাবে একটি দ্বারা পৃথকীকৃত দশমিক সংখ্যা হিসাবে ,তার যোগফল যুক্ত স্ট্রিং তৈরি করে। সুতরাং, খুব সহজ

47,987

মধ্যে পরিণত করা উচিত

1034

আপনার উত্তরটি ইচ্ছামত ইতিবাচক পূর্ণসংখ্যার জন্য কাজ করা উচিত।

ফর্ম্যাট

প্রতিটি উত্তর প্রতিস্থাপনের পদক্ষেপগুলির ক্রম হওয়া উচিত , প্রতিটি ধাপে একটি রেইজেক্স এবং প্রতিস্থাপনের স্ট্রিং থাকে। Allyচ্ছিকভাবে, ক্রমের এই প্রতিটি পদক্ষেপের জন্য, স্ট্রিং পরিবর্তন হওয়া বন্ধ না হওয়া পর্যন্ত আপনি বিকল্পটি পুনরাবৃত্তি করতে পছন্দ করতে পারেন। এখানে একটি উদাহরণ জমা দেওয়া (যা উপরের সমস্যার সমাধান করে না ):

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।

বিবিধ বিধি

আপনি কোনও রেইগেক্স ফ্লেভার ব্যবহার করতে পারেন (যা আপনার নির্দেশ করা উচিত) তবে সমস্ত পদক্ষেপে অবশ্যই একই স্বাদ ব্যবহার করা উচিত। তদ্ব্যতীত, আপনাকে অবশ্যই স্বাদের হোস্ট ভাষার কোনও বৈশিষ্ট্য ব্যবহার করতে হবে না , যেমন প্রতিস্থাপন কলব্যাকস বা পার্লের eসংশোধক, যা পার্ল কোডকে মূল্যায়ন করে। সমস্ত ম্যানিপুলেশন অবশ্যই একচেটিয়াভাবে regex প্রতিস্থাপনের মাধ্যমে ঘটতে হবে।

মনে রাখবেন যে এটি আপনার স্বাদ এবং সংশোধনকারীগুলির উপর নির্ভর করে যে প্রতিটি একক প্রতিস্থাপন সমস্ত ঘটনাকে প্রতিস্থাপন করে বা কেবল একটি একক। উদাহরণস্বরূপ আপনি যদি ECMAScript স্বাদটি চয়ন করেন তবে একক পদক্ষেপ ডিফল্টরূপে কেবলমাত্র একটি ঘটনাকে প্রতিস্থাপন করবে, যদি না আপনি gসংশোধক ব্যবহার করেন । অন্যদিকে, আপনি যদি নেট নেট ব্যবহার করছেন তবে প্রতিটি পদক্ষেপ সর্বদা সমস্ত উপস্থিতি প্রতিস্থাপন করবে।

যে ভাষাগুলির একক এবং বৈশ্বিক প্রতিস্থাপনের জন্য পৃথক প্রতিস্থাপনের পদ্ধতি রয়েছে (উদাহরণস্বরূপ রুবির subবনাম gsub), ধরে নিন যে একক প্রতিস্থাপনটি ডিফল্ট এবং কোনও gসংশোধক হিসাবে বিশ্বব্যাপী প্রতিস্থাপনের আচরণ করে ।

পরীক্ষামূলক

যদি আপনার নির্বাচিত স্বাদটি হয় নেট বা ইসমাএসক্রিপ্ট হয়, আপনি আপনার জমাটি পরীক্ষা করতে রেটিনা ব্যবহার করতে পারেন (আমাকে বলা হচ্ছে, এটি মনোতেও কাজ করে)। অন্যান্য স্বাদের জন্য, আপনাকে সম্ভবত হোস্ট ভাষায় একটি ছোট প্রোগ্রাম লিখতে হবে যা বিকল্পগুলি যথাযথভাবে প্রয়োগ করে। যদি আপনি তা করেন তবে দয়া করে আপনার উত্তরে এই পরীক্ষা প্রোগ্রামটি অন্তর্ভুক্ত করুন।

Comments

কারও যদি এই ধরণের চ্যালেঞ্জটি কী বলা যায় সে সম্পর্কে ভাল ধারণা থাকে তবে একটি মন্তব্য করুন! :) (ভবিষ্যতে আমি এর মধ্যে আরও কিছু করছি))

— মার্টিন এন্ডার

যারা এটি পছন্দ করেন তারা সংযোজন ছাড়াই সংযোজন এবং সংখ্যা ছাড়াই

— গুণতে পারেন

রেটিনার রেজেক্সটি কি "স্বাদ" একটি বৈধ জমা? : পি (মোটামুটি দুটি সংখ্যার যোগ দেওয়ার ব্যবস্থাপনার জন্য আমি নিজের পক্ষে যথেষ্ট গর্বিত, এটি একেবারে গল্ফ করুন))

— সম্পূর্ণরূপে

@ আইক্রিরিটিম রেটিনার স্বাদ হ'ল নেট নেট।

— মার্টিন এন্ডার

কিন্তু রেটিনার বৈশিষ্ট্য রয়েছে। নেট নেই, নেই?

— সম্পূর্ণমানবিক

Answer 1

। নেট গন্ধ, স্কোর: 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)(?!))
)

এটি আমাকে ম্যানুফ্যাকোরিয়ার চূড়ান্ত স্তরের সম্পর্কে ভাবতে বাধ্য করেছে ... তবে আমি মনে করি। নেট নেটজেল, যা সম্ভবত "নিয়মিত" নয়, পিএইচ-তে কোনও সমস্যা সমাধান করতে পারে। এবং এটি এল-তে কেবল একটি অ্যালগরিদম is

Comments

সমস্ত শেল। নেট ব্যালান্সিং গ্রুপগুলি।

— এসপি 3000

প্রথমে আমি ভেবেছিলাম আমার পাঁচ-পদক্ষেপের প্রক্রিয়াটি বেশ ভাল। তারপরে আমি দেখেছি যে কেউ অর্ধ দৈর্ঘ্য সহ সমাধান দাবি করছে। তারপর এই. এটি কি একটি রেজেক্স হিসাবে গণনা করা হয়?

— জন ডিভোরাক

@ জনডভোরাক তাত্ত্বিক "নিয়মিত প্রকাশ" এর জন্য, না। "রেজেক্স" এর জন্য, হ্যাঁ, প্রত্যেকে এটিকে একটি রেজেক্স বলে এবং প্রায় প্রতিটি রেগেক্স স্বাদে এর কিছু থাকে। মাইক্রোসফ্ট এখনও তাদের আনুষ্ঠানিকভাবে " নিয়মিত অভিব্যক্তি " বলে।

— 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 টি নন-লুপ বিকল্প রয়েছে, তবে আমি এগুলি নিচে রাখার জন্য বিশেষ চেষ্টা করেছিলাম না।

— মার্টিন ইন্ডার

@ মার্টিনবাটনার হাহাহা! আমি নিশ্চিত যে আমার শেষ দুটি

— সাবও একত্রী

সমস্ত নেতৃস্থানীয় স্পেস ইচ্ছাকৃত?

— অপ্টিমাইজার 13

@ অপ্টিমাইজার হ্যাঁ দুঃখিত, আমার আরও ভাল চরিত্রটি বেছে নেওয়া উচিত ছিল।

— 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মান সঞ্চয় করে। প্রথমে আমরা প্রতিটি অঙ্কটি আনারাইজ করি, তারপরে আমরা এক্স 10 গুণককে বাম দিকে মিশ্রিত করব, তারপরে সমস্ত বিভাজককে ড্রপ করব, তারপরে গুণকগুলিকে ব্যাক-ইনসার্ট করুন, তারপরে প্রতিটি ক্রমটিকে অঙ্কগুলিতে ফিরে রূপান্তর করুন।

Answer 4

.NET রেইজেক্স, 14

ব্যবহারকারী 23013 এর সমাধানের মতো ভাল নয়, তবে এটি মজাদার ছিল। প্রতিস্থাপনের কোনওটিতেই মডিফায়ার নেই।

.NET Regex জন্য কারণ কারণ একবার গ্রুপ মিট নয় - আমি শুধু সাথে পরীক্ষিত অক্ষিপট , যা .NET ব্যবহার করে এবং আমি এও দেখা গেছে যে পরিবর্তনশীল দৈর্ঘ্য lookbehinds অনেক সাহায্য করেছে।

প্রতিস্থাপন 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পরিবর্তে কয়েকটি অক্ষর সংরক্ষণ করে আমি এটি ব্যবহার করে বদলেছিলাম etc.