मेंढक चैंपियन

11

खेल

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

कुछ महीने पहले एक फ्रॉगगर क्लोन विकसित करने के लिए एक चुनौती जारी की गई थी। लेकिन जब आप मेंढक का किरदार निभा सकते हैं तो फ्रॉगर क्लोन क्यों ? :)

निम्नलिखित सरलीकृत खेल ग्रिड पर विचार करें:

 XXXXXXXXXXXXXXXXXXXXXXX  North Safe Zone
 -----------------------
|                       | <<<<       Express Lane West        (Lane 1)
|                       |     >      Gridlock East            (Lane 2)
|                       |   <<       Freeflowing Traffic West (Lane 3)
|                       |    <       Gridlock West            (Lane 4)
|                       |     >>>>   Express Lane East        (Lane 5)
 -----------------------
 XXXXXXXXXXX@XXXXXXXXXXX  South Safe Zone
 \__________ __________/
            '
  23 cells horizontally

हमारे पास पाँच लेन का ट्रैफ़िक है, प्रत्येक 23 कोशिकाएँ चौड़ी हैं, और दो सुरक्षित ज़ोन (जहाँ मेंढक सुरक्षित रूप से बाएँ और दाएँ घूम सकते हैं), 23 कोशिकाएँ भी चौड़ी हैं। आप दाएं और बाएं सीमाओं की अनदेखी कर सकते हैं क्योंकि ये सचित्र स्पष्टता के लिए हैं।

हमारे मेंढक केंद्र (12 वें) सेल पर, दक्षिणी सुरक्षित क्षेत्र में शुरू होते हैं, जैसा कि @उपरोक्त आंकड़े में संकेत दिया गया है ।

खेल में समय को असतत चरणों में विभाजित किया जाता है जिसे फ्रेम कहा जाता है। फ्रॉग्जी एक तेज मेंढक है और प्रति फ्रेम में किसी भी दिशा (ऊपर, नीचे, दाएं, बाएं) में एक सेल को हॉप कर सकता है। वह किसी भी फ्रेम के लिए स्थिर रहना चुन सकता है। पाँच लेन में यातायात निरंतर गति से आगे बढ़ता है:

  • एक्सप्रेस लेन पश्चिम (लेन 1) में यातायात 2 कोशिकाओं को हर फ्रेम में छोड़ देता है
  • ग्रिडलॉक ईस्ट लेन (लेन 2) में यातायात हर दूसरे फ्रेम में 1 सेल सही चलता है
  • फ्रीफ़्लोइंग ट्रैफ़िक वेस्ट लेन (लेन 3) में ट्रैफ़िक हर फ्रेम में 1 सेल छोड़ता है
  • ग्रिडलॉक वेस्ट लेन (लेन 4) में यातायात हर दूसरे फ्रेम में 1 सेल छोड़ता है
  • एक्सप्रेस लेन में यातायात पूर्व (लेन ५) हर फ्रेम में २ सेल सही चलता है

यातायात लगभग विशिष्ट रूप से परिभाषित है। इस पाठ फ़ाइल में 3,000 टाइमस्टेप्स । 'ट्रैफ़िक' में वाहनों और वाहनों के बीच रिक्त स्थान होते हैं। कोई भी वर्ण जो एक स्थान नहीं है, एक वाहन का हिस्सा है। पाठ फ़ाइल में पाँच लाइनें होती हैं, जो ट्रैफ़िक के पाँच लेन के समान होती हैं (उसी क्रम के साथ)।

वेस्टबाउंड लेन के लिए, फ्रेम 0 (गेम की शुरुआत) की शुरुआत में, हम लेन में पहले वाहन को प्लेइंग ग्रिड के दाहिने किनारे से परे मानते हैं।

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

एक उदाहरण के रूप में विचार करें:

Traffic Lane 1:  [|==|  =
Traffic Lane 2:  |) =  o
Traffic Lane 3:  (|[]-[]:
Traffic Lane 4:  <| (oo|
Traffic Lane 5:  |==|] :=)

फिर खेल ग्रिड निम्नानुसार दिखाई देगा:

Start of Frame 0       XXXXXXXXXXXXXXXXXXXXXXX
                                              [|==|  =
                |) =  o
                                              (|[]-[]:
                                              <| (oo|
              |==|] :=)
                       XXXXXXXXXXXXXXXXXXXXXXX

Start of Frame 1       XXXXXXXXXXXXXXXXXXXXXXX
                                            [|==|  =
                |) =  o
                                             (|[]-[]:
                                              <| (oo|
                |==|] :=)
                       XXXXXXXXXXXXXXXXXXXXXXX

Start of Frame 2       XXXXXXXXXXXXXXXXXXXXXXX
                                          [|==|  =
                 |) =  o
                                            (|[]-[]:
                                             <| (oo|
                  |==|] :=)
                       XXXXXXXXXXXXXXXXXXXXXXX

Start of Frame 3       XXXXXXXXXXXXXXXXXXXXXXX
                                        [|==|  =
                 |) =  o
                                           (|[]-[]:
                                             <| (oo|
                    |==|] :=)
                       XXXXXXXXXXXXXXXXXXXXXXX

एक लेन में सभी ट्रैफ़िक "समाप्त" होने के बाद (यानी स्ट्रिंग बाहर निकलती है), हम स्ट्रिंग के सभी वर्णों को रिक्त स्थान मानते हैं।

हमारे मेंढक है squished यदि निम्न में से कोई होता है:

  • मेंढक किसी भी फ्रेम पर, वाहन द्वारा कब्जा किए गए सेल पर कब्जा कर लेता है
  • मेंढक एक एक्सप्रेस लेन में स्थिर रहता है और 1 सेल चौड़ाई का वाहन उस फ्रेम में उसके ऊपर से गुजरता है
  • मेंढक पूर्व में "वाहन" के माध्यम से पश्चिम की ओर बढ़ता है, या पूर्व की ओर जाने वाले वाहन के माध्यम से पश्चिम में कूदता है
  • मेंढक 7 (लाइन) के बाहर 23 (सेल) प्लेइंग ग्रिड द्वारा, किसी भी फ्रेम पर कूदता है

ध्यान दें कि ये एकमात्र स्थितियां हैं जिनके तहत एक मेंढक को निचोड़ा जाता है। विशेष रूप से, "ट्रैफिक" के साथ "मेंढक के साथ एक मेंढक को रोकना" अनुज्ञेय है, जैसा कि एक एक्सप्रेस लेन में एक सेल में या बाहर कूदने वाला एक मेंढक है जो एक ही फ्रेम में चौड़ाई -1 वाहन से गुजरता है।

उद्देश्य और स्कोरिंग

प्रोग्रामिंग चुनौती का उद्देश्य अंतिम वाहन को प्ले ग्रिड से बाहर निकलने से पहले जितनी बार संभव हो, मेंढक को सड़क के पार पहुंचाना है । यही है, फ्रेम एक्स के पूरा होने के तुरंत बाद कार्यक्रम समाप्त हो जाता है , जहां फ्रेम एक्स पहला फ्रेम है जो ग्रिड को ऐसी स्थिति में ले जाता है जहां कोई और वाहन मौजूद नहीं है।

आपके प्रोग्राम का आउटपुट एक स्ट्रिंग (या टेक्स्ट फ़ाइल) होना चाहिए जिसमें निम्नलिखित एन्कोडिंग का उपयोग करके मेंढक के लिए चाल का क्रम हो:

<   frog moves left
>   frog moves right
^   frog moves up
v   frog moves down
.   frog remains stationary

उदाहरण के लिए, स्ट्रिंग <<^.^इंगित करती है कि मेंढक दो बार छोड़ दिया है, फिर ऊपर, फिर एक फ्रेम के लिए रुकता है, फिर ऊपर जाता है।

जब भी मेंढक दक्षिण सुरक्षित क्षेत्र से उत्तर सुरक्षित क्षेत्र की ओर जाता है, और जब भी मेंढक उत्तर सुरक्षित क्षेत्र से दक्षिण सुरक्षित क्षेत्र में पार करता है, तो एक बिंदु बनाया जाता है।

कुछ महत्वपूर्ण नियम:

  1. मेंढक को स्क्वीज़ नहीं करना चाहिए।
  2. कृपया अपने प्रोग्राम कोड के साथ अपना समाधान (चाल का क्रम) पोस्ट करें, या तो इनलाइन या एक टेक्स्ट फ़ाइल के रूप में (जैसे pastebin.com का उपयोग करके)।
  3. हमारा मेंढक प्रस्तुतकर्ता और पूर्वज्ञानी है, इसलिए आपका कार्यक्रम समाधान की मांग करते हुए किसी भी फ्रेम में किसी भी और सभी ट्रैफ़िक डेटा का उपयोग कर सकता है । इसमें ट्रैफ़िक के लिए डेटा शामिल है जो अभी तक प्लेइंग ग्रिड तक नहीं पहुंचा है।
  4. ग्रिड चारों ओर नहीं लपेटता है। ग्रिड से बाहर निकलने के कारण मेंढक को स्क्वीज़ किया जाएगा और इसलिए इसकी अनुमति नहीं है।
  5. किसी भी बिंदु पर ट्रैफ़िक "रीसेट" या मेंढक "टेलीपोर्ट" नहीं करता है। अनुकरण निरंतर है।
  6. मेंढक बाहर निकलने के बाद दक्षिण सुरक्षित क्षेत्र में लौट सकता है, लेकिन यह एक बिंदु के रूप में नहीं गिना जाता है। इसी तरह उत्तर सुरक्षित क्षेत्र के लिए।
  7. प्रतियोगिता विजेता वह कार्यक्रम है जो सबसे अधिक संख्या में क्रॉसिंग की उपज के क्रम को उत्पन्न करता है।
  8. किसी भी अतिरिक्त प्रश्न या चिंताओं के लिए, कृपया टिप्पणी अनुभाग में पूछने के लिए स्वतंत्र महसूस करें।

कुछ अतिरिक्त प्रोत्साहन के लिए, मैं जीतने के कार्यक्रम में +100 प्रतिनिधि के इनाम में जोड़ दूंगा जब मैं ऐसा करने में सक्षम हूं।

बोनस

प्ले ग्रिड के प्रत्येक कोने के लिए बेस स्कोर * (10% तक) को 2.5% मेंढक छूता है। ग्रिड के चार कोने दो सुरक्षित क्षेत्रों की सबसे बाईं और दाईं ओर की कोशिकाएँ हैं।

बेस स्कोर के लिए 25% * यदि आपकी चाल का क्रम मेंढक को भीतर तक सीमित रखता है +/- पूरे सिमुलेशन के लिए उसके शुरुआती सेल के बाएं या दाएं 4 सेल (वह निश्चित रूप से स्वतंत्र रूप से लंबवत स्थानांतरित कर सकते हैं)।

कोई स्कोरिंग बोनस नहीं है, लेकिन ओपी में विशेष प्रॉप्स किसी भी व्यक्ति के पास जाएगा जो त्वरित एन 'गंदे समाधान सत्यापनकर्ता पोस्ट करता है ताकि मुझे एक कार्यक्रम न करना पड़े। ;) एक सत्यापनकर्ता बस चालों के अनुक्रम को स्वीकार करेगा, इसकी वैधता (नियमों और यातायात फ़ाइल के अनुसार) सुनिश्चित करेगा, और इसके स्कोर (यानी क्रॉसिंग की कुल संख्या) की रिपोर्ट करेगा।

* कुल स्कोर आधार स्कोर के बराबर है और बोनस, निकटतम पूर्णांक तक गोल है।

गुड फ्राइडिंग!

code-challenge  game  optimization 
— COTO
स्रोत
जो कोई समाधान सत्यापनकर्ता पोस्ट करना चाहता है, उसे कृपया उत्तर के रूप में पोस्ट न करें ।
— जियोबिट्स
वास्तव में। एक टिप्पणी में कोड के लिए एक लिंक, या एक समाधान के लिए एक परिशिष्ट के रूप में, एक सत्यापनकर्ता प्रस्तुत करने का पसंदीदा तरीका होगा।
— सीओटीओ
पहला फ्रेम जिसमें धीमी गलियां अग्रिम होती हैं, वह पहले फ्रेम की तरह होती हैं, जिसमें दूसरी गलियां अग्रिम होती हैं, या एक फ्रेम बाद में?
— feersum
इसके अलावा, क्या यह संभव है कि पहले फ्रेम पर एंडज़ोन तक पहुंचकर स्कोर किया जाए जिसमें सभी कारों ने क्षेत्र को साफ़ कर दिया है?
— feersum
@ फैर्सम: धीमी गलियां बाद में एक फ्रेम को आगे बढ़ाती हैं। जैसा कि उदाहरण में बताया गया है, वे बहुत पहले फ्रेम में गतिहीन रहते हैं। के रूप में बहुत अंतिम फ्रेम पर मेंढक स्कोरिंग के लिए: हाँ, यह संभव है। यदि मेंढक एक ही फ्रेम पर एक सुरक्षित क्षेत्र में चले गए हैं, जहां अंतिम वाहन खेल के मैदान से बाहर निकलता है, तो एक अंक बनाया जाता है।
— COTO

जवाबों:

5

C ++: 176

आउटपुट:

176
^^^^^^>vvvvvv>^^^^>^^>>>>>>><<<.vv>v<<<.vvv<<<<<<^.^.^.^.>.>^^<.>>>>>>v>v>.>v<<<<v.<.vv<<<<<^^.<^<<<<<<^.^^>>>>vv>.>.v<v.vv>>^>>^<^<<<<<<<^>.>^^<<<.>>>>>vv>v<vvv<<<<<^^.<^^^^.....vv>.>.>.>v<<vvv<<>>>>^>^<.<.^^>^^>>>>vv.>v<vv.v^>^<.<.<^<^>.>^^>>>>vv.v<<<<<<.vvv<<<<^^^<<v^^.>.^^..>>>>>>vv>.>.v.vvv>>>^>^^<<<<<<<<<^>.>^^>>>>vvv<<v.<.vv<<<<<<>>>>>^^^<<<^^^<<>>vv>.v<<>vvv<<><>>>>>>>^>^^<^^^<.>>>>>>>>vv>.>v<<<vvv<<<<<^^^<<v.<.<^<<^.^<<^...>>>>>>>>>>>>>vv>v<vvv<<<<<<<<^>^.<.^^>.>^^<<<<<<<..>>>>vv>.vvvv<<<<>^.v>>>^^.^^>^<^<>>>>>>>>>vv>vvvv<<<<^^^<^>^<<^.>>vv>v<vvv<<<<<<<>>>>>>>^>^^^.^^>>>>>vvv<<vvv<<<^^^^^^<vvv<<<<<<<vvv<<<>>>>>>>>^^.<.<.^.^.^<^<>>>>>>>>>>vvv<<.vvv<<<^^<^<<^^<<^<<<>>>>vv>.vvvv>>^>>^<.<.<^<<<<<.^^<<^.......>vv.>.>.>v<vvv>>>>>>^>^.<.<^<.^^^<.>>>>>>>vvv<<<v.<vv<<<^^<.<.<.<^<<<^>^^..........v<vvvv>v>>>>>^>>^^^>^^>>>vv>v<vvv<<<<<<<<>^^.<.<^<^^^<.........>vv.>.vvvv>>>>^^<.<.<^^^<^<<.v<v>.>.>.>.>.>.>.vvv.v<<<<<^^<^<^>.>.>.>.^<^.>>>>>>>>vv>v<<vvv<<>>>>>^^^.^.>^<^<<<<<<<<.vv.>.v<<<.vvv<>>>>>^>^.<.<.<.<^^.^<<^<.....>>vvv<.>>vvv<<<>>>>>>>>^^^<<<.^.>.>^^.>>>>>vv.>v<vvv<<<>>>>>>^>^<^<<^.^^<vvv<<<<<vv.v<>>>>>>>>>>^>^.^^>^^<<<<.>vv.>.vvvv>^>>^.<.<.<^<<<^>^^>>>vv>v<<<<<vvv<<<>>>>>^^<.<.<.<.<^<^>.^^.>>>>>vv>v<>vvv<<<<<<<^>^.<^<<<<<<<^^^.>>>>>vv>v<>vvv>>>^^<.<^<<<^>^^.>>>>vv>.v<<vvv<<<<<^^^<<<<<^>.^^<>>>>>>>vv>.>v<<vvv<<<<<<<>>>^>>.>^^^.>^^<>>>>>>vv>vv.<.<.vv>>>>^^<.<.<.<^<<^.>^^.>>>>>vv.>.>v<<vvv<<>>>>>^^<.<.<.^^>.>.>^^<<<<<<<<.>>>>>>vv>v<<v.<.<vv<<<<^^.<^<<<.^^^<.vv.>v<vvv<<<>>>>>>^>^<^<<^.^<^<<.>>vv>.>.>.>vvvv>>>>>>^>^^^^^<<<.vvv<<<<<<vvv>>>>>^>^<.<^<<^.>.>.^^>>>>vv>.>v<<<<<<vvv<<<<^^^<.^.>^^>>>>vvv<<v.vv<<<^>>^^<<<.^^<<^>>>>>>>>>vvv.v.vv<>>>>>^>^^<<<<<<<<<<<<<<<<^^^..>>>>>vv>.>.>.>v<<v.<.<.vv<<<<<^^^<^>.^^...>>>>>>>>vv.v<.vvv>>>^>^<.<^^^^>>>vv>v<<<vvv<<<<>>>>>>^>^.<.<^<^>.>^^.>>>>>vv.v<<<<<<<<vvv<<<<^^<^<<<<<><^>.>^^>>>>vv.>.>.vvv.v>>>>>>>^^<.<^<<^^^>>>vv>.>.>.>.>v<<v.<.<vv>>>>^^^<<<<<.^.>^^>>>vv>.>v<vvv<<<<^^<.<.<.^^>^^>>>vv>.>.v<<<v.<vv<<<<^^.<^<<<^^^>>>>vvvvvv<<<<<<<<>^^.^>>^^^<>>>>>>>vvv<<<v.vv>>>>>^>>^^<<<<<^>.^^>>>>vv>.>v<<<<vvv<<<^^<.<.<.<^<<<<<^>^^>>>>vv.>vv.v.v<^>.>^.<.^^^^>>>>vv>.>.>.v<<<<<<vvv>>>>^^<.<.<^<<^^<^>>>>>>vv>v<<.vvv^>^^<<<^>^^<<<<<<.vvv<<vv>.v>>>>>>^>.>^^<<<<<^>.>.>.>.>.^^>>>>vv>.>.>v<<<<<vvv<<<<^^<^<<^.^^>>>>vv>.>.>.>v<vvv<<<<<^^.<.<^<<^^^>>>>>>>>>>>vv>.>.>.>.>vvvv<<<<^^.<.<^<^^^<<<<<<vvv<v.<vv<<<<^v>>>>>>>>>>^^^<.^.>.>.^^>>>>vvv<<<<<<<vvv<<<<<<<>^^.<^<.^^^.>>>>vv>v<vvv<>>>>^^.<.^.^.>.^<^>>>>>>>>vvvv.<.<vv<<<<^^^<<<<<^>.^^<.vv>.v<<vvv<<><>>>>>^>>^.<^<^^^<<<.>>vv>.>v<<<<v.vv>^>>^.<^^.^^.>>>>>vv>.>.>.v<v.<vv<<<<<^.^^^.>^^<>>>>>>vv>.v<<<v.<vv<<<<>>>>>>>>>>>^^<.<.<.<.<^<<^^<^<<<>>>>>>>vv>v<<<vv.v>>>>>>>>^>^<.<^<<<<<<<<<<<.^.>^^<<<vvv.v.<vv<<<^.>>^.<^^.>.>^^<<......vv.v>vvv>>>^.v^>>^^<<^^^<.>>>>>>>vvv<v.<.<.vv<<<<^^<.<.<.^^^^<.>>>>>>>>vvv<v.<vv^.>^^<<^^^vv>vvvv^>>>>>>>^^^^^vvvvvv^^^^^^vvvvvv>>>>

विज़िट किए गए कोनों की स्थिति एक्स टाइम एक्स सेट के 8 मिलियन राज्यों के संयोजन के तहत हैं , इसलिए उन्हें 1 सेकंड से भी कम समय में खोजा जा सकता है। यदि कोड में कोई बग नहीं है, तो इसे हरा पाना असंभव है। इष्टतम रणनीति पूरे बोर्ड का उपयोग करने के लिए थी, क्योंकि केंद्र तक सीमित होने पर मेंढक 160 बार, बनाम 120 के पार जाने की अनुमति देता है। यातायात इतना भारी होने के कारण कोनों पर जाना किसी भी क्रॉसिंग पर खर्च नहीं हुआ।

/* feersum  2014/9
 /codegolf/37975/frogger-champion */

#include <iostream>
#include <fstream>
#include <string>
#include <algorithm>
#include <cstring>

#define B(F, CST, X, Y) best[ ((F)*NCST + (CST)) * BS + (Xmax-Xmin+1) * ((Y)-Ymin) + (X)-Xmin]
#define TL(i) ((int)t[i].length())
#define ABSPEED(I) (speed[i]<0?-speed[i]:speed[i])
#define errr(X) { cout<<"ERROR!!!!!!!!"; return X; }

#define DRAW 0
#if DRAW
    #include <unistd.h>
#endif


using namespace std;

int bc(int cs) {
    int c = 0;
    while(cs) {
        c += cs&1;
        cs >>= 1;
    }
    return c;
}

int main()
{
    const bool bonusTwentyfive = false;
    const int COLS = 23, T_ROWS = 5, YGS = T_ROWS + 2, XGS = COLS + 2;
    string t[5];
    int speed[] = {-4, 1, -2, -1, 4};
    ifstream f("t.txt");
    for(int i = 0; i < T_ROWS; i++)
        getline(f, t[i]);
    if(f.fail())
        return 1;
    f.close();
//for(int i = 0; i < 5; i ++)t[i]="xxx";

    char g[XGS][YGS];

    int mov[][3] = { {-1,  0, '<'},
                     {+1,  0, '>'},
                     { 0, -1, '^'},
                     { 0, +1, 'v'},
                     { 0,  0, '.'} };


    int Ymin = 0, Ymax = YGS-1;


    const int Xstart = 11, Xmaxmove = bonusTwentyfive ? 4 : 10;
    const int Xmin = Xstart - Xmaxmove, Xmax = Xstart + Xmaxmove;

    const int NCST = bonusTwentyfive ? 1 : 1<<4;

    int maxfr = 0;
    for(int i = 0; i < T_ROWS; i++) {
        if(speed[i] < 0) {
            for(int m = 0, n = t[i].length()-1; m < n; ++m,--n)
                swap(t[i][m], t[i][n]);
        }
        int carslen = TL(i);
        for(char*c = &t[i][speed[i]>0?TL(i)-1:0]; carslen; carslen--, speed[i]>0?--c:++c)
            if(*c != ' ')
                break;
        if(carslen)
            maxfr = max(maxfr, ( (carslen + COLS) * 2 + ABSPEED(i)-1 ) / ABSPEED(i));
    }
    const int BS = (Xmax-Xmin+1)*(Ymax-Ymin+1);
    int *best = new int[(maxfr+1)*NCST*BS];
    memset(best, 0xFF, (maxfr+1)*NCST*BS*sizeof(int));
    memset(g, ' ', sizeof(g));
    B(0, 0, Xstart, Ymax) = 0;

    for(int fr = 0; fr < maxfr; fr++) {
        for(int r = 0; r < T_ROWS; r++) {
            for(int x = 0; x < XGS; x++) {
                int ind = speed[r] > 0 ? TL(r)-1 + x - fr*speed[r]/2 : x - (XGS-1) - fr*speed[r]/2;
                g[x][r+1] = ind >= 0 && ind < TL(r) ? t[r][ind] : ' ';
            }
        }
        for(int x = Xmin; x <= Xmax; x++) {
            for(int y = Ymin; y <= Ymax; y++) {
                if(g[x][y] != ' ')
                    continue;
                for(unsigned m = 0; m < sizeof(mov)/sizeof(mov[0]); m++) {
                    int X = x + mov[m][0], Y = y + mov[m][1];
                    if(X < Xmin || X > Xmax || Y < Ymin || Y > Ymax)
                        continue;
                    if(!(mov[m][0]|mov[m][1]) && y > 0 && y > T_ROWS && g[x][y-speed[y-1]/4] != ' ')
                        continue;

                    int csor = ((X==Xmin|X==Xmax)&(Y==Ymin|Y==Ymax)&!bonusTwentyfive) << ((X==Xmax) + 2*(Y==Ymax));

                    for(int cs = 0; cs < NCST; cs++) {
                        int N = B(fr, cs, x, y);
                        if(!~N)
                            continue;
                        if((!(N&1) && y == 1 && Y == 0) ||
                              (N&1 && y == T_ROWS && Y == T_ROWS+1))
                            ++N;
                        if(N > B(fr+1, cs|csor, X, Y))
                            B(fr+1, cs|csor, X, Y) = N;
                    }


                }
            }
        }
    }

    int score = 0, xb, yb, cb, nb;
    for(int x = Xmin; x <= Xmax; x++) {
        for(int y = Ymin; y <= Ymax; y++) {
            for(int cs = 0; cs < NCST; cs++) {
                if(B(maxfr, cs, x, y) * (40 + bc(cs)) / 40 >= score) {
                    score = B(maxfr, cs, x, y) * (40 + bc(cs)) / 40;
                    xb = x, yb = y, cb = cs, nb = B(maxfr, cs, x, y);
                }
            }
        }
    }
    char *mvs = new char[maxfr+1];
    mvs[maxfr] = 0;

    for(int fr = maxfr-1; fr >= 0; --fr) {
        for(int r = 0; r < T_ROWS; r++) {
            for(int x = 0; x < XGS; x++) {
                int ind = speed[r] > 0 ? TL(r)-1 + x - fr*speed[r]/2 : x - (XGS-1) - fr*speed[r]/2;
                g[x][r+1] = ind >= 0 && ind < TL(r) ? t[r][ind] : ' ';
            }
        }
        for(int x = Xmin; x <= Xmax; x++) {
            for(int y = Ymin; y <= Ymax; y++) {
                if(g[x][y] != ' ')
                    continue;

                for(unsigned m = 0; m < sizeof(mov)/sizeof(mov[0]); m++) {
                    int X = x + mov[m][0], Y = y + mov[m][1];
                    if(X < Xmin || X > Xmax || Y < Ymin || Y > Ymax)
                        continue;
                    if(!(mov[m][0]|mov[m][1]) && y > 0 && y > T_ROWS && g[x][y-speed[y-1]/4] != ' ')
                        continue;

                    int csor = ((X==Xmin|X==Xmax)&(Y==Ymin|Y==Ymax)&!bonusTwentyfive) << ((X==Xmax) + 2*(Y==Ymax));

                    for(int cs = 0; cs < NCST; cs++) {
                        int N = B(fr, cs, x, y);
                        if(!~N)
                            continue;
                        if((!(N&1) && y == 1 && Y == 0) ||
                              (N&1 && y == T_ROWS && Y == T_ROWS+1))
                            ++N;
                        if(X==xb && Y==yb && N == nb && (cs|csor) == cb) {
                            mvs[fr] = mov[m][2];
                            xb = x, yb = y, nb = B(fr, cs, x, y), cb = cs;
                            goto fr_next;
                        }
                    }
                }
            }
        }
        errr(3623);
        fr_next:;
    }

    if((xb-Xstart)|(yb-Ymax)|nb)
        errr(789);
    #if DRAW

        for(int fr = 0; fr <= maxfr; ++fr) {
            memset(g, ' ', sizeof(g));
            for(int r = 0; r < T_ROWS; r++) {
                for(int x = 0; x < XGS; x++) {
                    int ind = speed[r] > 0 ? TL(r)-1 + x - fr*speed[r]/2 : x - (XGS-1) - fr*speed[r]/2;
                    ind >= 0 && ind < TL(r) ? g[x][r+1] = t[r][ind] : ' ';
                }
            }
            g[xb][yb] = 'F';
            for(int y = 0; y < YGS; y++) {
                for(int x = 0; x < XGS; x++)
                    cout<<g[x][y];
                cout<<endl;
            }
            cout<<string(XGS,'-')<<endl;
            usleep(55*1000);
            for(int i = 0; i < 5; i++) {
                if(mvs[fr] == mov[i][2]) {
                    xb += mov[i][0];
                    yb += mov[i][1];
                    break;
                }
            }
        }

    #endif
    cout<<score<<endl;
    cout<<mvs<<endl;
}
— feersum
स्रोत
1
मुझे यकीन नहीं है कि आप "राज्यों" को कैसे परिभाषित कर रहे हैं। अगर हम सिस्टम स्थिति को मेंढक गति का समय प्रोफ़ाइल मानते हैं, तो लगभग 5 ^ 3000 संभावित इनपुट्स (पांच संभव इनपुट प्रति ~ 3000 फ्रेम) के लिए गति प्रोफ़ाइल के अनुरूप लगभग 5 ^ 3000 राज्य हैं। जाहिर है कि इनमें से केवल कुछ अंश ही स्वीकार्य होंगे, लेकिन कई सौ परिमाणों के द्वारा स्वीकार्य राज्यों की संख्या को खोजना असंभव होगा। जब आप अपना अंतिम उत्तर प्रस्तुत करते हैं, तो कृपया इसके साथ चालों की एक सूची प्रस्तुत करें।
— सीओटीओ
इसके अलावा, यदि यह स्पष्ट नहीं है, तो ध्यान दें कि मेंढक ट्रैफिक में बाएं और दाएं कूद सकता है, जब तक कि "स्क्विट" नियमों में से कोई भी उल्लंघन नहीं किया जाता है। आप उन खिड़कियों की प्रतीक्षा करने तक सीमित नहीं हैं जहां मेंढक बिना पार्श्व गति के साथ लंबवत हॉप करने में सक्षम है।
— सीओटीओ
@ COTO "राज्यों" की मेरी गणना में मैं एक महत्वपूर्ण बात भूल गया, अर्थात् क्रॉसिंग की संख्या अब तक, इसलिए मैंने एक स्पष्ट विवरण देने की कोशिश की। युक्ति बहुत अच्छी तरह से लिखी गई थी। ऐसा लगता है कि मैंने इन सभी विशेष मुद्दों की पहली बार सही व्याख्या की है।
— feersum
मैं 162 + 10% = 178 क्रॉसिंग के रूप में इष्टतम की गणना करता हूं, लेकिन तुम्हारा काफी करीब है। मैं वास्तव में यह नहीं चाहता था कि यह बलपूर्वक सक्षम हो, लेकिन जाहिर है कि मुझे समस्या को और अधिक विचार करना चाहिए था। निष्पक्षता में, मैं आपको 100 प्रतिनिधि दूंगा।
— सीओटीओ
जाहिर तौर पर "इनाम" देने से पहले मुझे 24 घंटे इंतजार करना होगा। किस कारण से: कौन जानता है। एसई को समय-समय पर पुरस्कृत किए गए जवाब नहीं चाहिए। अगर हम ऐसा करते तो आतंकवादी जीत जाते। : O
— सीओटीओ
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.