प्रोग्रामर गार्डन

Question

प्रोग्रामर गार्डन

एक पेशेवर सॉफ्टवेयर डेवलपर होने के नाते, आप अपने आप को सूरज की कठोर गैर-कृत्रिम रोशनी के संपर्क में लाने का जोखिम नहीं उठा सकते हैं, लेकिन आपके पास फूलों के लिए एक नरम स्थान भी है, और अपने बगीचे को पूरे वर्ष अच्छे आकार में रखना चाहते हैं।

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

इनपुट

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

इनपुट की पहली पंक्ति प्रारूप की है

width height unwanted_item_type_count

जहां widthफूल की चौड़ाई है, फूल heightकी ऊंचाई (एएससीआईआई अक्षर दोनों में) है, और unwanted_item_type_countआपको बताता है कि बगीचे से निकाले जाने वाले एक प्रकार के आइटम का वर्णन करने के लिए कितनी लाइनें होंगी।

प्रत्येक अवांछित प्रकार के आइटम के लिए प्रत्येक पंक्ति प्रारूप की है

width height string_representation name fee_per_item

widthआइटम की चौड़ाई कहां है, आइटम heightकी ऊंचाई है (दोनों ASCII वर्णों में), string_representationपंक्ति विराम के बिना आइटम का स्ट्रिंग प्रतिनिधित्व है, आइटम nameके प्रकार के लिए एक पहचानकर्ता है (रिक्त स्थान को अंडरस्कोर के साथ बदल दिया जाएगा), औरfee_per_item यह है कि प्रत्येक प्रकार के आइटम को हटाने के लिए माली को कितना भुगतान किया जाना चाहिए।

उदाहरण के लिए

3 2 .R.\|/ rouge_flower 3

एक आइटम प्रकार के नाम का प्रतिनिधित्व करता है rouge_flower, जिसे निकालने के लिए 3 की लागत होती है, और इस तरह दिखता है:

.R.
\|/

आइटम में रिक्त स्थान नहीं होंगे, और किसी भी आइटम में पूरी तरह से डॉट्स से युक्त एक सीमा नहीं हो सकती है, और स्ट्रिंग प्रतिनिधित्व भी सटीक आकार का वर्णन करेगा। इस प्रकार, निम्नलिखित सभी अमान्य इनपुट हैं:

3 1 ( ) space 0
1 1 . dot 0
2 1 .! bang 0
3 2 .@.\|/. plant 0

ध्यान दें कि 0 हालांकि एक वैध शुल्क है (फीस हमेशा -1 से अधिक पूर्णांक होगी)।

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

अवांछित आइटम प्रकार सूचीबद्ध होने के बाद, फिर दिए गए चौड़ाई और ऊंचाई के फूल के ASCII प्रतिनिधित्व आता है।

उत्पादन

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

आउटपुट फूल के प्रिंट-आउट के साथ शुरू होता है, लेकिन सभी अवांछित वस्तुओं को हटा दिया जाता है (डॉट्स के साथ बदल दिया जाता है), इसलिए आप देख सकते हैं कि इसे कैसे दिखना चाहिए और माली ने अपना काम किया है। फ्लॉवरबेड में प्रत्येक आइटम डॉट्स की एक आयत से घिरा होगा, और एक-सन्निहित आइटम होगा (यानी आइटम के अंदर कोई अलग डॉट्स नहीं होगा )। उदाहरण के लिए

.....
.#.#.
.....

2 अलग आइटम दिखाता है

.....
.\@/.
.....

1 आइटम दिखाता है

......
.#....
....|.
....|.
.o--/.
......

यह अमान्य है, क्योंकि पत्थर (#) का मिलान किया जा सकता है, सांप (आप यह नहीं बता सकते कि यह सांप था?) नहीं कर सकता क्योंकि पत्थर डॉट्स के आस-पास आवश्यक होने पर हस्तक्षेप करता है।

...
\@.
...

यह भी अमान्य है, क्योंकि घोंघा फूल के किनारे पर है, और किनारे को हमेशा वैध इनपुट में डॉट्स द्वारा बाध्य किया जाना चाहिए।

इसके बाद, प्रारूप में प्रत्येक प्रकार की अवांछित वस्तु की एक सूची, गिनती, प्रति आइटम की लागत, और सभी वस्तुओं के लिए लागत (गणना * लागत प्रति आइटम) होनी चाहिए:

<count> <name> at <cost_per_item> costs <cost>

इसके बाद, कुल लागत (अवांछित वस्तुओं के लिए लागत का योग) में एक एकल रेखा होनी चाहिए:

total cost <total_cost>

उदाहरण

इसके लिए दिए गए इनपुट

25 18 3
4 2 .\/.\\// weeds 5
2 1 \@ snails 2
1 1 # stones 1
.........................
.\@/.................\@..
............\/...........
......O....\\//..^|^.....
.#...\|/.........^|^.....
..................|......
.................\|/.....
..\@.....\/...........#..
........\\//....#........
....*....................
...\|/......\/......\@/..
...........\\//..........
..................*......
.......\@/.......\|/.....
...O.....................
..\|/.......*............
.......#...\|/....\@.....
.........................

कार्यक्रम इस उत्पादन का उत्पादन करना चाहिए

.........................
.\@/.....................
.........................
......O..........^|^.....
.....\|/.........^|^.....
..................|......
.................\|/.....
.........................
.........................
....*....................
...\|/..............\@/..
.........................
..................*......
.......\@/.......\|/.....
...O.....................
..\|/.......*............
...........\|/...........
.........................
3 weeds at 5 costs 15
3 snails at 2 costs 6
4 stones at 1 costs 4
total cost 25

आउटपुट को एक ब्रेक द्वारा समाप्त किया जाना चाहिए।

यह कोड-गोल्फ है, सबसे छोटी कोड जीत हो सकती है।

अतिरिक्त परीक्षण मामला

संपादित करें: इसमें यूनिकोड सम्‍मिलित था, जो कि फूलबेड में, बहुत आधुनिक नहीं है। इसे ठीक कर लिया गया है, इस बारे में खेद है।

25 15 5
5 3 ..@..\\|//.\|/. overgrown_plants 3
5 3 @-o....|...\|/. semi-articulated_plant 4
3 2 .|.\@/ mutant_plants 5
1 1 $ dollars 0
1 1 # stones 1
.........................
........@................
....$..\|/...........@...
............|.......\|/..
...#.......\@/...........
.........................
.........................
......@.......@......@...
.....\|/....\\|//...\|/..
.............\|/.........
.#....................#..
.........$.......|.......
...\/.......\/..\@/..\/..
..\\//.....\\//.....\\//.
.........................

अपेक्षित उत्पादन:

.........................
........@................
.......\|/...........@...
....................\|/..
.........................
.........................
.........................
......@..............@...
.....\|/............\|/..
.........................
.........................
.........................
...\/.......\/.......\/..
..\\//.....\\//.....\\//.
.........................
1 overgrown_plants at 3 costs 3
0 semi-articulated_plants at 4 costs 0
2 mutant_plants at 5 costs 10
2 dollars at 0 costs 0
3 stones at 1 costs 3
total cost 16

Comments

क्या हम मान सकते हैं कि प्रत्येक अवांछित वस्तु का बाउंडिंग बॉक्स सटीक है? अर्थात्, आइटम के विवरण में कोई सीमा पूरी तरह से डॉट्स नहीं है?

— जॉन ड्वोरक

@JDDvorak हाँ, यह एक उचित पर्याप्त बाधा लगता है। मैं इसे प्रश्न में जोड़ दूंगा, और आपके अनुमान को मैं इस बात के लिए उधार लूंगा कि आप मेरे ऐसा करने से बुरा नहीं मानेंगे।

— विजुअलमेल

क्या घोंघा भी अलग-अलग दिशा में रेंग रहा होगा? \@और @/उदाहरण के लिए .. या वे पश्चिम में अनंत काल तक बाध्य हैं?

— हान सलोन

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

— विजुअलमेल

Answer 1

पर्ल - 636

वहाँ निश्चित रूप से कुछ और गोल्फिंग किया जा सकता है। और शायद इसे करने के बेहतर तरीके भी।

<>;while(<>){if(/ /){chomp;push@v,$_}else{$t.=$_}}for(@v){r(split/ /)}say$t.$y."total cost $u";sub r{my($e,$w,$c,$h,$z)=@_;($i,$f,$q,$d)=(1,0,0,"."x$e);@m=($c=~/($d)/g);@l=split/\n/,$t;while($i>0){($g,$j)=(1,0);for(0..$#l){if($j==0&&$l[$_]=~/^(.*?)\.\Q$m[$j]\E\./){$j++;$l="."x length$1}elsif($j<@m&&$l[$_]=~/^$l\.\Q$m[$j]\E\./){$j++}elsif($j>0){$l[$_-1]=~s!.\Q$m[$j-1]\E.!" ".$m[$j-1]=~s/\./ /gr." "!e;($j,$g)=(0,0)}if($j==@m){$k=$j;for($f=$_;$f>$_-$j;$f--){$k--;$o="."x length$m[$k];$l[$f]=~s/^($l)\.\Q$m[$k]\E\./$1.$o./}($g,$j)=(0,0);$q++}}if($g){$i--}}$t=join("\n",@l)."\n";$t=~s/ /./g;$p=$z*$q;$u+=$p;$y.="$q $h at $z costs $p\n"}

-Cयूरो को संभालने के लिए ध्वज के लिए 635 वर्ण + 1 ।

यदि आपके पास इनपुट संग्रहीत है, input.txtतो आप इसे चला सकते हैं:

cat input.txt | perl -C -E'<>;while(<>){if(/ /){chomp;push@v,$_}else{$t.=$_}}for(@v){r(split/ /)}say$t.$y."total cost $u";sub r{my($e,$w,$c,$h,$z)=@_;($i,$f,$q,$d)=(1,0,0,"."x$e);@m=($c=~/($d)/g);@l=split/\n/,$t;while($i>0){($g,$j)=(1,0);for(0..$#l){if($j==0&&$l[$_]=~/^(.*?)\.\Q$m[$j]\E\./){$j++;$l="."x length$1}elsif($j<@m&&$l[$_]=~/^$l\.\Q$m[$j]\E\./){$j++}elsif($j>0){$l[$_-1]=~s!\Q$m[$j-1]\E!$m[$j-1]=~s/\./ /gr!e;($j,$g)=(0,0)}if($j==@m){$k=$j;for($f=$_;$f>$_-$j;$f--){$k--;$o="."x length$m[$k];$l[$f]=~s/^($l)\.\Q$m[$k]\E\./$1.$o./}($g,$j)=(0,0);$q++}}if($g){$i--}}$t=join("\n",@l)."\n";$t=~s/ /./g;$p=$z*$q;$u+=$p;$y.="$q $h at $z costs $p\n"}'

यहाँ पर इसका संस्करण है। मैंने कुछ चीजों को समझाने में मदद करने के लिए कुछ टिप्पणियों को जोड़ा। हो सकता है कि मैं चर नामों को कभी-कभी अधिक पठनीय बनाऊं। ऐसे कुछ किनारे मामले हो सकते हैं जो इसके साथ काम नहीं करते हैं लेकिन यह कम से कम उदाहरणों के साथ काम करता है।

BEGIN { # These are the features we get with -C and -E flags
    $^H{'feature_unicode'} = q(1); # -C gives us unicode
    $^H{'feature_say'} = q(1); # -E gives us say to save 1 character from print
    $^H{'feature_state'} = q(1);
    $^H{'feature_switch'} = q(1);
}
<ARGV>; # throw away the first line
while (defined($_ = <ARGV>)) { # read the rest line by line
    if (/ /) { # if we found a space (the garden doesn't have spaces in it)
        chomp $_; # remove the newline
        push @v, $_; # add to our array
    }
    else { # else, we construct the garden
        $t .= $_;
    }
}
foreach $_ (@v) { # call the subroutine r by splitting our input lines into arguments
    r(split(/ /, $_, 0)); # the arguments would be like r(3,2,".R.\|/","rouge_flower",3)
}
say $t . $y . "total cost $u"; # print the cost at the end

# this subroutine removes weeds from the garden and counts them
sub r {
    BEGIN {
        $^H{'feature_unicode'} = q(1);
        $^H{'feature_say'} = q(1);
        $^H{'feature_state'} = q(1);
        $^H{'feature_switch'} = q(1);
    }
    my($e, $w, $c, $h, $z) = @_; # get our arguments
    ($i, $f, $q, $d) = (1, 0, 0, '.' x $e); # initialize some variables
    @m = $c =~ /($d)/g; # split a string like this .R.\|/ into .R. and \|/
    @l = split(?\n?, $t, 0); # split the garden into lines to process line by line
    while ($i > 0) {
        ($g, $j) = (1, 0);
        foreach $_ (0 .. $#l) { # go through the garden
            if ($j == 0 and $l[$_] =~ /^(.*?)\.\Q$m[$j]\E\./) { # this matches the top part of the weed. \Q and \E make it so the weed isn't intepreted as a regex. Capture the number of dots in front of it so we know where it is
                ++$j;
                $l = '.' x length($1); # this is how many dots we have
            }
            elsif ($j < @m and $l[$_] =~ /^$l\.\Q$m[$j]\E\./) { # capture the next line
                ++$j;
            }
            elsif ($j > 0) { # if we didn't match we have to reset
                $l[$_ - 1] =~ s[.\Q$m[$j - 1]\E.][' ' . $m[$j - 1] =~ s/\./ /rg . ' ';]e; # this line replaces the dots next to the weed and in the weed with spaces
                # to mark it since it didn't work but the top part matches
                # that way when we repeat we go to the next weed
                ($j, $g) = (0, 0);
            }
            if ($j == @m) { # the whole weed has been matched
                $k = $j;
                for ($f = $_; $f > $_ - $j; --$f) { # remove the weed backwards line by line
                    --$k;
                    $o = '.' x length($m[$k]);
                    $l[$f] =~ s/^($l)\.\Q$m[$k]\E\./$1.$o./; 
                }
                ($g, $j) = (0, 0);
                ++$q;
            }
        }
        if ($g) {
            --$i; # all the weeds of this type are gone
        }
    }
    $t = join("\n", @l) . "\n"; # join the garden lines back together
    $t =~ s/ /./g; # changes spaces to dots 
    $p = $z * $q; # calculate cost
    $u += $p; # add to sum
    $y .= "$q $h at $z costs $p\n"; #get message
}

सुधार का सुझाव देने के लिए स्वतंत्र महसूस करें!

Comments

अच्छा काम, और मुझे डर है कि मैंने पाप किया है, मैंने निर्दिष्ट किया है कि फुलबेड ASCII होगा, और फिर सभी उत्साहित हो गए और यूनिकोड को उदाहरण में रखा - मैं उदाहरण बदलूंगा ताकि यह सिर्फ ASCII हो, काम करने के लिए खेद है आप।

— विजुअलमेल

@VisualMelon यह जानना दिलचस्प था कि यूनिकोड के साथ काम करने के लिए एक-लाइनर कैसे प्राप्त किया जाए। मुझे -Cइससे पहले ध्वज के बारे में पता नहीं था । मैं इसे वैसे भी संगत रहने के लिए छोड़ दूंगा क्योंकि यह केवल 1 वर्ण का अंतर है।

— hmatt1

Answer 2

पायथन 3, 459 बाइट्स

    from re import*
E=input()
W,H,C=map(int,E[0].split())
B,T,O='\n'.join(E[~H:]),0,''
for L in E[1:~H]:
 w,h,s,n,c=L.split();w,h,c=map(int,(w,h,c));r,t='.'*(w+2),0;a=[r]+['.%s.'%s[i:i+w]for i in range(0,w*h,w)]+[r]
 for L in['(%s)'%'\\n'.join('.{%d})%s(.*'%(i,escape(b))for b in a)for i in range(W)]:t+=len(findall(L,B));B=sub(L,r.join('\\%d'%b for b in range(1,h+4)),B,MULTILINE)
 O+='%d %s at %d costs %d\n'%(t,n,c,t*c);T+=t*c
print(B+O+'total cost',T)

मान लें कि इनपुट को स्ट्रिंग्स की सूची के रूप में दिया जाएगा।

Comments

मुझे ~Hतरकीब पसंद है ; मैं अब इसका परीक्षण नहीं कर सकता, लेकिन मैं आज बाद में ऐसा करने की कोशिश करूंगा।

— विजुअलमेल

मैं इसे सही ढंग से चलाने के लिए प्राप्त नहीं कर सकता ( ValueError: not enough values to unpack (expected 3, got 1), अजगर 3.6.6); क्या आप इसे चलाने के लिए एक TIO लिंक या कुछ विवरण प्रदान कर सकते हैं। मुझे लगता है कि यह सब एक लाइन में है, यह मानकर नियमों को झुकाया जा सकता है, लेकिन मैं इस बारे में पूरी तरह से स्पष्ट नहीं था कि मैं शिकायत नहीं करूंगा।

— विजुअलमेल

@VisualMelon - बाह, मैंने शायद कॉपी / पास्ता कुछ गलत किया है। मुझे काम पर TIO नहीं मिल सकता है, इसलिए मैं अपने काम की जांच करूंगा और आज बाद में एक लिंक पोस्ट करूंगा।

— त्रिगुटर्नोमेट्री