24 시 포커 게임 프로 그래 밍 알고리즘 상세 설명

24 시 포커 게임 은 간단하게 말 하면 한 장의 카드 가 크 고 작은 왕 을 제거 하고 네 장의 카드 를 게이머 에 게 임의로 보 냅 니 다. 유 저 는 이 네 장의 카드 를 가감 곱 하기 연산 을 해 야 합 니 다. 규칙 은 네 장의 카드 의 순서 가 정 해 지지 않 지만 중복 할 수 없습니다. 계산 결과 가 24 이면 게이머 가 이 깁 니 다.이 프로그램 은 컴퓨터 가 자동 으로 패 를 보 내 고 카드 조합 이 24 시 로 계산 할 수 있 는 지 판단 하 며 모든 계산 방법 을 출력 합 니 다.    게임 의 알고리즘 은 다음 과 같이 설명 할 수 있 습 니 다. 무 작위 로 4 개의 1 - 13 숫자 를 만 든 다음 에 표현 식 을 생 성 합 니 다. 표현 식 은 4 개의 1 - 13 숫자, 가감 곱 하기 연산 자, 쌍 으로 나타 난 괄호 를 포함 합 니 다.이 표현 식 들 은 반드시 합 법 적 이 어야 합 니 다. 무엇이 합 법 적 인 표현 식 입 니까?예 를 들 어 (2 + 10) * (6 - 4) 는 합 법 적 이 고 계산 결 과 는 24 의 표현 식 입 니 다. 예 를 들 어 2 + 4 () * 38 + 는 불법 표현 식 입 니 다. (2 + 8) / 5 * 2 는 합 법 적 인 표현 식 이지 만 계산 결 과 는 24 가 아 닙 니 다.그리고 이 표현 식 이 24 인지 연산 법칙 에 따라 계산 합 니 다.    알고리즘 은 점차적으로 다음 과 같이 풀 수 있다.    현재 세 개의 집합 이 있 습 니 다.    집합 1 = {N1, N2, N3, N4},    집합 2 = {op1, op2, op3},    집합 3 = {"(", ")"}    N1, N2, N3, N4 는 1 - 13 의 임의의 숫자 일 수 있 습 니 다. op1, op2, op3 은 '+', '-', '*', '/' 중의 임의의 조작 부호 일 수 있 습 니 다.    (1) 먼저 집합 1 에서 하나의 요 소 를 무 작위 로 추출 하고 추출 한 요 소 를 삭제 한 다음 에 집합 2 에서 무 작위 로 하나의 요 소 를 추출 하여 문자 배열 을 구성한다.    (2) 첫 번 째 작업 을 반복 합 니 다. 집합 1 이 비어 있 을 때 까지 집합 2 에서 요 소 를 추출 하지 않 습 니 다. 마지막 으로 얻 은 표현 식 은 다음 과 같 습 니 다.     expression = N1 op1 N2 op2 N3 op3 N4    (3) 집합 3 의 요 소 를 표현 식 expression 에 삽입 하여 얻 은 합 법 적 인 표현 식 은 다음 과 같이 표시 할 수 있 습 니 다.      (N1 op1 N2) op2 N3 op3 N4      N1 op1 (N2 op2 N3) op3 N4      N1 op1 N2 op2 (N3 op3 N4)      (N1 op1 N2 op2 N3) op3 N4      N1 op1 (N2 op2 N3 op3 N4)      ((N1 op1 N2) op2 N3) op3 N4      (N1 op1 (N2 op2 N3)) op3 N4      N1 op1 ((N2 op2 N3) op3 N4)      N1 op1 (N2 op2 (N3 op3 N4))      (N1 op1 N2) op2 (N3 op3 N4)      위의 세 단 계 는 Get 24 Point Expression. java 에서 이 루어 집 니 다.    (4) 이렇게 하면 배열 과 조합 원리 에 따라 C41 * C31 * C21 * C11 * C41 * C41 * C41 * C41 * 10 = 4 를 얻 을 수 있 습 니 다! *4 * 4 * 4 * 10 개의 합 법 적 인 표현 식 을 분석 한 다음 에 이 표현 식 이 중복 되 었 는 지 하나씩 분석 한 다음 에 이 표현 식 을 실제 수학 연산 식 으로 바 꾸 고 결 과 를 계산 하여 계산 결과 가 24 인지 판단 합 니 다.   이 단 계 는 Cancal 24. 자바 에서 이 루어 졌 다.   알고리즘 구현 부분 코드:

package PokerGame24Point;
import com.Allen.*;
public class Get24PointExpression {
    /**
     *           24     
     * @haram array     
     * @return   24     
     */
    static String[] get24CalExpression(int[] array) {
        String[] op = {"+", "-", "*", "/"};
        String[] ch = {"(", ")"};        
        String[] sentence = new String[array.length+op.length-1];
         
        int opNumIndex = PublicFunction.getRandom(0, array.length);
        sentence[0] = Integer.toString(array[opNumIndex]); 
        array = PublicFunction.deleteOneElement(array, array[opNumIndex]);
        int opIndex = PublicFunction.getRandom(0, op.length);
        sentence[1] = op[opIndex];
        opNumIndex = PublicFunction.getRandom(0, array.length);
        sentence[2] =  Integer.toString(array[opNumIndex]); 
        array = PublicFunction.deleteOneElement(array, array[opNumIndex]);
        opIndex = PublicFunction.getRandom(0, op.length);
        sentence[3] = op[opIndex];
        opNumIndex = PublicFunction.getRandom(0, array.length);
        sentence[4] = Integer.toString(array[opNumIndex]); 
        array = PublicFunction.deleteOneElement(array, array[opNumIndex]);
        opIndex = PublicFunction.getRandom(0, op.length);
        sentence[5] = op[opIndex];
        opNumIndex = PublicFunction.getRandom(0, array.length);
        sentence[6] =  Integer.toString(array[opNumIndex]);
         
        //              
        int[][] chindex1 = {{0, 4}, {2, 6},  {4, 8}, {0, 6}, {2, 8}};
        int[][][] chindex2 = {{{0, 6}, {1, 5}}, {{0, 6}, {3, 7}}, 
                {{2, 8}, {3, 7}}, {{2, 8}, {5, 9}}, {{0, 4}, {6, 10}}};
        //          ，    
        int selectedArray = PublicFunction.getRandom(1, 3);
        if (selectedArray == 1)
        {
            int index = PublicFunction.getRandom(0, 5);
            sentence = PublicFunction.insertOneElement(
                    sentence, chindex2[index][0][0], ch[0]);
            sentence = PublicFunction.insertOneElement(
                    sentence, chindex2[index][0][1], ch[1]);
            sentence = PublicFunction.insertOneElement(
                    sentence, chindex2[index][1][0], ch[0]);
            sentence = PublicFunction.insertOneElement(
                    sentence, chindex2[index][1][1], ch[1]);    
        }
        else
        {
            int index = PublicFunction.getRandom(0, 5);
            sentence = PublicFunction.insertOneElement(
                    sentence, chindex1[index][0], ch[0]);
            sentence = PublicFunction.insertOneElement(
                    sentence, chindex1[index][1], ch[1]);
        }
        return sentence;
    }
}
 
 
PublicFunction.java
 
package com.allen;
import java.util.Random;
 
public class PublicFunction {    
    /**
     *           
     * @param from        
     * @param to          
     * @return             
     */
    public static int getRandom(int from, int to) {
        return new Random().nextInt(to)%(to-from) + from;
    }
    /**
     *    
     * @param n   
     * @return   
     */
    public static int getFabonacci(int n) {
        if (n==0 | n == 1) return 1;
        else return n*getFabonacci(n-1);
    }    
     
    /**
     *             
     * @param     
     * @param      
     * @return         
     */
    public static int[] deleteOneElement(int[] array, int element) {
        int[] result = new int[array.length-1];
        int mark = 0;
        for (int i = 0; i < array.length; i++) {
            if (array[i] == element) {
                mark = i;
                break;
            }
        }
        int index = 0;
        for (int i = 0; i < mark; i++) {
            result[index] = array[i]; 
            index++;
        }
        for (int i = mark + 1; i < array.length;  i++) {
            result[index] = array[i];
            index++;
        }
        return result;
    }
 
    /**
     *       array       element
     * @param array       
     * @param element   
     * @return          array       element
     */
    public static boolean isExistsElement(String[] array, String element) {
        boolean result = false;
        if (array == null) return false;
        for (int i = 0; i < array.length; i++) {
            if (array[i] == null) break;
            if (array[i].equals(element)) 
                result = true;
        }
        return result;
    }
     
    /**
     *            
     * @param array      
     * @param insertIndex     
     * @param element     
     * @return          
     */
    public static String[] insertOneElement(
            String[] array, int insertIndex, String element) {
        String[] result = new String[array.length+1];
        int index = 0;
        for (int i = 0; i < insertIndex; i++) {
            result[index] = array[i];
            index++;
        }
        result[index] = element;
        index++;
        if (insertIndex == (array.length-1))
            result[index] = array[insertIndex];
        for (int i = insertIndex; i < array.length; i++) {
            result[index] = array[i];
            index++;
        }
        return result;        
    }
}