बाईं ओर चार कदम: वाइपर। दाईं ओर चार कदम: एक चट्टान। मर मत!


28

परिचय

एक पल के लिए मान लीजिए कि वाइपर और क्लिफ तीन के बजाय केवल दो कदम दूर हैं।

            o
           ---
Hsss!       |
 ';;' ___  /_\  ___  _
                      |

आप दुर्भाग्य से, एक दुखद यातना के बंदी हैं। आप चाहिए या तो बाएं हर मोड़ करने के लिए या सही करने के लिए एक कदम उठाना। यदि आप नहीं करते हैं, तो वे आपको तुरंत मार देते हैं। आपको पहले से अपने चरणों की योजना बनाने की अनुमति है, लेकिन एक बार जब आप अपना पहला कदम उठाते हैं, तो आप अपनी योजना को बदल नहीं सकते हैं। (और कोई डडलिंग भी नहीं; वे तुम्हें गोली मार देंगे।)

अचानक, एक उज्ज्वल विचार मन में आता है ...

आह! मैं सिर्फ वैकल्पिक कदम दाएं और बाएं कर सकता हूं! दाएं कदम, बाएं कदम, दाएं कदम, बाएं कदम, और इसी तरह ...

आह आह आह, इतनी जल्दी नहीं। जैसा मैंने कहा, यातना करने वाला दुखवादी होता है। उन्हें यह चुनने के लिए मिलता है कि क्या आप हर कदम, या हर दूसरे कदम, या हर तीसरे कदम, और इसी तरह। इसलिए यदि आप भोलेपन से सीक्वेंस चुनते हैं RLRLRL...तो वे आपको हर दूसरा कदम उठाने के लिए मजबूर कर सकते हैं, जो इसके साथ शुरू होता है LL। उह ओह! आप वाइपर द्वारा काट लिया गया है! कालापन तुम पर झपटता है और बाकी सब मिट जाता है ...।

वास्तव में नहीं, तुम अभी मरे नहीं हो। आपको अभी भी अपनी योजना के साथ आना होगा। कुछ मिनटों के बारे में सोचने के बाद, आपको एहसास होता है कि आप बर्बाद हैं। ऐसे चरणों की एक श्रृंखला की योजना बनाने का कोई तरीका नहीं है जो आपके अस्तित्व की गारंटी देगा। सबसे अच्छा आप के साथ आ सकते हैं RLLRLRRLLRR1 ग्यारह सुरक्षित कदम और अधिक नहीं। यदि बारहवाँ चरण है R, तो टॉर्चर आपको हर कदम उठाने देगा और फिर अंतिम तीन चरण आपको क्लिफ भेज देंगे। यदि बारहवाँ चरण है L, तो टॉर्चर आपको हर तीसरा कदम ( LRLL) देगा, जो आपको सही तरीके से वाइपर और उनके घातक काटने की स्थिति में डालता है।

आप Rबारहवें कदम के रूप में उठाते हैं, जब तक आपके निधन की देरी संभव है। आपके कानों में तेज़ हवा के साथ, आप खुद को आश्चर्यचकित करते हैं ...

अगर मेरे पास तीन कदम हैं तो क्या होगा?


बिगड़ने की चेतावनी!

तुम फिर भी मरोगे। जैसा कि यह पता चला है कि आपके पास चाहे कितने भी कदम हों, कुछ बिंदु ऐसे होंगे जहाँ आप चाहे कोई भी चुनाव कर लें, आपके सीढ़ीनुमा कदम का एक क्रम है जिसे आप अपने घातक भाग्य को पूरा करने के लिए उठा सकते हैं। 2 हालांकि, जब वाइपर और क्लिफ तीन कदम दूर होते हैं, तो आप कुल 1160 सुरक्षित कदम उठा सकते हैं और जब वे चार कदम दूर होते हैं, तो कम से कम 13,000 सुरक्षित कदम होते हैं! 3

चुनौती

एकल पूर्णांक को देखते हुए n < 13000, nसुरक्षित चरणों का एक क्रम आउटपुट होता है , यह मानते हुए कि चट्टान और वाइपर चार कदम दूर हैं।

नियम

  • एक पूर्ण कार्यक्रम या एक समारोह हो सकता है।
  • इनपुट STDIN या समकक्ष के माध्यम से या एक फ़ंक्शन तर्क के रूप में लिया जा सकता है।
  • आउटपुट होना आवश्यक है दो अलग-अलग पात्रों (हो सकता है जो +/-, R/L, 1/0, आदि)।
  • आउटपुट में कोई भी व्हाट्सएप मायने नहीं रखता है।
  • हार्ड-कोडिंग एक समाधान की अनुमति नहीं है। यह इस चुनौती को छोटा करेगा।
  • आपका कार्यक्रम (सिद्धांत रूप में) समय की एक सभ्य मात्रा में खत्म होना चाहिए। के रूप में, n=13000एक महीने की तरह लग सकता है, लेकिन यह एक हजार साल या उससे अधिक नहीं लेना चाहिए। वह है, कोई पाशविक बल नहीं। (खैर, कम से कम इससे बचने की कोशिश करें।)
  • जीवन बोनस:2000 सुरक्षित चरणों की एक श्रृंखला प्रदान करते हैं । यदि आप ऐसा करते हैं, तो Torturer आपके तप, दृढ़ता, और इस बात से प्रभावित होगा कि उन्होंने आपको जीवित किया है। यह एक बार (इस क्रम को एक द्विआधारी संख्या के रूप में मानें और सत्यापन के लिए दशमलव के बराबर प्रदान करें। इसका उद्देश्य उन उत्तरों को पुरस्कृत करना है जो उत्तर के रूप में जल्दी समाप्त कर देते हैं, बहुत लंबे समय तक लेने की अनुमति है।)
  • स्कोर: बाइट्स , जब तक आप बोनस के लिए अर्हता प्राप्त नहीं करते - 0.75 से गुणा करें

बना रहना!


1 इस समस्या और "समाधान" की एक अच्छी व्याख्या नंबरफाइल, जेम्स ग्रिम के सितारों में से एक ने अपने YouTube चैनल पर की है: https://www.youtube.com/watch?v=pFHsrCNtJu4

2 80 वर्षीय यह अनुमान, जिसे एर्दोस की विसंगति समस्या के रूप में जाना जाता है, टेरेंस ताओ द्वारा हाल ही में साबित किया गया था। इस बारे में क्वांटा पत्रिका पर एक बहुत अच्छा लेख यहां दिया गया है: https://www.quantamagazine.org/20151001-tao-erdos-discrepancy-problem/

3 स्रोत: बोरिस कोनव और अलेक्सी लिसिट्स द्वारा एर्दोस विसंगति अनुमान पर सैट हमला । यहां से पुन: प्राप्त http://arxiv.org/pdf/1402.2184v2.pdf


1
इसलिए, यदि मैं इसके लिए कोई समाधान करता हूं, तो n=13000क्या इसके पहले 2000 निर्देश बोनस जीतेंगे? व्यर्थ लगता है, तो आप शायद कुछ और मतलब था?
अनातोलीग

@anatolyg: सभी समाधानों को सैद्धांतिक रूप से n=13000एक वर्ष के भीतर, जैसे कि दस को संभालने में सक्षम होना चाहिए । क्या आप एक महीने के लिए इंतजार करने जा रहे हैं n=2000? शायद नहीं। और यदि आप करते हैं , तो आप वैसे भी बोनस के हकदार हैं।
एल'इंडिया स्ट्रैटन

जवाबों:


6

जावा, 915 * 0.75 = 686.25

import java.util.*;class E implements Comparable<E>{static
int n,m,t,u;byte[]a;int k=2,b,d;E(){a=new byte[5];a[1]=13;}E(E
x){a=Arrays.copyOf(x.a,n+1);k=x.k;d=x.d;b=x.b;}int
g(int x){return(a[x]+1)%3-1;}void s(int x,int y){a[x]=(byte)(a[x]/3*3+(y+3)%3);}void
S(int x,int y){a[x]=(byte)(a[x]%3+(y+3)*3);}E
w(int x){if(g(k)==-x)return null;E e=new E(this);e.s(k,x);e.S(e.k++,x);for(m=0;++m<k;)if(k%m<1){u=e.a[m]/3-3+x;if(u==(k<9?2:4)*x)return
null;e.S(m,u);if(u==3*x){e.b++;if(k+m<=n){if(e.g(k+m)==x)return
null;e.s(k+m,-x);}}}return e;}public int compareTo(E o){m=d-o.d+(b-o.b)/60+(o.k-k)/150;return
m==0?o.k-k:m;}public static void main(String[]a){n=Integer.valueOf(a[0]);Queue<E>q=new PriorityQueue<>();q.add(new
E());for(;;){E x=q.remove(),y;if(x.k>n){for(t=0;++t<x.k;)System.out.print((x.g(t)+1)/2);return;}t=x.g(x.k<9?1:x.k%9==0?x.k/9:x.k%9);y=x.w(t);if(y!=null)q.add(y);y=x.w(-t);if(y!=null){y.d++;q.add(y);}}}}

इनपुट को कमांड-लाइन तर्क के रूप में लिया जाता है।

यह लगभग सभी संभावनाओं का प्रयास करता है (केवल प्रतिबंध यह है कि पहले 8 चरणों को केवल -1..1 के भीतर जाना चाहिए), कदम से कदम रखते हुए, एक जादू वूडू अनुमानी का उपयोग करके कि किस तरह से पहले प्रयास करें।

यह मेरे (काफी तेज) कंप्यूटर पर 1 सेकंड के भीतर 2000 और यहां तक ​​कि 4000 को हल करता है। बड़ी संख्या के लिए अधिक रैम की आवश्यकता होती है; सबसे बड़ा इनपुट जो मैंने 8GB में हल किया है वह 5023 है और इसमें लगभग 30 सेकंड का समय लगा है।

बोनस के लिए आवश्यक के रूप में 2000 चरणों के लिए समाधान का दशमलव प्रतिनिधित्व:

67629177464446960798008264442022667063957880432486338092706841703491740570274032860458934082821213021464065304260003487277917407152662394728833698812373924467640518368465012204980858438160127647802572983143425507448999967241207186701518207195015015739598846687434709056793597015487555707466358473564611432637890414593517116857771284711814076853125419306285869381974622557155019992727242896503018802441210966188045211779436703341152749688824296759097963388158731237092792251164105828728858516951458791084595247591674731645830905744761534078963607725435881491831508342871545788662307953494333833994658998

बाइनरी में वापस कन्वर्ट करने के लिए CJamYb में इसे जोड़ें ।

हेयुरिस्टिक के बारे में: सबसे पहले, एक पैटर्न है जिसका मैं उपयोग कर रहा हूं: प्रत्येक 9 चरण पहले 9 को दोहराने की कोशिश करते हैं, हर (9 * x) वें चरण को छोड़कर, x'th चरण को दोहराने की कोशिश करता है। यह उस समाधान से प्रेरित है जिसे मैंने डाउनलोड किया और मेरे अजगर जवाब में इस्तेमाल किया (हार्डकोड)।

मैं पैटर्न से विचलित हुए समय की संख्या पर नज़र रख रहा हूं, और कई बार मुझे "बढ़त" (मरने से 1 कदम) तक भी मिला है। ह्यूरिस्टिक फ़ंक्शन मूल रूप से उन 2 नंबरों का एक भारित संयोजन और अब तक उठाए गए चरणों की संख्या है।

गति को सुधारने के लिए अनुमानी को आगे बढ़ाया जा सकता है, और इसमें यादृच्छिक कारक जोड़ने के भी कई तरीके हैं।
वास्तव में, मैंने अभी इस समस्या के संबंध में गुणक कार्यों के बारे में पढ़ा है, और ऐसा लगता है कि यह एक महत्वपूर्ण सुधार प्रदान कर सकता है (TODO: इसे बाद में लागू करें)।

असंबद्ध और टिप्पणी:

import java.util.*;

public class Erdos implements Comparable<Erdos> {
    static int n; // input (requested number of steps)
    static int m, t, u; // auxiliary variables

    byte[] a; // keeps each step and sum combined into 1 byte
    int k = 2; // number of steps + 1 (steps are 1-based)
    int edge; // number of times we got to an edge
    int diff; // number of differences from the expected pattern

    // start with one step
    Erdos() {
        a = new byte[5];
        set(1, 1);
        setSum(1, 1);
    }

    // copy constructor
    Erdos(Erdos x) {
        a = Arrays.copyOf(x.a, n + 1);
        k = x.k;
        diff = x.diff;
        edge = x.edge;
    }

    // get the x'th step (can be -1, 0 or 1)
    int get(int x) {
        return (a[x] + 1) % 3 - 1;
    }

    // set the x'th step
    void set(int x, int y) {
        a[x] = (byte) (a[x] / 3 * 3 + (y + 3) % 3);
    }

    // get the sum of every x'th step (should be within -3..3)
    int getSum(int x) {
        return a[x] / 3 - 3;
    }

    // set the sum of every x'th step
    void setSum(int x, int y) {
        a[x] = (byte) (a[x] % 3 + (y + 3) * 3);
    }

    // try to add a step with value x (1 or -1)
    Erdos grow(int x) {
        if (get(k) == -x) // predetermined step doesn't match
            return null;
        Erdos e = new Erdos(this);
        e.set(k, x);
        e.setSum(e.k++, x);
        for (m = 0; ++m < k;)
            if (k % m < 1) { // check all divisors of k
                u = e.getSum(m) + x; // updated sum
                if (u == (k < 9 ? 2 : 4) * x) // use limit 2 for the first 8 steps, 4 for the rest
                    return null; // dead
                e.setSum(m, u);
                if (u == 3 * x) { // we're at an edge
                    e.edge++;
                    if (k + m <= n) { // predetermine future step - should be going back
                        if (e.get(k + m) == x) // conflict
                            return null;
                        e.set(k + m, -x);
                    }
                }
            }
        return e;
    }

    public int compareTo(Erdos o) { // heuristic function
        m = diff - o.diff + (edge - o.edge) / 60 + (o.k - k) / 150;
        return m == 0 ? o.k - k : m;
    }

    public static void main(String[] a) {
        n = Integer.valueOf(a[0]);
        Queue<Erdos> q = new PriorityQueue<>();
        q.add(new Erdos());
        for (;;) {
            Erdos x = q.remove(), y;
            if (x.k > n) { // we made it
                for (t = 0; ++t < x.k;)
                    System.out.print((x.get(t) + 1) / 2);
                return;
            }
            t = x.get(x.k < 9 ? 1 : x.k % 9 == 0 ? x.k / 9 : x.k % 9); // next step based on the pattern
            y = x.grow(t);
            if (y != null)
                q.add(y);
            y = x.grow(-t);
            if (y != null) {
                y.diff++;
                q.add(y);
            }
        }
    }
}

"बाद में" एक वर्ष से अधिक इंतजार कर रहा है
कैलक्यूलेटरफनल

1

पायथन 2, 236 बाइट्स

n=input();r=len;u=[("",[0]*(n//4))]
while n>r(u[-1][0]):
 y,t=u.pop()
 for c in 0,1:
  s=t[:];u+=(y+"LR"[c],s),
  for i in range(r(s)):
   if-~r(y)//-~i*-~i==-~r(y):s[i]+=2*c-1;
   if abs(s[i])>3:u.pop();break;
print(u[-1][0])

यह काफी तेज है, एक जानवर-बल-ईश विधि के लिए, केवल कुछ सेकंड n = 223 के लिए ले रहा है, लेकिन n> = 224 के लिए अधिक लंबा है।

स्पष्टीकरण: स्ट्रिंग-सूची जोड़े (एस, यू) की एक सूची पर नज़र रखें, जहां सूची यू ऐसी है कि यू [i] स्ट्रिंग में हर ith कदम का पालन करने के बाद वर्तमान स्थिति है। सूची के प्रत्येक स्ट्रिंग के लिए, "L" या "R" को जोड़ने का प्रयास करें, फिर सूची में मौजूद मानों को बदल दें। (यानी यदि परिणामी स्ट्रिंग की लंबाई 10 है, तो 1 या 2 पदों से 1 घटाएं या घटाएं, आपके द्वारा चलाए गए निर्देशों के अनुसार)। यदि आप 3 या -3 से अधिक हैं तो नई जोड़ी को फेंक दें, अन्यथा इसे सूची में रखें। सबसे लंबे तार अंत में रखे जाते हैं। एक बार जब आप लंबाई n की एक स्ट्रिंग है, तो इसे वापस कर दें।


क्यों अजगर 2/3?
R

यह एक ही में काम करता है। क्या मुझे उनमें से एक को निर्दिष्ट करना चाहिए?
फ्रिकेटिव मेलन

शायद आपको करना चाहिए। मैं सिर्फ इसलिए कि मुझे नहीं पता था कि सोच रहा था //अजगर 2 में availible था
Rɪᴋᴇʀ

-2

पायथन 2, 729 बाइट्स

n=0
for x in"eJytVU2LwyAQPWzTvZjjspcsxFYTBdNuQSEF+///1jp+p5o0hYVSBl9nfOObNz1MlAgqzMcEEwQkDyIkFpDYCW0UnChbyZJiK2sfhDcYmu9hT0GdIPQvLduAmoCvvqEssvq84CVCpLzrNcOOspLhY6/KswB6FmoSxGPBcWts7lsMp/0q83da1hgC6k7GoqBir1ruAFIVvWIdTi++oGIAyZw8mkuG03uDDc+rEsSWTmFBwbLgtTF8hl1e/lpCigR7+pM5V9lIqVJBjStzKNRRQDp6UOrvwga6VFrGcWz6YHwLNYWUYeZfWO/DQTq7i4dAxixeszmtFEw7Cr5v9R3lRVF55TDzY6QRrSfzF9NLE7lAZ+vLnGgYLZ/FlCuoRcOugeFduHTqRWmyh1J91XpIndIbEk8jifL8hs8qQ8vjAVoGqhK5Tm/O5svpXd82QH4Azq05kYnhj93PzLbcTisFzXWfDqIC5zsq3jU7UUhSh1R3L4+i4HCXKlrGyywSBttPr2zpL4gCDPtk2HPN5tgZFomzSDPfGAlASus+e4KlLcjS0vPQ0f5/mR/r1s4PcxsgMLRSMp617AveCuup2OCAPBT6yltWrPO9azsbp6fphR87Lc7VzcbEt5F4Ydg/NzhXTA==".decode("base64").decode("zip"):n=n*64+ord(x)
print bin(n)[2:input()+2]

मुझे लगता है कि यह बोनस के लिए भी अर्हता प्राप्त करता है अगर विचार "जवाब जल्दी से खत्म करने के लिए पुरस्कृत करने के लिए" है।

हालांकि, यह एक कठिन-कोडित उत्तर है, जो चुनौती की भावना में नहीं है (हालांकि जब मैंने लिखा था तब स्पष्ट रूप से अस्वीकृत नहीं हुआ था)।


2
अंत में, एक जवाब! d ;-)
wizzwizz4
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.