Java, 249700 포인트 (테스트에서 Chinese Perl Goth보다 우수)
업데이트 된 순위 목록 :
4 5 6 8 9 10 11 12 13 합계
perl chinese_perl_goth.pl 6700 12300 16900 19200 23000 26100 28500 29600 32100 33900 228300
자바 Lingo 9400 14700 18900 21000 26300 28700 30300 32400 33800 34200 249700
다음은 다음을 사용하는 이전 순위 목록입니다 pit.rb.
4 5 6 8 9 10 11 12 13 합계
ruby player-example.rb 200400400500 1800 1400 1700 1600 3200 4400 15600
루비 player-example2.rb 2700 3200 2500 4300 7300 6300 8200 10400 13300 15000 73200
루비 player-example3.rb 4500 7400 9900 13700 15400 19000 19600 22300 24600 27300 163700
perl chinese_perl_goth.pl 6400 14600 16500 21000 22500 26000 27200 30600 32500 33800 231100
자바 Lingo 4800 13100 16500 21400 27200 29200 30600 32400 33700 36100 245000
** 순위 **
1 : 자바 링고 (245000)
2 : 펄 chinese_perl_goth.pl (231100)
3 : 루비 player-example3.rb (163700)
4 : 루비 player-example2.rb (73200)
5 : 루비 player-example.rb (15600)
@chineseperlgoth와 비교하여 짧은 단어 (<6 문자)로 잃어 버렸지 만 긴 단어 (> = 6 문자)로 이깁니다.
이 아이디어는 @chineseperlgoth와 유사합니다. 내 주요 아이디어는 다음 추측에 가장 많은 정보를 제공하는 추측 (나머지 가능성 중 하나가 아닌 동일한 길이의 단어 일 수 있음)을 찾는 것입니다.
현재 나는 여전히 공식을 가지고 놀고 있지만 위의 스코어 보드의 경우 최소값을 산출하는 단어를 선택합니다.
-num_confusion * 엔트로피
최신 버전은 다른 점수를 사용하여 다음 최상의 추측을 찾습니다. 현재 추측 후 "단일 가능성"의 수를 최대화합니다. 이것은 가능한 모든 후보에 대해 정리 된 단어 목록의 모든 단어를 시도하여 (시간을 절약하기 위해) 수행되며, 어떤 추측이 "단일 가능성"(즉,이 추측 후에 하나의 가능한 대답 만 있음)을 생성 할 가능성이 높은지 확인합니다. 다음 추측.
예를 들어이 실행 :
새로운 라운드를 시작하면 단어가 유익합니다
있어 : seora
보냄 :? XOXX
있어 : topsl
보냄 : XOX? X
있어 : 승려
보냄 : XO? XO
잡았다
보냄 : OXXXX
있어 : boons
보냄 : OOOOO
100 점을 얻은 라운드
처음 세 가지 추측에서, 우리는 어딘가에 "n"을 가진 "* oo * s"를 얻었고 여전히 하나의 글자를 더 찾아야합니다. 이제이 알고리즘의 장점은 그 형태와 유사한 단어를 추측하는 대신 이전 추측과 전혀 관련이없는 단어를 추측하고 더 많은 문자를 제공하려고하며 누락 된 문자를 표시한다는 것입니다. 이 경우 누락 된 "b"의 위치를 올바르게 가져오고 올바른 최종 추측 "boons"로 끝납니다.
코드는 다음과 같습니다.
import java.util.*;
import java.io.*;
class Lingo{
public static String[] guessBestList = new String[]{
"",
"a",
"sa",
"tea",
"orae",
"seora", // 5
"ariose",
"erasion",
"serotina",
"tensorial",
"psalterion", // 10
"ulcerations",
"culteranismo",
"persecutional"};
public static HashMap<Integer, ArrayList<String>> wordlist = new HashMap<Integer, ArrayList<String>>();
public static void main(String[] args){
readWordlist("wordlist.txt");
Scanner scanner = new Scanner(System.in);
int wordlen = Integer.parseInt(args[0]);
int roundNum = 5;
ArrayList<String> candidates = new ArrayList<String>();
candidates.addAll(wordlist.get(wordlen));
String guess = "";
while(roundNum-- > 0){
guess = guessBest(candidates, roundNum==4, roundNum==0);
System.out.println(guess);
String response = scanner.nextLine();
if(isAllO(response)){
break;
}
updateCandidates(candidates, guess, response);
//print(candidates);
}
}
public static void print(ArrayList<String> candidates){
for(String str: candidates){
System.err.println(str);
}
System.err.println();
}
public static void readWordlist(String path){
try{
BufferedReader reader = new BufferedReader(new FileReader(path));
while(reader.ready()){
String word = reader.readLine();
if(!wordlist.containsKey(word.length())){
wordlist.put(word.length(), new ArrayList<String>());
}
wordlist.get(word.length()).add(word);
}
} catch (Exception e){
System.exit(1);
}
}
public static boolean isAllO(String response){
for(int i=0; i<response.length(); i++){
if(response.charAt(i) != 'O') return false;
}
return true;
}
public static String getResponse(String word, String guess){
char[] wordChar = word.toCharArray();
char[] result = new char[word.length()];
Arrays.fill(result, 'X');
for(int i=0; i<guess.length(); i++){
if(guess.charAt(i) == wordChar[i]){
result[i] = 'O';
wordChar[i] = '_';
}
}
for(int i=0; i<guess.length(); i++){
if(result[i] == 'O') continue;
for(int j=0; j<wordChar.length; j++){
if(result[j] == 'O') continue;
if(wordChar[j] == guess.charAt(i)){
result[i] = '?';
wordChar[j] = '_';
break;
}
}
}
return String.valueOf(result);
}
public static void updateCandidates(ArrayList<String> candidates, String guess, String response){
for(int i=candidates.size()-1; i>=0; i--){
String candidate = candidates.get(i);
if(!response.equals(getResponse(candidate, guess))){
candidates.remove(i);
}
}
}
public static int countMatchingCandidates(ArrayList<String> candidates, String guess, String response){
int result = 0;
for(String candidate: candidates){
if(response.equals(getResponse(candidate, guess))){
result++;
}
}
return result;
}
public static String[] getSample(ArrayList<String> words, int size){
String[] result = new String[size];
int[] indices = new int[words.size()];
for(int i=0; i<words.size(); i++){
indices[i] = i;
}
Random rand = new Random(System.currentTimeMillis());
for(int i=0; i<size; i++){
int take = rand.nextInt(indices.length-i);
result[i] = words.get(indices[take]);
indices[take] = indices[indices.length-i-1];
}
return result;
}
public static String guessBest(ArrayList<String> candidates, boolean firstGuess, boolean lastGuess){
if(candidates.size() == 1){
return candidates.get(0);
}
String minGuess = candidates.get(0);
int wordlen = minGuess.length();
if(firstGuess && guessBestList[wordlen].length()==wordlen){
return guessBestList[wordlen];
}
int minMatches = Integer.MAX_VALUE;
String[] words;
if(lastGuess){
words = candidates.toArray(new String[0]);
} else if (candidates.size()>10){
words = bestWords(wordlist.get(wordlen), candidates, 25);
} else {
words = wordlist.get(wordlen).toArray(new String[0]);
}
for(String guess: words){
double sumMatches = 0;
for(String word: candidates){
int matches = countMatchingCandidates(candidates, guess, getResponse(word, guess));
if(matches == 0) matches = candidates.size();
sumMatches += (matches-1)*(matches-1);
}
if(sumMatches < minMatches){
minGuess = guess;
minMatches = sumMatches;
}
}
return minGuess;
}
public static String[] bestWords(ArrayList<String> words, ArrayList<String> candidates, int size){
int[] charCount = new int[123];
for(String candidate: candidates){
for(int i=0; i<candidate.length(); i++){
charCount[(int)candidate.charAt(i)]++;
}
}
String[] tmp = (String[])words.toArray(new String[0]);
Arrays.sort(tmp, new WordComparator(charCount));
String[] result = new String[size+Math.min(size, candidates.size())];
String[] sampled = getSample(candidates, Math.min(size, candidates.size()));
for(int i=0; i<size; i++){
result[i] = tmp[tmp.length-i-1];
if(i < sampled.length){
result[size+i] = sampled[i];
}
}
return result;
}
static class WordComparator implements Comparator<String>{
int[] charCount = null;
public WordComparator(int[] charCount){
this.charCount = charCount;
}
public Integer count(String word){
int result = 0;
int[] multiplier = new int[charCount.length];
Arrays.fill(multiplier, 1);
for(char chr: word.toCharArray()){
result += multiplier[(int)chr]*this.charCount[(int)chr];
multiplier[(int)chr] = 0;
}
return Integer.valueOf(result);
}
public int compare(String s1, String s2){
return count(s1).compareTo(count(s2));
}
}
}