3 और 5 लिटर जुग पज़ल


14

आपने इसे डाई हार्ड में देखा होगा: एक प्रतिशोध के साथ ... यह प्रश्न प्रसिद्ध 3 और 5 लिटर जुग पज़ल पर आधारित है, लेकिन थोड़ा अलग तिरछा है।

1 और 100 के बीच पूर्णांक दिए जाने पर कुछ कोड को गोल्फ करें, आपको 3 लीटर जग और 5 लीटर जग का उपयोग करके, एक फव्वारे से लीटर पानी की इसी संख्या को मापने के लिए त्वरित निर्देश प्रदान करेगा।

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

टैंक में जाते ही आप टैंक से पानी का उपयोग नहीं कर सकते।

निष्पादन का प्रारूप इस प्रकार है:

इनपुट:

4 उदाहरण के लिए।

उत्पादन

प्रत्येक गिने हुए चरण को आउटपुट करें, जैसा कि दिखाया गया है, इसके बाद 5L जग, 3L जग और टैंक की मात्राओं का एक समूह है। टैली प्रारूप भी नीचे दिखाया गया है। चरणों की समाप्ति पर चरणों की संख्या भी आउटपुट होनी चाहिए।

1) Fill 5L jug

5L: 5, 3L: 0, T: 0

2) Pour from 5L jug into 3L jug

5L: 2, 3L: 3, T: 0

3) Empty 3L jug

5L: 2, 3L: 0, T: 0

4) Pour from 5L jug into 3L jug

5L: 0, 3L: 2, T: 0

5) Fill 5L jug

5L: 5, 3L: 2, T: 0

6) Pour from 5L jug into 3L jug

5L: 4, 3L: 3, T: 0

7) Pour from 5L jug into tank

5L: 0, 3L: 3, T: 4

Volume measured out in 7 turns

उदाहरण 2

इनपुट: 8

आउटपुट:

1) Fill 5L jug

5L: 5, 3L: 0, T: 0

2) Pour from 5L jug into tank

5L: 0, 3L: 0, T: 5

3) Fill 3L jug

5L: 0, 3L: 3, T: 5

4) Pour from 3L jug into tank

5L: 0, 3L: 0, T: 8

Volume measured out in 4 turns

कन्वेंशनों

  1. Fill xL jug - जुड़े हुए जग को फव्वारे से ऊपर तक भरता है
  2. Empty xL jug - जुड़े हुए जग की सामग्री को फव्वारे में खाली कर देता है
  3. Pour from xL jug into yL jug - xL जग की सामग्री को yL जग में रखता है
  4. Pour from xL jug into tank - xL जग की सामग्री को टैंक में डाल देता है

सबसे छोटा कोड जीतता है।



4
@ हॉवर्ड, पुराना प्रश्न अ-निर्दिष्ट है (जिसका कोई मानदंड नहीं है) और छोड़ दिया गया था, इसलिए मुझे लगता है कि यह बेहतर है और इसे बंद नहीं किया जाना चाहिए।
विक्टर स्टैफुसा

मुझे पागल कहो, लेकिन सबसे अच्छा समाधान होने वाला नहीं है। 1. जितना संभव हो उतना 5 एल जोड़ें, 2. यदि आवश्यक हो तो 3 एल जोड़ें, 3. पहले से ही हल 2 एल या 1 एल हिस्से को आवश्यकतानुसार जोड़ें?

1
@LegoStormtroopr जब यह सब उबलता है, सच है। लेकिन मैं उम्मीद कर रहा हूं कि यह कोड-गोल्फ के अनुसार होगा।
वैलेस्ट

3
@LegoStormtroopr मैंने सोचा कि यह भी है, लेकिन 6 और 9 नहीं हैं?
पॉल प्रेस्टिज

जवाबों:


6

माणिक, 407 376 365 331 324 323

यह पढ़ने में कठिन हो रहा है ...

x=y=n=d=0
g=gets.to_i
"#{[43435,102,t=45,t,12,t,12,t,t][g+~d]||12}".chars{|c|n+=1
puts [eval(["x-=t=[3-y,x].min;y+=t"+t=";'Pour from 5L jug into 3L jug'","x=5;'Fill 5L jug'","d+=x;x=0"+t.sub(/3.+/,"tank'")][c.ord%3].tr t='35xy',c<?3?t:'53yx'),"5L: #{x}, 3L: #{y}, T: #{d}"]}while g>d
$><<"Volume measured out in #{n} turns"

STDIN पर इनपुट लेता है। उदाहरण के लिए N = 10 चलाएं:

Fill 5L jug
5L: 5, 3L: 0, T: 0
Pour from 5L jug into tank
5L: 0, 3L: 0, T: 5
Fill 5L jug
5L: 5, 3L: 0, T: 5
Pour from 5L jug into tank
5L: 0, 3L: 0, T: 10
Volume measured out in 4 turns

2
"यह पढ़ने में कठिन है ..." - यार, कोड गोल्फ की बात नहीं है ...? ;)
वैलीवेस्ट

4
@ वैलीस्टॉप नोप। हम उन लोगों के लिए एक [obfuscation] टैग है! मेरी विनम्र राय एक ही लंबाई के दो कोडगुल्फ समाधानों में से एक होगी, सबसे पठनीय सबसे अच्छा होगा।
मिस्टर लिस्टर

@ मिस्टरलीस्टर फेयर काफी है, लेकिन कभी-कभी
मोटापा

5

टी-एसक्यूएल 2012: 1410 1302

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

इस के दिल में इंजन 5-12 लाइनों में है, जो समस्या को हल करने के लिए आवश्यक अधिकांश संख्याओं की तालिका बनाने के लिए एक पुनरावर्ती CTE और एक विंडो फ़ंक्शन का उपयोग करता है। 3, 4, 6, या 9 के लिए विशेष रूप से परीक्षण पर ध्यान दें, जो आगे की ओर उन नंबरों से 3 एस द्वारा समाधान के लिए एक इष्टतम दृष्टिकोण सुनिश्चित करता है। (तकनीकी रूप से, यह 3-1 के दृष्टिकोण और 2-2 के बीच 4 के लिए एक टाई है, लेकिन इस तरह से करने से मुझे बहुत सारे किरदार मिल गए।) फिर अलग-अलग के लिए इष्टतम चरणों की लुकअप टेबल में शामिल होना एक साधारण बात है। समस्या का हिस्सा है और चरणों को ठीक से संख्या देने के लिए एक अन्य विंडो फ़ंक्शन का उपयोग करें।

यदि आपके पास MS SQL नहीं है, तो इसके साथ SQLFiddle पर खेलें।

DECLARE @i INT=42,@l VARCHAR(9)='L jug ',@k VARCHAR(99)='into tank
5L: 0, 3L: 0, T: ',@o VARCHAR(99)='
5L: 5, 3L: 0, T: ',@n CHAR(1)='
',@5 VARCHAR(99)=') Pour from 5',@3 VARCHAR(99)=') Pour from 3'
;WITH t AS (SELECT @i i,(@i-@i%5)%5 j
UNION ALL
SELECT i-5,(i-i%5)%5+5 FROM t WHERE i>=5 AND i NOT IN(6,9)
UNION ALL
SELECT i-3,3FROM t WHERE i in(3,4,6,9)
UNION ALL
SELECT i-i,i FROM t WHERE i<3 AND i>0)
SELECT t.i,t.j,v.s,ROW_NUMBER()OVER(PARTITION BY t.j ORDER BY t.i DESC)x,SUM(t.j)OVER(ORDER BY t.i DESC ROWS UNBOUNDED PRECEDING)y INTO #q FROM(VALUES(1,5),(2,3),(3,2),(5,2))v(i,s) JOIN t ON t.j = v.i
SELECT z.b FROM(SELECT ROW_NUMBER()OVER(ORDER BY q.i DESC,w.s)a,CAST(ROW_NUMBER()OVER(ORDER BY q.i DESC,w.s)AS VARCHAR)+w.v+CAST(y-CASE WHEN q.s!=w.s THEN q.j ELSE 0 END AS VARCHAR)b
FROM(VALUES(5,1,') Fill 5'+@l+@o),(5,2,@5+@l+@k),(3,1,') Fill 3'+@l+@n+'5L: 0, 3L: 3, T: '),(3,2,@3+@l+@k),(2,1,') Fill 5'+@l+@o),(2,2,@5+@l+' into 3'+@l+@n+'5L: 2, 3L: 3, T: '),(2,3,@5+@l+@k),(1,1,') Fill 3'+@l+@n+'5L: 0, 3L: 3, T: '),(1,2,@3+@l+'into 5'+@l+@n+'5L: 3, 3L: 0, T: '),(1,3,') Fill 3'+@l+@n+'5L: 3, 3L: 3, T: '),(1,4,@3+@l+'into 5'+@l+@n+'5L: 5, 3L: 1, T: '),(1,5,@3+@l+'into tank'+@o))w(i,s,v)JOIN #q q ON w.i=q.j
UNION
SELECT 99,'Volume measured out in '+CAST(COUNT(*)AS VARCHAR)+' turns'
FROM #q)z

इनपुट 42 के लिए परिणाम:

1) Fill 5L jug 
5L: 5, 3L: 0, T: 0
2) Pour from 5L jug into tank
5L: 0, 3L: 0, T: 5
3) Fill 5L jug 
5L: 5, 3L: 0, T: 5
4) Pour from 5L jug into tank
5L: 0, 3L: 0, T: 10 
5) Fill 5L jug 
5L: 5, 3L: 0, T: 10 
6) Pour from 5L jug into tank
5L: 0, 3L: 0, T: 15 
7) Fill 5L jug 
5L: 5, 3L: 0, T: 15 
8) Pour from 5L jug into tank
5L: 0, 3L: 0, T: 20 
9) Fill 5L jug 
5L: 5, 3L: 0, T: 20 
10) Pour from 5L jug into tank
5L: 0, 3L: 0, T: 25 
11) Fill 5L jug 
5L: 5, 3L: 0, T: 25 
12) Pour from 5L jug into tank
5L: 0, 3L: 0, T: 30 
13) Fill 5L jug 
5L: 5, 3L: 0, T: 30 
14) Pour from 5L jug into tank
5L: 0, 3L: 0, T: 35 
15) Fill 5L jug 
5L: 5, 3L: 0, T: 35 
16) Pour from 5L jug into tank
5L: 0, 3L: 0, T: 40 
17) Fill 5L jug 
5L: 5, 3L: 0, T: 40 
18) Pour from 5L jug  into 3L jug 
5L: 2, 3L: 3, T: 40 
19) Pour from 5L jug into tank
5L: 0, 3L: 0, T: 42 
Volume measured out in 9 turns 

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

द्वारा एक सभ्य स्कोर सुधार किया गया

  • सीटीई की पहली पंक्ति में एक अनावश्यक +5 को नष्ट करना, और जहां आवश्यक हो, वहां खंड
  • महंगा तालिकाओं को बचाने, मूल्यवान तालिकाओं को इन-लाइनिंग करता है
  • इस समय विंडोज डबल-बाइट CRLFs को यूनिक्स शैली में बदलना याद है।

+1 बहादुरी के लिए, दोस्त ... बहुत प्रभावशाली और एमएस एसक्यूएल फिडेल लिंक के लिए धन्यवाद!
वैलीवेस्ट

1
हाहा, धन्यवाद आदमी! मैं वास्तव में यह विश्वास करता था कि जब मैं शुरू करूंगा और पुनरावर्ती कोर क्वेरी कर सकता था तो यह एक योग्य हो सकता है। लेकिन यहां तक ​​कि व्यापक स्ट्रिंग गोल्फ के साथ, सभी आवश्यक पाठ जोड़ने की क्रिया ने मेरा अंतिम समाधान बर्बाद कर दिया। :)
जोनाथन वान मैट्रे

अगर मैं एक "सबसे रचनात्मक" इनाम कर सकता था, तो आप इसे प्राप्त करेंगे ...
वैलेस्ट

मुझे LOL बनाने के लिए +1। T-SQL निश्चित रूप से आपके कोड-गोल्फ बैग में ले जाने के लिए एक अजीब क्लब है।
कॉमिन्टेन

5

जावास्क्रिप्ट: 481

गोल्फ में पहला प्रयास, सलाह की सराहना की

n=["3L jug","5L jug","tank"];l=[0,0,0];t=[3,5,0];h=0;c=console;function e(d){l[d]=t[d];c.log(++h+") Fill "+n[d]);k()}function m(d,g){s=l[d];f=l[g];b=s+f>t[g];l[g]=b?t[g]:f+s;l[d]=b?s-(t[g]-f):0;c.log(++h+") Pour from "+n[d]+" into "+n[g]);k()}function k(){c.log("5L: "+l[1]+", 3L: "+l[0]+", T: "+l[2])}a=prompt();for(t[2]=a;4<a;)e(1),m(1,2),a-=5;2<a&&(e(0),m(0,2),a-=3);1<a&&(e(1),m(1,0),m(1,2),a=0);0<a&&(e(0),m(0,1),e(0),m(0,1),m(0,2));c.log("Volume measured out in "+h+" turns")

यह कुछ नंबरों के साथ गड़बड़ करता है क्योंकि यह जांच नहीं करता है कि 3 या 5 डालना बेहतर है, उदाहरण: 9 6 के बजाय 9 मोड़ देता है, मैं इसे बाद में ठीक कर सकता हूं

इसे कंसीलर में पेस्ट करें

553 से 481 तक @WallyWest के लिए धन्यवाद


1
आप कोशिश कर सकते हैं: n=["3L jug","5L jug","tank"];l=[0,0,0];t=[3,5,0];h=0;c=console;function e(d){l[d]=t[d];c.log(++h+") Fill "+n[d]);k()}function m(d,g){s=l[d];f=l[g];b=s+f>t[g];l[g]=b?t[g]:f+s;l[d]=b?s-(t[g]-f):0;c.log(++h+") Pour from "+n[d]+" into "+n[g]);k()}function k(){c.log("5L: "+l[1]+", 3L: "+l[0]+", T: "+l[2])}a=prompt();for(t[2]=a;4<a;)e(1),m(1,2),a-=5;2<a&&(e(0),m(0,2),a-=3);1<a&&(e(1),m(1,0),m(1,2),a=0);0<a&&(e(0),m(0,1),e(0),m(0,1),m(0,2));c.log("Volume measured out in "+h+" turns") 481 वर्णों के लिए ...
WallyWest

@WallyWest धन्यवाद, के बजाय तार्किक ऑपरेटर्स का उपयोग कर के बारे में नहीं सोचा था ifरों
सैम

3

जावा, 610

class X{int n,c=0,t=0;public void static main(String[]a){n=Integer.parseInt(a[0]);String s,b,f,k,m,u;b="5L";s="3L";k="tank";u="Fill %s jug\n5L: %d, 3L: %d, T: %d";m="\nPour from %s jug into %s\n5L: %d, 3L: %d, T: %d";f=u+m;for(;n>4;)z(f,2,5,b,5,0,t,b,k,0,0,t+=5);while(n!=0){if(n==1)z(f+f+m,5,1,s,0,3,t,s,b,3,0,t,s,3,3,t,s,b,5,1,t,s,k,5,0,t+1);if(n==3)z(f,2,3,s,0,3,t,s,k,0,0,t+3);z(f+m,3,2,b,5,0,t,b,s,2,3,t,b,k,0,3,t+=2);if(n==2)z("Empty 3L jug\n5L: 0, 3L: 0,T: %d",1,0,t)}z("Volume measured out in %d turns",0,0,c)}void z(String s,int o,int w,Object...a){c+=o;n-=w;System.out.println(String.format(s,a))}}

मैंने सुमेध का हल निकाला और उसे गोल्फ दिया। मैं इसे टिप्पणियों में रखना चाहता था, लेकिन मेरी प्रतिष्ठा पर्याप्त नहीं है :( यह 40% कम है, मुझे लगता है कि इसे कम से कम साझा किया जाना चाहिए। अभी भी पहले से बहुत दूर है ...

यहाँ अपुष्ट है:

    class X{
    int n,c=0,t=0;
    public void static main(String[] a){
        n=Integer.parseInt(a[0]);
        String s,b,f,k,m,u;
        b="5L";
        s="3L";
        k="tank";
        u="Fill %s jug\n5L: %d, 3L: %d, T: %d";
        m="\nPour from %s jug into %s\n5L: %d, 3L: %d, T: %d";
        f=u+m;
        for(;n>4;)z(f,2,5,b,5,0,t,b,k,0,0,t+=5);
        while(n!=0)
        {
            if(n==1)z(f+f+m,5,1,s,0,3,t,s,b,3,0,t,s,3,3,t,s,b,5,1,t,s,k,5,0,t+1);
            if(n==3)z(f,2,3,s,0,3,t,s,k,0,0,t+3); 
            z(f+m,3,2,b,5,0,t,b,s,2,3,t,b,k,0,3,t+=2);
            if(n==2)z("Empty 3L jug\n5L: 0, 3L: 0,T: %d",1,0,t);
        }
        z("Volume measured out in %d turns",0,0,c);
    }
    void z(String s,int o, int w,Object... a){
        c+=o;
        n-=w;
        System.out.println(String.format(s,a));
    }
}

NB: यह केवल पहले रन पर काम करता है। इसे फिर से करें और परिणाम गलत होगा (वैश्विक परिवर्तन के कारण)।

निम्नलिखित संस्करण सुरक्षित है, लेकिन हम 2 चर खो देते हैं, 610 से 612 तक जा रहे हैं:

    class X{
    int n,c,t;
    public void static main(String[] a){
        n=Integer.parseInt(a[0]);
        String s,b,f,k,m,u;
        t=c=0;
        b="5L";
        s="3L";
        k="tank";
        u="Fill %s jug\n5L: %d, 3L: %d, T: %d";
        m="\nPour from %s jug into %s\n5L: %d, 3L: %d, T: %d";
        f=u+m;
        for(;n>4;)z(f,2,5,b,5,0,t,b,k,0,0,t+=5);
        while(n!=0)
        {
            if(n==1)z(f+f+m,5,1,s,0,3,t,s,b,3,0,t,s,3,3,t,s,b,5,1,t,s,k,5,0,t+1);
            if(n==3)z(f,2,3,s,0,3,t,s,k,0,0,t+3); 
            z(f+m,3,2,b,5,0,t,b,s,2,3,t,b,k,0,3,t+=2);
            if(n==2)z("Empty 3L jug\n5L: 0, 3L: 0,T: %d",1,0,t);
        }
        z("Volume measured out in %d turns",0,0,c);
    }
    void z(String s,int o, int w,Object... a){
        c+=o;
        n-=w;
        System.out.println(String.format(s,a));
    }
}

N = 69 के लिए नमूना आउटपुट:

Fill 5L jug
5L: 5, 3L: 0, T: 0
Pour from 5L jug into tank
5L: 0, 3L: 0, T: 5
Fill 5L jug
5L: 5, 3L: 0, T: 5
Pour from 5L jug into tank
5L: 0, 3L: 0, T: 10
Fill 5L jug
5L: 5, 3L: 0, T: 10
Pour from 5L jug into tank
5L: 0, 3L: 0, T: 15
Fill 5L jug
5L: 5, 3L: 0, T: 15
Pour from 5L jug into tank
5L: 0, 3L: 0, T: 20
Fill 5L jug
5L: 5, 3L: 0, T: 20
Pour from 5L jug into tank
5L: 0, 3L: 0, T: 25
Fill 5L jug
5L: 5, 3L: 0, T: 25
Pour from 5L jug into tank
5L: 0, 3L: 0, T: 30
Fill 5L jug
5L: 5, 3L: 0, T: 30
Pour from 5L jug into tank
5L: 0, 3L: 0, T: 35
Fill 5L jug
5L: 5, 3L: 0, T: 35
Pour from 5L jug into tank
5L: 0, 3L: 0, T: 40
Fill 5L jug
5L: 5, 3L: 0, T: 40
Pour from 5L jug into tank
5L: 0, 3L: 0, T: 45
Fill 5L jug
5L: 5, 3L: 0, T: 45
Pour from 5L jug into tank
5L: 0, 3L: 0, T: 50
Fill 5L jug
5L: 5, 3L: 0, T: 50
Pour from 5L jug into tank
5L: 0, 3L: 0, T: 55
Fill 5L jug
5L: 5, 3L: 0, T: 55
Pour from 5L jug into tank
5L: 0, 3L: 0, T: 60
Fill 5L jug
5L: 5, 3L: 0, T: 60
Pour from 5L jug into tank
5L: 0, 3L: 0, T: 65
Fill 5L jug
5L: 5, 3L: 0, T: 65
Pour from 5L jug into 3L
5L: 2, 3L: 3, T: 65
Pour from 5L jug into tank
5L: 0, 3L: 3, T: 67
Empty 3L jug
5L: 0, 3L: 0,T: 67
Fill 5L jug
5L: 5, 3L: 0, T: 67
Pour from 5L jug into 3L
5L: 2, 3L: 3, T: 67
Pour from 5L jug into tank
5L: 0, 3L: 3, T: 69
Volume measured out in 33 turns

2

जावा: 984

यहाँ कोड है

class X{public static void main(String[] s){int n=Integer.parseInt(s[0]);int t=0;int c=0;while(n>4){n-=5;System.out.println("Fill 5L jug\n5L: 5, 3L: 0, T: "+t+"\nPour from 5L jug into tank\n5L: 0, 3L: 0, T: "+(t+5));t+=5;c+=2;}while(n!=0){switch(n){case 1:System.out.println("Fill 3L jug\n5L: 0, 3L: 3, T: "+t+"\nPour from 3L jug into 5L jug\n5L: 3, 3L: 0, T: "+t+"\nFill 3L jug\n5L: 3, 3L: 3, T: "+t+"\nPour from 3L jug into 5L jug\n5L: 5, 3L: 1, T: "+t+"\nPour from 3L jug into tank\n5L: 5, 3L: 0, T: "+(t+1));n=0;c+=5;break;case 3:System.out.println("Fill 3L jug\n5L: 0, 3L: 3, T: "+t+"\nPour from 3L jug into tank\n5L: 0, 3L: 0, T: "+(t+3));n=0;c+=2;break;default:System.out.println("Fill 5L jug\n5L: 5, 3L: 0, T: "+t+"\nPour from 5L jug into 3L jug\n5L: 2, 3L: 3, T: "+t+"\nPour from 5L jug into tank\n5L: 0, 3L: 0, T: "+(t+2));n-=2;c+=3;t+=2;if(n==2){System.out.println("Empty 3L jug\n5L: 0, 3L: 0,T: "+t);c++;}break;}}System.out.println("Volume measured out in "+c+" turns");}}

इनपुट कमांड लाइन से है। उदाहरण के लिए: जावा एक्स 4


मैं कहीं और टिप्पणी नहीं कर सकता, इसलिए मैं यहां टिप्पणी कर रहा हूं। @ लेगो स्ट्रोमट्रोप्र, एक वैकल्पिक इष्टतम समाधान है, जहां 4 एल शेष है, आप 2 एल (3 चरणों) के लिए ऐसा ही कर सकते हैं, फिर खाली 3 एल गुड़, और फिर शेष 2 एल के लिए दोहराएं, इस प्रकार इसे 7 चरणों में पूरा करें ...। जो आपके समाधान के लिए समान है जहाँ 4L को विभाजित किया गया है: 3L टैंक में (2 चरण) और शेष 1L के लिए 5 चरण विधि।
सुमेध

@ क्रोन, क्या आपका कोड N के मूल्यों के लिए काम करता है, जहां N% 5 1 या 4 है? मुझे माणिक समझ में नहीं आता, यही कारण है कि मैं खुद इसका परीक्षण नहीं कर सका ...
सुमेध

उदाहरण के लिए, N = 11 पर यहां एक नज़र होनी चाहिए: ideone.com/3ZDuOS आप टॉप-लेफ्ट में एडिट को हिट कर सकते हैं और STDIN को दूसरे मान में बदल सकते हैं यदि आप चेक करना चाहते हैं।
पॉल प्रेस्टिज

वाह, आपको मेरी तुलना में अधिक इष्टतम समाधान मिला है .... आप कैसे तय करते हैं कि 5 एल को रोकें और इसके बजाय 3 एल का उपयोग करें? मेरा मतलब है, यदि इनपुट 81 है, तो आप 5L का उपयोग करके 75L तक उठेंगे, और फिर 3L का उपयोग करेंगे। यदि IP 89 है, तो 5L का उपयोग 80L तक किया जाता है, और शेष 3L हैं।
सुमेध

कुछ वर्ण सहेजें main(String[]s), int n=Integer.parseInt(s[0]),t=0,c=0;, java.io.PrintStream q=System.out;। इसके अलावा, पहले whileको एक या दो वर्णों के रूप में लिखना संभव हो सकता है for। इसके अलावा, आपके Stringपुनरावृत्ति हैं, आप चर में दोहराव वाले भागों को स्टोर करने या केवल एक प्रीबॅब का उपयोग करके उन्हें बनाने वाले कार्यों को बनाने की कोशिश कर सकते हैं String
विक्टर स्टैफुसा

2

पायथन 2.7 - 437

सबसे छोटा कोड नहीं है, लेकिन मुझे लगता है कि यह इसे हल करने का सबसे इष्टतम तरीका है।

जैसा कि मैंने टिप्पणियों में कहा है, यह गणना करने का सबसे इष्टतम तरीका है:

  1. जितना संभव हो 5L के कई विखंडू लें - divmod(amount,5)। यह आपको शेष के रूप में 4,3,2,1 में से एक देगा।
  2. शेष से 3 (यदि संभव हो) ले लो।
  3. जो शेष के रूप में 1 या 2 छोड़ देता है। या तो समय से पहले जाना जा सकता है के लिए इष्टतम समाधान का उपयोग करें:

    1. 1 एल, 5 चरणों: 3 एल -> 5 एल, 3 एल -> 5 एल, 3 एल में 1 एल छोड़कर, 3 एल (1 एल पकड़े) -> टैंक
    2. 2 एल, 3 चरण: 5 एल -> 3 एल, 5 एल में 5 एल, 5 एल (2 एल पकड़े) -> टैंक

कोड:

j,T="%dL jug","tank"
A="\n5L: %d, 3L: %d, T: %d"
F,P="Fill "+j+A,"Pour from "+j+" into %s"+A
f,r=divmod(input(),5)
o,t=f*5,[]
for i in range(f):o+=[F%(5,5,0,5*i),P%(5,T,0,0,5*i+5)]
if r>2:o+=[F%(3,0,3,t),P%(3,T,0,0,t+3)];r-=3;t+=3
if r==2:o+=[F%(5,5,0,t),P%(5,j%3,2,3,t),P%(5,T,0,3,t+2)]
if r==1:o+=[F%(3,0,3,t),P%(3,j%5,3,0,t),F%(3,3,3,t),P%(3,j%5,5,1,t),P%(3,T,5,0,t+1)]
print"\n".join(o),'\n',"Volume measured out in %d turns"%len(o)

और 7 चरणों में 4L के लिए एक आउटपुट:

Fill 3L jug
5L: 0, 3L: 3, T: 0
Pour from 3L jug into tank
5L: 0, 3L: 0, T: 3
Fill 3L jug
5L: 0, 3L: 3, T: 3
Pour from 3L jug into 5L jug
5L: 3, 3L: 0, T: 3
Fill 3L jug
5L: 3, 3L: 3, T: 3
Pour from 3L jug into 5L jug
5L: 5, 3L: 1, T: 3
Pour from 3L jug into tank
5L: 5, 3L: 0, T: 4
Volume measured out in 7 turns

आप ओ को एक इंट असाइन कर रहे हैं और फिर एक सूची जोड़ने की कोशिश कर रहे हैं। मुझे लगता है कि आपको ओ, टी = [], एफ * ५ को लाइन ५ पर सौंपने का मतलब है
psion5mx

1
उन लोगों के लिए, सीमाएँ, और यदि कथन और आप इसे एक पंक्ति में 399 तक प्राप्त कर सकते हैं: j, T = "% dL jug", "टैंक"; A = "\ n5L:% d, 3L:% d, T :% d "; एफ, पी =" भरें "+ जे + ए," "+ जे +" से% + ​​"ए +; एफ, आर = डीमोड (इनपुट) (५); टी; ओ = एफ * में डालो। 5, []; ओ = [एफ% (5,5,0,5 * i), पी% (5, टी, 0,0,5 * मैं + 5)] * च + [एफ% (3,0, 3, टी), पी% (3, टी, 0,0, टी + 3)] * (r> 2) + [एफ% (5,5,0, टी), पी% (5, जे% 3, 2,3, टी), पी% (5, टी, 0.3, टी +2)] * (आर == 2) + [एफ% (3,0,3, टी), पी% (3, j % 5,3,0, टी), एफ% (3,3,3, टी), पी% (3, j% 5,5,1, टी), पी% (3, टी, 5,0, टी +1)] * ([1,4] में r), "\ n" .join (o), "\ nVolume% d में मापा जाता है"% len (o)
psion5mx

1
प्रभावशाली हेरफेर ... @ psion5mx मुझे नहीं लगा कि पायथन पर इस तरह की प्रोग्रामिंग संभव थी? कोई सीमा नहीं, पुनरावृत्ति या यदि कथन?
वैलेस्ट

सूचियों की शक्ति। किसी सूची को पूर्णांक द्वारा गुणा करने पर 'लूप्स' बदल जाता है। एक बूलियन द्वारा गुणा 'इफ्स' की जगह।
Psion5mx

इसके अलावा - मैं इसे एक सिंगल स्पेस (कोट्स के बाहर) पर लाने में कामयाब रहा, लेकिन किसी कैरेक्टर की कीमत पर सभी स्पेस को खत्म कर सकता है (r [1,4] में) (r% 5in [1,4] के साथ ) इस मामले में।
Psion5mx

2

स्मालटाक (स्मालटाक / एक्स), ५६ 5 560 ५१६

n में इनपुट:

    T:=j:=J:=c:=0.m:={'Pour from'.' into'.' 3L jug'.' 5L jug'.[j:=j+3.'Fill'].[J:=J+5.'Fill'].[t:=j.j:=0.''].[t:=J.J:=0.''].[r:=j min:5-J.j:=j-r.J:=J+r.''].[r:=J min:3-j.J:=J-r.j:=j+r.''].[T:=T+t.' into tank'].[c:=c+1.'\5L: %1 3L: %2 T: %3\'bindWith:J with:j with:T].['Volume measured out in %1 turns'bindWith:c]}.[n>=0]whileTrue:[s:=n.n:=0.(s caseOf:{0->[n:=-1.'<'].1->'42;02813;42;02813;062:;'.2->'53;03912;073:;'.3->'42;062:;'.4->[n:=1.'42;062:;']}otherwise:[n:=s-5.'53;073:;'])do:[:c|(m at:c-$/)value withCRs print]]

लड़का यह निश्चित रूप से सबसे अधिक मोटापे से ग्रस्त कार्यक्रम है जो मैंने कभी लिखा है ...

संपादित करें: कुछ अन्य स्मॉलटैक्स कार्यक्षेत्र चर को ऑटोडेक्लेर नहीं कर सकते हैं और आपको घोषणाओं को स्थगित करना होगा। इसके अलावा bindWith: अलग हो सकता है (विस्तार करें: '<p>')।

n = 17 के लिए नमूना उत्पादन:

Fill 5L jug 
5L: 5, 3L: 0, T: 0
Pour from 5L jug into tank
5L: 0, 3L: 0, T: 5
Fill 5L jug 
5L: 5, 3L: 0, T: 5
Pour from 5L jug into tank
5L: 0, 3L: 0, T: 10
Fill 5L jug 
5L: 5, 3L: 0, T: 10
Pour from 5L jug into tank
5L: 0, 3L: 0, T: 15
Fill 5L jug 
5L: 5, 3L: 0, T: 15
Pour from 5L jug into 3L jug 
5L: 2, 3L: 3, T: 15
Pour from 5L jug into tank
5L: 0, 3L: 3, T: 17
Volume measured out in 9 turns

2

C, 567 609

#define r printf
#define l r("5L: %d, 3L: %d, T: %d\n", a, b, T);
#define j(x,y,z,w) r("%d) "#x" %dL jug\n", i++, y),z=w,l
#define e j(Empty,3,b,0)
#define f j(Fill,5,a,5)
#define g j(Fill,3,b,3)
#define o(x,y,z,w) r("%d) Pour from %dL jug into "x"\n", i++, y,z),w;l
#define t(x,y) T+=x,o("tank",y,0,x=0)
#define p(x) o("%dL jug",5,3,(a-=x,b+=x))
int N,T,i;q(x){int a=0,b=0;switch(x){case 5:f t(a,5) break;case 3:g t(b,3) break;case 1:case 2:case 4:f if(x-2){e p(2)f p(1)if(x-4){e p(3)}}t(a,5)}N-=x;}main(){T=0,i=1,scanf("%d",&N);while(N>5)q((N-6)&&(N-9)?5:3);q(N);r("Volume measured out in %d turns",i-1);}

पिछला अमान्य संस्करण:

#define r printf
#define l r("5L: %d, 3L: %d, T: %d\n", a, b, T);
#define j(x,y,z,w) r("%d) "#x" %dL jug\n", i++, y),z=w,l
#define e j(Empty,3,b,0)
#define f j(Fill,5,a,5)
#define g j(Fill,3,b,3)
#define o(x,y,z,w) r("%d) Pour from %dL jug into "x"\n", i++, y,z),w;l
#define t o("tank",5,0,a=0)
#define p(x) o("%dL jug",5,3,(a-=x,b+=x))
int N,T,i;q(x){int a=0,b=0;switch(x){case 5:f t break;case 3:g t break;case 1:case 2:case 4:f if(x-2){e p(2)f p(1)if(x-4){e p(3)}}t}N-=x;}main(){T=0,i=1,scanf("%d",&N);while(N>5)q(5);q(N);r("Volume measured out in %d turns",i-1);}

और यहाँ कोड विकृत है:

#define r printf
#define l r("5L: %d, 3L: %d, T: %d\n", a, b, T);
#define j(x,y,z,w) r("%d) "#x" %dL jug\n", i++, y),z=w,l
#define e j(Empty,3,b,0)
#define f j(Fill,5,a,5)
#define g j(Fill,3,b,3)
#define o(x,y,z,w) r("%d) Pour from %dL jug into "x"\n", i++, y,z),w;l
#define t o("tank",5,0,a=0)
#define p(x) o("%dL jug",5,3,(a-=x,b+=x))
int N,T,i;
q(x)
{
    int a=0,b=0;
    switch(x)
    {
        case 5:
            f
            t 
            break;
        case 3:
            g
            t
            break;
        case 1:
        case 2:
        case 4:
            f
            if(x-2)
            {
                e
                p(2)
                f
                p(1)
                if(x-4)
                {
                    e
                    p(3)
                }
            }
            t
    }
    N-=x;
}
main()
{
    T=0,i=1,scanf("%d",&N);
    while(N&gt;
    5)q(5);
    q(N);
    r("Volume measured out in %d turns",i-1);
}

यह 9 के लिए इष्टतम समाधान नहीं देता है (8 मोड़, 6 होना चाहिए - 3 एल 3 बार भरें और खाली करें)।
कॉमिंटर

इसके अलावा 1 के इनपुट के लिए बिल्कुल भी काम नहीं करता है
कॉमिन्टेन

1 के लिए काम नहीं करता है? अफ़सोस ... लेकिन सराहनीय प्रयास ... :)
वैलीवेस्ट

हाँ, कुछ कीड़े हैं और समाधान इष्टतम नहीं है। लेकिन यह 8 चरणों में 1 L बनाता है ...
VX

युगल गोल्फ टिप्स - आप इंट एन, टी, आई की जगह 6 बाइट्स बचा सकते हैं; एन, टी, आई, ए, बी के साथ; और int a = 0, b = 0; a = b = 0;; आप अपने प्रिंटफ की परिभाषा को जोड़कर 3 बाइट्स प्राप्त करते हैं। मुझे लगता है कि सबसे बड़ा लाभ एक नेस्टर्ड टर्नरी के लिए स्विच स्टेटमेंट को कम करना होगा - हालांकि केस और ब्रेक स्टेटमेंट वास्तव में जोड़ते हैं।
कॉमिंटर

2

सी ( 480 465 बाइट्स)

#define P printf(
#define O(x) P"%d) Pour from %dL jug into "x"\n"
#define S P"5L: %d, 3L: %d, T: %d\n",F,H,g);}
F,H,s,g,x;l(j){P"%d) Fill %dL jug\n",++s,j);St(j,o,m){O("%dL jug"),++s,j,(j^5)?5:3);Se(j,i){O("tank"),++s,j);Smain(){scanf("%d",&x);while(x>4){x-=5;l(F=5);g+=5;e(5,F=0);}while(x>2){x-=3;l(H=3);g+=3;e(3,H=0);}(x^2)?(x^1)?0:(l(H=3),t(3,H=0,F=3),l(H=3),t(3,H=1,F=5),g++,e(3,H=0)):(l(F=5),t(5,F=2,H=3),g+=2,e(5,F=0));P"Volume measured out in %d turns",s);}

इष्टतम संस्करण (10 बाइट्स जोड़ता है)

#define P printf(
#define O(x) P"%d) Pour from %dL jug into "x"\n"
#define S P"5L: %d, 3L: %d, T: %d\n",F,H,g);}
F,H,s,g,x;l(j){P"%d) Fill %dL jug\n",++s,j);St(j,o,m){O("%dL jug"),++s,j,(j^5)?5:3);Se(j,i){O("tank"),++s,j);Smain(){scanf("%d",&x);while(x>4&&x^6&&x^9){x-=5;l(F=5);g+=5;e(5,F=0);}while(x>2){x-=3;l(H=3);g+=3;e(3,H=0);}(x^2)?(x^1)?0:(l(H=3),t(3,H=0,F=3),l(H=3),t(3,H=1,F=5),g++,e(3,H=0)):(l(F=5),t(5,F=2,H=3),g+=2,e(5,F=0));P"Volume measured out in %d turns",s);}

संभवतः यहाँ और अधिक गोल्फिंग किया जाना था - आउटपुट फ़ंक्शंस मुझे मार रहे थे। यह इष्टतम समाधान (कम से कम चरणों की संख्या) देना चाहिए। यहां अन्य कोड के समान, यह 5L के नीचे तक 5L गुड़ को भरता है और खाली करता है और फिर 3L jugs में बदल जाता है। यह 2 विशेष मामलों (6 और 9) के लिए परीक्षण करता है और अगर यह उन्हें 3 एल गुड़ में स्विच करता है। 1L और 2L प्राप्त करने के निर्देश हार्ड कोडित हैं।

अधिक पठनीय संस्करण:

#define P printf(
#define O(x) P"%d) Pour from %dL jug into "x"\n"
#define S P"5L: %d, 3L: %d, T: %d\n",F,H,g);}
F,H,s,g,x;
l(j)
{
    P"%d) Fill %dL jug\n",++s,j);S

t(j,o,m)
{
    O("%dL jug"),++s,j,(j^5)?5:3);S

e(j,i)
{
    O("tank"),++s,j);S

main()
{
    scanf("%d",&x);
    //while(x>4&&x^6&&x^9)     <--optimal version
    while(x>4)
    {
        x-=5;l(F=5);g+=5;e(5,F=0);
    }
    while(x>2)
    {
        x-=3;l(H=3);g+=3;e(3,H=0);
    }
    (x^2)?
        (x^1)?  
            0
             :
            (l(H=3),t(3,H=0,F=3),l(H=3),t(3,H=1,F=5),g++,e(3,H=0))
             :(l(F=5),t(5,F=2,H=3),g+=2,e(5,F=0));
    P"Volume measured out in %d turns",s);
}

संपादन:

  • हटाए गए 10 बाइट्स जिन्होंने ओपी के स्पष्टीकरण के आधार पर स्कोर किए गए संस्करण के लिए इष्टतम प्रदर्शन दिया।
  • फ़ंक्शन को परिभाषा में कनवर्ट करके 5 बाइट्स दाढ़ी।

N = 11 (इष्टतम संस्करण) के लिए टेस्ट आउटपुट:

11
1) Fill 5L jug
5L: 5, 3L: 0, T: 0
2) Pour from 5L jug into tank
5L: 0, 3L: 0, T: 5
3) Fill 3L jug
5L: 0, 3L: 3, T: 5
4) Pour from 3L jug into tank
5L: 0, 3L: 0, T: 8
5) Fill 3L jug
5L: 0, 3L: 3, T: 8
6) Pour from 3L jug into tank
5L: 0, 3L: 0, T: 11
Volume measured out in 6 turns

आप एक विशेष मामले के रूप में 11 की गिनती क्यों नहीं करते हैं? आप 14 के लिए क्या करते हैं? एक पाँच, तीन तेरह (8) दो पत्नियों को हराकर और अन्य चार लीटर (जो चार बारी में नहीं किया जा सकता) बनाने जा रहे हैं।
बिल वुडगेर

11 और 14 दोनों में विशेष मामले शामिल हैं। आपके द्वारा पहले 5L को घटाने के बाद, वे क्रमशः 6 और 9 छोड़ते हैं और इन्हें विशेष मामलों द्वारा नियंत्रित किया जाता है। 9 सबसे बड़ी संख्या है जो केवल 3L जग का उपयोग करके कम चरणों में किया जा सकता है । 14 का इनपुट 8 कदम समाधान देता है, 11 के लिए आउटपुट ऊपर है।
कॉमिंटर

2

टी-एसक्यूएल (2012): 794 689 580

@ जोनाथन-वान-मैटर के टी-एसक्यूएल उत्तर से प्रेरित होकर @ लेगो-स्ट्रोमट्रोप्र के एल्गोरिथ्म के साथ संयोजन में । मैं ऐसा करना चाहता था क्योंकि मैंने बीयर की 99 बोतलों को चुनौती दी थी।

मैंने OVERगणित / बूल कार्यों की प्राथमिकता में विंडो ( ) कार्यों को न्यूनतम रखने की कोशिश की ।

SQLFiddle यहाँ है

WITH n AS(SELECT 11 n UNION ALL SELECT n-IIF(n>4,5,3)FROM n WHERE n>2)SELECT n, a,LEN(a)L,i=IDENTITY(INT,1,1),'L jug'j INTO #t FROM n JOIN(VALUES(3303),(33900),(5550),(55900),(2550),(259323),(25903),(1303),(139530),(1333),(139551),(13950))x(a)ON RIGHT(LEFT(12335,n),1)=LEFT(a,1)ORDER BY n DESC SELECT LTRIM(i)+') '+REPLACE(IIF(L=4,'Fill ','Pour ')+RIGHT(a/100,L-3),9,j+' into ')+IIF(L=5,'tank',j)  +'
5L: '+LTRIM((A%100)/10)+', 3L: '+LTRIM(A%10)+', T: '+LTRIM(SUM(IIF(L=5,LEFT(a,1),0))OVER(ORDER BY i))FROM #t UNION SELECT 'Volume measured out in ' +LTRIM(MAX(i))+' turns'FROM #t

इनपुट: 11

1) Fill 5L jug
5L: 5, 3L: 0, T: 0
2) Pour from 5L jug into tank
5L: 0, 3L: 0, T: 5
3) Fill 5L jug
5L: 5, 3L: 0, T: 5
4) Pour from 5L jug into tank
5L: 0, 3L: 0, T: 10
5) Fill 3L jug
5L: 0, 3L: 3, T: 10
6) Pour from 3L jug into
5L jug 5L: 0, 3L: 3, T: 10
7) Fill 3L jug
5L: 3, 3L: 3, T: 10
8) Pour from 3L jug into 5L jug
5L: 5, 3L: 1, T: 10
9) Pour from 3L jug into tank
5L: 5, 3L: 0, T: 11
Volume measured out in 9 turns

मानव पठनीय:

WITH n AS(
  SELECT 11 n
    UNION ALL
  SELECT n-IIF(n>4,5,3)
  FROM n
  WHERE n>2
)
SELECT n, a,LEN(a) L, i = IDENTITY(INT,1,1), 'L jug'j
INTO #t
FROM n
JOIN(VALUES
     (3303),(33900),
     (5550),(55900),
     (2550),(259323),(25903),
     (1303),(139530),(1333),(139551),(13950)
    )x(a)
ON RIGHT(LEFT(12335,n),1) = LEFT(a,1)
ORDER BY n DESC

 SELECT LTRIM(i)+') '
  + REPLACE(IIF(L=4,'Fill ','Pour ')
  + RIGHT(a/100,L-3),9,j+' into ')+IIF(L=5,'tank',j)
  +'
5L: ' + LTRIM((A%100)/10) + ', 3L: ' + LTRIM(A%10) + ', T: '
  + LTRIM(SUM(IIF(L=5,LEFT(a,1),0))OVER(ORDER BY i)) FROM #t
UNION ALL
 SELECT 'Volume measured out in ' +LTRIM(MAX(i))+' turns'FROM #t
 DROP TABLE #t

क्या आपके पास कुछ नमूना आउटपुट है?
बिल वुडनर

@BillWoodger ने input = 8
आराम से

धन्यवाद। 8 काफी आसान है। 11 में से एक कोड को एक अच्छा खिंचाव देता है :-) मैं उत्थान कर रहा हूं, इसलिए वापस न आएं और मुझे बताएं कि यह काम नहीं करता है।
बिल वूगर

@ धन्यवाद। में बदल गयाinput = 11
आराम से

@comfortablydrei टी-एसक्यूएल का उपयोग करके कमाल का सामान ... जोनाथन की पुस्तक से एक पृष्ठ लेना ...
वैलीवेस्ट

1

पायथन 3 (417 वर्ण)

P=print
D=divmod
N=['3L jug','5L jug','tank',0]
M=999
R=[0,0,0,M]
F=[3,5,M,M]
def o(a,b):k=a==3;P(['Pour from %s into %s','Empty %s','Fill %s'][k*2+(b==3)]%[(N[a],N[b]),(N[b])][k]);d=min(R[a],F[b]-R[b]);R[a]-=d;R[b]+=d;P('5L:',R[1],'3L:',R[0],'T:',R[2]);N[3]+=1
k,r=D(int(input()),5)
for i in'0'*k:o(3,1);o(1,2)
for x in['','c1c12','d46','c2','d434d46'][r]:o(*D(int(x,16),4))
P('Volume measured out in',N[3],'turns')

व्याख्या की

ध्यान दें कि हमारे पास 4 ऑब्जेक्ट्स हैं, अर्थात्, 3 एल जग, 5 एल जग, टैंक और फाउटेन। केवल संचालन हम कर सकते हैं वस्तु से पानी ले जाने के लिए है aवस्तु के लिएbo(a, b)मेरे कोड में यह क्या कार्य करता है, यह पानी को स्थानांतरित करता है और इसे प्रिंट करता है और गिनती करता रहता है।

ट्रिक्स

  • N=['3L jug','5L jug','tank',0]। यहां मुझे बचने के लिए अंतिम तत्व की आवश्यकता है IndexError। इसके अलावा, इसका उपयोग वैश्विक गिनती चर के रूप में किया जा सकता है, बिना विस्तार केglobal कीवर्ड के। उदाहरण के लिए,N[3] += 1

  • 0 <= a < 4, 0 <= b < 4फ़ंक्शन के बाद से o(a, b), हम (a, b)एक हेक्स अंक का उपयोग करके सांकेतिक शब्दों में बदलना कर सकते हैं (a << 2) | b, और इसका उपयोग करके डीकोड कर सकते हैं divmod(x, 4)। इस चाल के साथ, सभी 5 समाधान ( reminder=0, 1, 2, 3, 4), सरणी में एन्कोड किए जा सकते हैं ['','c1c12','d46','c2','d434d46'], जो मूल रूप से थोड़ा छोटा है:

    A=[ (), ((3,0),(0,1),(3,0),(0,1),(0,2)), ((3,1),(1,0),(1,2)), ((3,0),(0,2)), ((3,1),(1,0),(0,3),(1,0),(3,1),(1,0),(1,2)) ]

नमूना उत्पादन (n = 17)

17
Fill 5L jug
5L: 5 3L: 0 T: 0
Pour from 5L jug into tank
5L: 0 3L: 0 T: 5
Fill 5L jug
5L: 5 3L: 0 T: 5
Pour from 5L jug into tank
5L: 0 3L: 0 T: 10
Fill 5L jug
5L: 5 3L: 0 T: 10
Pour from 5L jug into tank
5L: 0 3L: 0 T: 15
Fill 5L jug
5L: 5 3L: 0 T: 15
Pour from 5L jug into 3L jug
5L: 2 3L: 3 T: 15
Pour from 5L jug into tank
5L: 0 3L: 3 T: 17
Volume measured out in 9 turns

1

COBOL (IBM Enterprise COBOL) 72 अक्षरों की 192 पंक्तियाँ

यह प्रश्न के लिए अवधारणा का एक प्रमाण है, और गोल्फ-कॉबोल के लिए एक की शुरुआत :-)

सवाल तेज के लिए पूछता है। इसलिए, समानता को लागू करें। यहां तक ​​कि एक व्यक्ति एक ही समय में एक 3L गुड़ और एक 5L गुड़ भर सकता है।

बस इनपुट को आठ से विभाजित करें, शेष भी छोड़ दें। कुछ जल्दी 5L / 3L करें जो आठ बार बिल्कुल फिट बैठता है, तो सात लीटर शेष के माध्यम से निपटें।

शेष का सबसे दिलचस्प चार लीटर के लिए है। इसे एक लीटर प्लस थ्री लीटर के रूप में करने से बहुत कम पानी चारों ओर खिंचता है, अन्य संभावनाओं के लिए केवल 18 लीटर बनाम 23।

कोड (काम)

   ID DIVISION
   PROGRAM-ID
   DATA DIVISION
   WORKING-STORAGE SECTION
   1.
   88 g1 VALUE ' '.
   2  PIC X
   88 H VALUE 'F'.
   88 I VALUE 'E'.
   88 J VALUE 'T'.
   2 PIC X
   88 K VALUE 'F'.
   88 L VALUE 'E'.
   88 M VALUE 'T'.
   1 R
   2 A1 PIC 999
   2 B PIC 99
   2 C PIC 9
   1 E
   2 e2 PIC X(120) VALUE "  ) Fill both jugs"
   2 e3 PIC X(120)
   88 O VALUE "5L: 0, 3L: 0, T: 000".
   2 e4 PIC X(120) VALUE "  ) Empty both jugs"
   2 e5 PIC X(120)
   2 e1 occurs 32 depending on p pic x(240)
   2 e6 pic x(99)
   1 F PIC 999 VALUE 0
   1 P PIC 99 VALUE 0
   1 P1 PIC 99
   PROCEDURE DIVISION
   ACCEPT A1
   DIVIDE A1 BY 8 GIVING B REMAINDER C
   set o to true
   move e3 to e5
   move 5 to e3(5:1)
   move 3 to e3(12:1)
   PERFORM D1 B TIMES
   EVALUATE C
   WHEN 1
   MOVE ZERO TO R
   SET K TO TRUE
   PERFORM N
   SET M TO TRUE
   PERFORM N
   SET K TO TRUE
   PERFORM N
   SET M TO TRUE
   PERFORM N
   SET L TO TRUE
   PERFORM N
   WHEN 2
   MOVE ZERO TO R
   SET H TO TRUE
   PERFORM N
   SET J TO TRUE
   PERFORM N
   SET I TO TRUE
   PERFORM N
   WHEN 3
   MOVE ZERO TO R
   SET K TO TRUE
   PERFORM N
   SET L TO TRUE
   PERFORM N
   WHEN 4
   MOVE ZERO TO R
   SET K TO TRUE
   PERFORM N
   SET M TO TRUE
   PERFORM N
   SET K TO TRUE
   PERFORM N
   SET M TO TRUE
   PERFORM N
   SET L TO TRUE
   PERFORM N
   SET K TO TRUE
   PERFORM N
   SET L TO TRUE
   PERFORM N
   WHEN 5
   MOVE ZERO TO R
   SET H TO TRUE
   PERFORM N
   SET I TO TRUE
   PERFORM N
   WHEN 6
   MOVE ZERO TO R
   SET K TO TRUE
   PERFORM N
   SET L TO TRUE
   PERFORM N
   SET K TO TRUE
   PERFORM N
   SET L TO TRUE
   PERFORM N
   WHEN 7
   MOVE ZERO TO R
   SET H TO TRUE
   PERFORM N
   SET I TO TRUE
   PERFORM N
   SET H TO TRUE
   PERFORM N
   SET J TO TRUE
   PERFORM N
   SET I TO TRUE
   PERFORM N
   END-EVALUATE
   string "Volume measured out in " delimited size P " turns"
   delimited size into e6
   if  e6(24:1) = 0
   move e6(25:) to e6 (24:)
   end-if
   move p to p1
   perform d2 p times
   DISPLAY E(481:)
   GOBACK
   D1
   ADD 1 TO P
   MOVE P TO E(1:2)
   move e2 to e1(p)
   move e3 to e1(p)(121:)
   ADD 1 TO P
   MOVE P TO E(241:2)
   ADD 8 TO F
   MOVE F TO E(378:3)
   move e4 to e1(p)
   move e5 to e1(p)(121:)
   MOVE F TO E(138:3)
   N
   ADD 1 TO P
   SET O TO TRUE
   EVALUATE TRUE
   WHEN K

   MOVE 3 TO B
   string p delimited size ") Fill 3L jug" delimited by size
   into e1(p)
   WHEN M
   COMPUTE C = C + B
   IF  C > 5
   COMPUTE B = C - 5
   MOVE 5 TO C
   ELSE
   MOVE 0 TO B
   END-IF
   string  P delimited size ") Pour from 3L jug into 5L jug"
   delimited size into e1(p)
   WHEN L
   ADD B TO F
   MOVE 0 TO B
   string  P delimited size ") Empty 3L jug into tank"
   delimited size into e1(p)
   END-EVALUATE
   EVALUATE TRUE
   WHEN H
   MOVE 5 TO C
   string  P delimited size ") Fill 5L jug"
   delimited size into e1(p)
   WHEN J
   COMPUTE B = C + B
   IF  B > 3
   COMPUTE C = B - 3
   MOVE 3 TO B
   ELSE
   MOVE 0 TO C
   END-IF
   string  P delimited size ") Pour from 5L jug into 3L jug"
   delimited size into e1(p)
   WHEN I
   ADD C TO F
   MOVE 0 TO C
   string  P delimited size ") Empty 5L jug into tank"
   delimited size into e1(p)
   END-EVALUATE
   string  "5L: " delimited size
       C delimited size ", 3L: " delimited size B(2:)
   ", T: " delimited size F delimited size
   into e1(p)(121:)
   SET g1 TO TRUE
   d2
   perform d3 2 times
   if  e1(p1)(1:1) = 0
   move e1(p1)(2:) to e1(p1)(1:120)
   end-if
   subtract 1 from p1
   d3
   if  e1(p1)(138:1) = 0
   move e1(p1)(139:) to e1(p1)(138:)
   end-if

यह गलत स्थान पर शुरू होने वाले कोड के लिए नैदानिक ​​संदेशों का एक पूर्ण शेड-लोड प्राप्त करता है और आवश्यक पूर्ण-स्टॉप की कमी करता है।

डायग्नोस्टिक्स में से कोई भी ऑब्जेक्ट कोड पर कोई प्रभाव नहीं दिखाता है। तो, इसके बावजूद RC = 8 का पर्दाफाश होने के बावजूद मुझे पता है कि ऑब्जेक्ट ओके होगा, इसलिए इसे लिंक किया और इसे चलाया।

यहां एक से आठ लीटर के लिए आउटपुट हैं। उसके बाद, सभी परिणामों को अंतर्ज्ञान किया जा सकता है। 17 और 100 को समानता के उदाहरण के रूप में शामिल किया गया है।

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

नमूना उत्पादन:

1) Fill 3L jug                 
5L: 0, 3L: 3, T: 0             
2) Pour from 3L jug into 5L jug
5L: 3, 3L: 0, T: 0             
3) Fill 3L jug                 
5L: 3, 3L: 3, T: 0             
4) Pour from 3L jug into 5L jug
5L: 5, 3L: 1, T: 0             
5) Empty 3L jug into tank      
5L: 5, 3L: 0, T: 1             
Volume measured out in 5 turns 

1) Fill 5L jug                 
5L: 5, 3L: 0, T: 0             
2) Pour from 5L jug into 3L jug
5L: 2, 3L: 3, T: 0             
3) Empty 5L jug into tank      
5L: 0, 3L: 3, T: 2             
Volume measured out in 3 turns

1) Fill 3L jug                 
5L: 0, 3L: 3, T: 0             
2) Empty 3L jug into tank      
5L: 0, 3L: 0, T: 3             
Volume measured out in 2 turns 

1) Fill 3L jug                 
5L: 0, 3L: 3, T: 0             
2) Pour from 3L jug into 5L jug
5L: 3, 3L: 0, T: 0             
3) Fill 3L jug                 
5L: 3, 3L: 3, T: 0             
4) Pour from 3L jug into 5L jug
5L: 5, 3L: 1, T: 0             
5) Empty 3L jug into tank      
5L: 5, 3L: 0, T: 1             
6) Fill 3L jug                 
5L: 5, 3L: 3, T: 1             
7) Empty 3L jug into tank      
5L: 5, 3L: 0, T: 4             
Volume measured out in 7 turns 

1) Fill 5L jug                
5L: 5, 3L: 0, T: 0            
2) Empty 5L jug into tank     
5L: 0, 3L: 0, T: 5            
Volume measured out in 2 turns

1) Fill 3L jug                 
5L: 0, 3L: 3, T: 0             
2) Empty 3L jug into tank      
5L: 0, 3L: 0, T: 3             
3) Fill 3L jug                 
5L: 0, 3L: 3, T: 3             
4) Empty 3L jug into tank      
5L: 0, 3L: 0, T: 6             
Volume measured out in 4 turns 

1) Fill 5L jug                  
5L: 5, 3L: 0, T: 0              
2) Empty 5L jug into tank       
5L: 0, 3L: 0, T: 5              
3) Fill 5L jug                  
5L: 5, 3L: 0, T: 5              
4) Pour from 5L jug into 3L jug 
5L: 2, 3L: 3, T: 5              
5) Empty 5L jug into tank       
5L: 0, 3L: 3, T: 7              
Volume measured out in 5 turns 



1) Fill both jugs               
5L: 5, 3L: 3, T: 0              
2) Empty both jugs              
5L: 0, 3L: 0, T: 8              
Volume measured out in 2 turns  

1) Fill both jugs               
5L: 5, 3L: 3, T: 0              
2) Empty both jugs              
5L: 0, 3L: 0, T: 8              
3) Fill both jugs               
5L: 5, 3L: 3, T: 8              
4) Empty both jugs              
5L: 0, 3L: 0, T: 16             
5) Fill 3L jug                  
5L: 0, 3L: 3, T: 16             
6) Pour from 3L jug into 5L jug 
5L: 3, 3L: 0, T: 16             
7) Fill 3L jug                  
5L: 3, 3L: 3, T: 16             
8) Pour from 3L jug into 5L jug 
5L: 5, 3L: 1, T: 16             
9) Empty 3L jug into tank       
5L: 5, 3L: 0, T: 17             
Volume measured out in 9 turns  



1) Fill both jugs  
5L: 5, 3L: 3, T: 0 
2) Empty both jugs 
5L: 0, 3L: 0, T: 8 
3) Fill both jugs  
5L: 5, 3L: 3, T: 8 
4) Empty both jugs 
5L: 0, 3L: 0, T: 16
5) Fill both jugs  
5L: 5, 3L: 3, T: 16
6) Empty both jugs 
5L: 0, 3L: 0, T: 24
7) Fill both jugs  
5L: 5, 3L: 3, T: 24
8) Empty both jugs 
5L: 0, 3L: 0, T: 32
9) Fill both jugs  
5L: 5, 3L: 3, T: 32
10) Empty both jugs
5L: 0, 3L: 0, T: 40
11) Fill both jugs 
5L: 5, 3L: 3, T: 40
12) Empty both jugs
5L: 0, 3L: 0, T: 48
13) Fill both jugs 
5L: 5, 3L: 3, T: 48
14) Empty both jugs
5L: 0, 3L: 0, T: 56
15) Fill both jugs 
5L: 5, 3L: 3, T: 56
16) Empty both jugs
5L: 0, 3L: 0, T: 64
17) Fill both jugs 
5L: 5, 3L: 3, T: 64
18) Empty both jugs
5L: 0, 3L: 0, T: 72
19) Fill both jugs               
5L: 5, 3L: 3, T: 72              
20) Empty both jugs              
5L: 0, 3L: 0, T: 80              
21) Fill both jugs               
5L: 5, 3L: 3, T: 80              
22) Empty both jugs              
5L: 0, 3L: 0, T: 88              
23) Fill both jugs               
5L: 5, 3L: 3, T: 88              
24) Empty both jugs              
5L: 0, 3L: 0, T: 96              
25) Fill 3L jug                  
5L: 0, 3L: 3, T: 96              
26) Pour from 3L jug into 5L jug 
5L: 3, 3L: 0, T: 96              
27) Fill 3L jug                  
5L: 3, 3L: 3, T: 96              
28) Pour from 3L jug into 5L jug 
5L: 5, 3L: 1, T: 96              
29) Empty 3L jug into tank       
5L: 5, 3L: 0, T: 97              
30) Fill 3L jug                  
5L: 5, 3L: 3, T: 97              
31) Empty 3L jug into tank       
5L: 5, 3L: 0, T: 100             
Volume measured out in 31 turns 

सराहनीय दृष्टिकोण, @ बेल्वूडगर; मैं हालांकि उपलब्ध निर्देशों के भीतर एक "दोनों गुड़ भरें" कमांड सेट नहीं किया ... winfderful काम, और सहारा के लिए) एक का उपयोग कर COBOL, ख) सबसे तेज विधि मार्ग के साथ जा रहा है ।
वैलीवेस्ट

1
@ वैलीवेस्ट थैंक्स। अगर मुझे लगता है कि व्यावसायिक कल्पना में सुधार किया जा सकता है, तो मैं हमेशा ऐसा करता हूं :-)। मुझे "फव्वारे में खाली" की ज़रूरत नहीं थी, इसलिए दो नए और दो का उपयोग नहीं किया गया - दोहरी विफलता!
बिल वुडगेर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.