अंक एक कालकोठरी खुदाई

Question

संपादित करें: मैं सवाल के अंत में बोनस पहेली के पहले सॉल्वर के लिए एक 100-प्रतिष्ठा इनाम देगा !

मैं इस सवाल का जवाब केवल तभी दूंगा जब जवाब प्रकट हो जाएगा क्योंकि इस इनाम की कोई समय सीमा नहीं है।

एक-अंकों के सकारात्मक पूर्णांक की गैर-घटती सूची को देखते हुए, आपको यह निर्धारित करना चाहिए कि अंक कैसे खोदेंगे।

███  ███  A dungeon with 5 blocks removed and a depth of 3.
███  ███
███ ████
████████

जमीन खोदने की शुरुआत से पहले स्तर है।

प्रत्येक अंक अपने नीचे से मिट्टी के ठीक एक ब्लॉक को हटा सकता है, लेकिन उसे कालकोठरी के बाहर से उस स्थिति तक पहुंचना होगा और इसके बाद ब्लॉक को हटाकर कालकोठरी को छोड़ना होगा। ऐसा करते समय कोई भी अंक किसी भी क्षैतिज कदम पर अपने संख्यात्मक मूल्य से अधिक नहीं उतर या चढ़ सकता है ।

अंक खुदाई के लिए निम्नलिखित रणनीति का उपयोग करते हैं:

• सबसे छोटे मान वाला अंक पहले खोदता है और उसके बाद अगला अंक हमेशा शेष अंकों से अगला सबसे छोटा मान होता है।
• पहला अंक किसी भी स्थिति में खुदाई कर सकता है। (सभी मैदान समान हैं।)
• निम्नलिखित अंक हमेशा सबसे पहले से शुरू किए गए स्तंभ पर खोदते हैं जहां वे जा सकते हैं और बाहर आ सकते हैं। यदि ऐसा कोई कॉलम मौजूद नहीं है, तो वे दाईं ओर एक नया कॉलम खोदना शुरू करते हैं।

उदाहरण के लिए अंक 1 1 1 2 3 3निम्नलिखित कालकोठरी खोदेंगे (चरण-दर-चरण विज़ुअलाइज़ेशन संख्याओं के साथ अंकन करते हैं कि किस तरह का अंक खोदता है:)

███1████    ███11███    ███11███    ███11███    ███11███    ███11███
████████    ████████    ███1████    ███1████    ███1████    ███13███
████████    ████████    ████████    ███2████    ███2████    ███2████
████████    ████████    ████████    ████████    ███3████    ███3████
████████    ████████    ████████    ████████    ████████    ████████

उदाहरण के लिए स्पष्टीकरण:

• दूसरे 1ही उपलब्ध स्तंभ से बाहर चढ़ाई नहीं कर सकता है अगर यह यह गहरा करने के लिए होता है 2दीप तो यह यह करने के लिए सही खोदता है।
• तीसरा 1सबसे बाएं कॉलम में एक 2-deep कॉलम बनाकर खुदाई कर सकता है क्योंकि यह 1-deep कॉलम में और फिर जमीनी स्तर तक जा सकता है।
• अगला 2और 3दोनों सबसे बाएं कॉलम में खुदाई कर सकते हैं।
• अंतिम 3बाएं कॉलम में नहीं खोदा जा सकता, लेकिन अगले एक में।

इनपुट

• कम से कम एक तत्व के साथ सकारात्मक एक-अंकीय पूर्णांक की गैर-घटती सूची।

उत्पादन

• एक एकल सकारात्मक पूर्णांक, निर्मित कालकोठरी की गहराई।

उदाहरण

इनपुट => आउटपुट (स्पष्टीकरण के रूप में बाएं से दाएं के कॉलम की गहराई के साथ जो आउटपुट का हिस्सा नहीं है)

[3]  =>  1
(column depths are [1])

[1, 1, 1, 2, 3, 3]  =>  4
(column depths are [4, 2])

[1, 1, 1, 1, 1, 1, 1, 1]  =>  3
(column depths are [3, 2, 2, 1])

[1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, 5, 5, 5, 5, 5, 5, 5, 5]  =>  11
(column depths are [11, 6, 2])

[1, 1, 1, 1, 1, 2, 2, 9, 9, 9]  =>  7
(column depths are [7, 2, 1])

[2, 2, 2, 2, 2, 5, 5, 5, 7, 7, 9]  =>  9
(column depths are [9, 2])

[1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5]  =>  10
(column depths are [10, 5])

[1, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 5, 5, 5, 5, 7, 7, 9]  =>  13
(column depths are [13, 5])

[1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9]  =>  13
(column depths are [13, 5])

[1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9]  =>  21
(column depths are [21, 12, 3])

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

बोनस पहेली

क्या आप यह साबित (या अस्वीकृत) कर सकते हैं कि "अंक खुदाई के लिए निम्नलिखित रणनीति का उपयोग करता है" में वर्णित रणनीति हमेशा दिए गए अंकों के लिए सबसे गहरी संभव काल कोठरी देती है?

Answer 1

पायथ, 21 बाइट्स

huXf>+H@GhT@GT0G1Qm0Q

इसे ऑनलाइन आज़माएं: एकल प्रदर्शन या टेस्ट सूट

स्पष्टीकरण:

                  m0Q   generate a list of zeros of length len(input)
                        This will simulate the current depths
 u               Qm0Q   reduce G, starting with G=[0,...,0], for H in input():
   f          0             find the first number T >= 0, which satisfies:
    >+H@GhT@GT                  H + G[T+1] > G[T]
  X            G1           increase the depth at this position by one
                            update G with this result
h                       print the first element in this list

Answer 2

जावा, 199

import java.util.*;a->{List<Integer>l=new ArrayList();l.add(0);int x,y,z=0;s:for(int i:a){for(x=0;x<z;x++)if((y=l.get(x))-l.get(x+1)<i){l.set(x,l.get(x)+1);continue s;}l.add(z++,1);}return l.get(0);}

विस्तारित, रन करने योग्य संस्करण

import java.util.*;
class DIGits {
    public static void main(String[] args) {
        java.util.function.Function<int[], Integer> f =
                a->{
                    List<Integer> l = new ArrayList();
                    l.add(0);
                    int x, y, z = 0;
                    s:
                    for (int i : a) {
                        for (x = 0; x < z; x++) {
                            if ((y = l.get(x)) - l.get(x + 1) < i) {
                                l.set(x, l.get(x) + 1);
                                continue s;
                            }
                        }
                        l.add(z++, 1);
                    }
                    return l.get(0);
                };
        System.out.println(f.apply(new int[]{1, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 5, 5, 5, 5, 7, 7, 9}));
    }
}