2048 년 완벽한 게임을 즐겨보세요

당신의 임무는 수학적으로 완벽한 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를 사용하십시오)

루비, 코너킥, 점수 : 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 :+}"

이 전략은 매우 간단하고, 나 자신을 2048 연주 할 때 나는 실제로 128로 건너 뜁니다하는 데 사용되는 하나입니다 사이에 단지 대체 위로 와 왼쪽 . 이 작업을 가능한 한 오랫동안 수행하기 위해 4오른쪽 아래 모서리에 새로운 s가 생성됩니다.

편집 : 종료 직전의 특정 단계에서 몇 번 바로 이동하기 위해 하드 코딩 된 스위치를 추가했습니다. 실제로 1024에 도달 할 수 있습니다.하지만 다소 손이 닿지 않으므로 지금은 그만하고 내일 일반적으로 더 나은 접근 방식을 생각하십시오. (솔직히 손으로 비틀어 진 해킹을 추가하여 점수를 4 배 늘릴 수 있다는 사실은 내 전략이 헛소리라고 말해줍니다.)

이것은 당신이 끝내는 보드입니다

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