2048 का परफेक्ट गेम खेलें

Question

आपका काम 2048 के एक गणितीय रूप से परिपूर्ण खेल का अनुकरण करना है। विचार यह है कि 2048 के खेल की सैद्धांतिक ऊपरी सीमा कितनी दूर तक जा सकती है, और वहां कैसे पहुंचा जाए।

यह कैसा दिखता है, इसका अनुमान लगाने के लिए, इस 2x2 क्लोन के साथ खेलें और 68 अंक स्कोर करने का प्रयास करें। यदि आप करते हैं, तो आप 2, 4, 8 और 16 टाइल के साथ समाप्त हो जाएंगे। उस बिंदु से आगे बढ़ना असंभव है।

आपका काम आसान हो गया है क्योंकि आप चुन सकते हैं कि टाइलें कहाँ पर घूमती हैं और उनके मूल्य क्या हैं, बस इस क्लोन की तरह ।

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

Input:
-------
0 0 0 0
0 0 0 0
0 0 0 0
0 0 8 8

Output:
-------
0 0 0 0
0 0 0 0
0 0 0 0
0 4 8 8

0 0 0 0
0 0 0 0
0 0 0 0
0 0 4 16

आपके कार्यक्रम को 2048 के पूरे खेल को अनुकरण करने के लिए बार-बार अपने स्वयं के आउटपुट को खिलाया जाएगा। कार्यक्रम का पहला इनपुट एक खाली बोर्ड होगा। आपको मूल गेम की दो टाइलों के विपरीत, उस पर एक टाइल स्पॉन करना होगा। खेल के अंतिम चरण में, आप स्थानांतरित करने में असमर्थ होंगे, इसलिए आपके दो आउटपुट बोर्ड समान हो सकते हैं।

आपको निश्चित रूप से केवल कानूनी कदम उठाने होंगे। केवल 2 या 4 को ही जाड़ा जा सकता है, आपको एक चाल पर कम से कम एक टाइल को हिलाना या गिराना होगा, आदि।

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

विजेता वह होगा जो बोर्ड पर उच्चतम टाइल के साथ खेल को समाप्त करता है, फिर स्रोत कोड में सबसे कम बाइट्स होता है। मूल खेल से स्कोरिंग को ध्यान में नहीं रखा जाएगा। (संकेत: 4 का उपयोग करें)

Comments

@undergroundmonorail यह उस प्रश्न से अलग है। यह प्रश्न आपकी खुद की टाइलों को चमकाने की अनुमति देता है, और यह केवल 2048 तक नहीं बल्कि गणितीय रूप से संभव है।

— केंडल फ्रे

@ डॉक्टर 68 2 की शक्तियों का एक योग है, और यदि आपका स्कोर 2, 4, 8, 16 है, तो आपका स्कोर कितना होगा।

— user12205

क्या यह वास्तव में डुप्लिकेट है? इसे अलग बनाने में और क्या लगेगा?

— केंडल फ्रे

@Quincunx कि वास्तव में हालांकि एक suboptimal खेल उत्पन्न होगा।

— केंडल फ्रे

मुझे इस चुनौती का दिल मिला, "एक इष्टतम समाधान ढूंढें", अद्वितीय होने के लिए, लेकिन वास्तव में यह एक नकली "खोल" में घेरने के लिए एक खराब विकल्प था। यह चिल्लाता है, "ओह देखो, एक और 2048 कोड गोल्फ चुनौती।" करीबी वोट इतने व्यक्तिपरक होने के साथ, आपको वास्तव में भीड़ को अपनी चुनौती बेचनी होगी । कभी-कभी इसका मतलब होता है कि 2048 का आपका खुद का भयानक

— उत्पात

Answer 1

रूबी, इन द कॉर्नर, स्कोर: 3340

यहाँ इस बंद किक करने के लिए एक बहुत ही सरल रणनीति है। मेरे पास एक (पास) सही स्कोर के लिए एक विचार है, लेकिन मुझे इसे औपचारिक रूप देने में परेशानी हो रही है, इसलिए यहां चीजों को प्राप्त करने के लिए कुछ सरल है।

def slide board, dir
    case dir
    when 'U'
        i0 = 0
        i_stride = 1
        i_dist = 4
    when 'D'
        i0 = 15
        i_stride = -1
        i_dist = -4
    when 'L'
        i0 = 0
        i_stride = 4
        i_dist = 1
    when 'R'
        i0 = 15
        i_stride = -4
        i_dist = -1
    end

    4.times do |x|
        column = []
        top_merged = false
        4.times do |y|
            tile = board[i0 + x*i_stride + y*i_dist]
            next if tile == 0
            if top_merged || tile != column.last
                column.push tile
                top_merged = false
            else
                column[-1] *= 2
                top_merged = true
            end
        end

        4.times do |y|
            board[i0 + x*i_stride + y*i_dist] = column[y] || 0
        end
    end

    board
end

def advance board
    if board.reduce(:*) > 0
        return board, board
    end

    16.times do |i|
        if board[15-i] == 0
            board[15-i] = 4
            break
        end
    end

    spawned = board.clone

    # Attention, dirty dirty hand-tweaked edge cases to avoid
    # the inevitable for a bit longer. NSFS!
    if board[11] == 8 && (board[12..15] == [32, 16, 4, 4] ||
                          board[12..15] == [16, 16, 4, 4] && board[8..10] == [256,64,32]) || 
       board[11] == 16 && (board[12..15] == [32, 8, 4, 4] || 
                           board[12..15] == [4, 32, 8, 8] || 
                           board[12..15] == [4, 32, 0, 4])

        dir = 'R'
    elsif board[11] == 16 && board[12..15] == [4, 4, 32, 4] ||
          board[11] == 8 && board[12..15] == [0, 4, 32, 8]
        dir = 'U'
    else
        dir = (board.reduce(:+)/4).even? ? 'U' : 'L'
    end

    board = slide(board, dir)

    if board == spawned
        dir = dir == 'U' ? 'L' : 'U'
        board = slide(board, dir)
    end
    return spawned, board
end

advanceसमारोह एक अपने के लिए पूछ रहा है। यह 1d सरणी के रूप में एक बोर्ड लेता है और टाइल को हटाने के बाद बोर्ड को वापस कर देता है और इस कदम के बाद किया गया है।

आप इसे इस स्निपेट के साथ टेस्ट कर सकते हैं

board = [0]*16
loop do
    spawned, board = advance(board)
    board.each_slice(4) {|row| puts row*' '}
    puts
    break if board[15] > 0
end

puts "Score: #{board.reduce :+}"

रणनीति बहुत सरल है, और क्या मैं वास्तव में 128 को छोड़ता था जब मैं 2048 खुद खेल रहा था: बस ऊपर और बाएं के बीच वैकल्पिक । इस काम को अधिक से अधिक समय तक करने के लिए, 4नीचे के दाएं कोने में नए एस लगाए गए हैं।

संपादित करें: मैंने अंत से ठीक पहले विशिष्ट चरणों में कुछ बार सही जाने के लिए एक हार्ड कोडित स्विच जोड़ा है, जो वास्तव में मुझे 1024 तक पहुंचने देता है। हालांकि यह कुछ हद तक हाथ से बाहर हो रहा है, इसलिए मैं अभी इसके लिए रुकूंगा। कल एक आम तौर पर बेहतर दृष्टिकोण के बारे में सोचें। (ईमानदारी से, तथ्य यह है कि मैं अपने स्कोर को 4 के कारक से बढ़ा सकता हूं, हाथ से घुमाए गए हैक को जोड़कर केवल मुझे बताता है कि मेरी रणनीति बकवास है।)

यह वह बोर्ड है जिसे आप समाप्त करते हैं

1024 512 256 128
 512 256 128  16
 256 128  64   8
   8  32   8   4

Comments

सिर्फ नाइटपिक करने के लिए, 4 की स्पॉनिंग आपको एक इष्टतम स्कोर नहीं देती है क्योंकि आप हर बार 4 अंक प्राप्त नहीं कर रहे हैं जो कि 2 2 के द्वारा उत्पन्न होने के विपरीत बनाया गया है।

— BrunoJ

@BrunoJ इस चुनौती के लिए स्कोर की गणना अंत में सभी टाइलों के कुल के रूप में की जाती है, न कि स्कोर वास्तविक गेम में आपके पास होगा। लेकिन अगर ऐसा था, तो आप बिल्कुल सही हैं। ;) ... हालांकि मुझे लगता है कि मेरी रणनीति से इसे कोई फर्क नहीं पड़ेगा, क्योंकि मैं केवल 256 के बजाय 128 प्राप्त करूंगा।

— मार्टिन एंडर

ओह, यह नहीं पकड़ा कि स्कोरिंग समान नहीं है, मेरी माफी

— ब्रूनो