1
import socket
2
import re
3
import time
4
from collections import Counter
5
from typing import List, Set, Optional, Tuple
6
from pathlib import Path
7

8
WORD_LIST_PATH = Path(__file__).with_name('wordle_words.txt')
9
if not WORD_LIST_PATH.exists():
10
    raise FileNotFoundError('wordle_words.txt not found; download the Wordle list first')
11
with open(WORD_LIST_PATH) as f:
12
    WORDS = [line.strip() for line in f if line.strip()]
13
ALLOWED_WORDS = WORDS[:]
14

15
COLOR_RE = re.compile(r'\x1b\[(\d+(?:;\d+)*)m([a-z])\x1b\[0m')
16

17

18
def evaluate(secret: str, guess: str) -> str:
19
    """Return Wordle pattern string for guess against secret using 'g', 'y', 'b'."""
20
    result = ['b'] * 5
21
    counter = Counter()
22
    for i in range(5):
23
        s = secret[i]
24
        g = guess[i]
25
        if g == s:
26
            result[i] = 'g'
27
        else:
28
            counter[s] += 1
29
    for i in range(5):
30
        if result[i] == 'g':
31
            continue
32
        g = guess[i]
33
        if counter[g] > 0:
34
            result[i] = 'y'
35
            counter[g] -= 1
36
    return ''.join(result)
37

38

39
def filter_candidates(candidates: List[str], guess: str, pattern: str) -> List[str]:
40
    return [word for word in candidates if evaluate(word, guess) == pattern]
41

42

43
def score_candidates(candidates: List[str]) -> dict:
44
    freq_total = Counter()
45
    freq_pos = [Counter() for _ in range(5)]
46
    for word in candidates:
47
        unique_letters = set(word)
48
        freq_total.update(unique_letters)
49
        for idx, ch in enumerate(word):
50
            freq_pos[idx][ch] += 1
51
    return {
52
        'total': freq_total,
53
        'pos': freq_pos,
54
    }
55

56

57
def forced_guess(candidates: List[str], allowed: List[str], remaining: int) -> Optional[str]:
58
    if len(candidates) <= 1:
59
        return candidates[0] if candidates else None
60
    if remaining <= 1:
61
        return None
62
    cache: dict[tuple[Tuple[str, ...], int], Optional[str]] = {}
63
    allowed_pool = list(dict.fromkeys(candidates + allowed[:max(20, len(candidates))]))
64

65
    def helper(cands: Tuple[str, ...], rem: int) -> Optional[str]:
66
        if len(cands) <= 1:
67
            return cands[0] if cands else None
68
        if rem <= 1:
69
            return None
70
        key = (cands, rem)
71
        if key in cache:
72
            return cache[key]
73
        for word in allowed_pool:
74
            partitions: dict[str, List[str]] = {}
75
            for secret in cands:
76
                pattern = evaluate(secret, word)
77
                partitions.setdefault(pattern, []).append(secret)
78
            ok = True
79
            for pattern, subset in partitions.items():
80
                if pattern == 'ggggg':
81
                    continue
82
                res = helper(tuple(sorted(subset)), rem - 1)
83
                if res is None:
84
                    ok = False
85
                    break
86
            if ok:
87
                cache[key] = word
88
                return word
89
        cache[key] = None
90
        return None
91

92
    return helper(tuple(sorted(candidates)), remaining)
93

94

95
def minimax_guess(candidates: List[str], allowed: List[str], used: Set[str]) -> str:
96
    best_word = None
97
    best_score = float('inf')
98
    best_is_candidate = False
99
    for word in allowed:
100
        if word in used:
101
            continue
102
        partitions = {}
103
        for secret in candidates:
104
            pattern = evaluate(secret, word)
105
            partitions[pattern] = partitions.get(pattern, 0) + 1
106
        score = max(partitions.values())
107
        is_candidate = word in candidates
108
        if score < best_score or (score == best_score and is_candidate and not best_is_candidate):
109
            best_score = score
110
            best_word = word
111
            best_is_candidate = is_candidate
112
        if best_score == 1 and best_is_candidate:
113
            break
114
    return best_word if best_word else candidates[0]
115

116

117
def choose_guess(candidates: List[str], allowed: List[str], used: Set[str], remaining_attempts: int) -> str:
118
    if not candidates:
119
        return 'arise'
120
    if len(candidates) == 1:
121
        return candidates[0]
122
    if len(candidates) <= 8:
123
        forced = forced_guess(candidates, allowed, remaining_attempts)
124
        if forced:
125
            return forced
126
    if len(candidates) <= 20:
127
        return minimax_guess(candidates, allowed, used)
128
    letter_freq = Counter()
129
    pos_freq = [Counter() for _ in range(5)]
130
    for word in candidates:
131
        unique_letters = set(word)
132
        letter_freq.update(unique_letters)
133
        for idx, ch in enumerate(word):
134
            pos_freq[idx][ch] += 1
135
    letter_set = set(letter_freq)
136
    best_word = None
137
    best_score = -1.0
138
    for word in allowed:
139
        if word in used:
140
            continue
141
        unique_letters = set(word)
142
        if not unique_letters & letter_set:
143
            continue
144
        score = sum(letter_freq[ch] for ch in unique_letters)
145
        positional = sum(pos_freq[idx][ch] for idx, ch in enumerate(word))
146
        if word in candidates:
147
            score += positional
148
        else:
149
            score += 0.2 * positional
150
        duplicate_penalty = len(word) - len(unique_letters)
151
        if duplicate_penalty:
152
            score -= duplicate_penalty * 0.5
153
        if score > best_score:
154
            best_score = score
155
            best_word = word
156
    if best_word is None:
157
        for word in candidates:
158
            if word not in used:
159
                return word
160
        return candidates[0]
161
    return best_word
162

163

164
def parse_feedback(text: str):
165
    matches = COLOR_RE.findall(text)
166
    if len(matches) < 5:
167
        raise ValueError(f"Unable to parse feedback: {text!r}")
168
    matches = matches[-5:]
169
    letters = []
170
    pattern_chars = []
171
    for code, letter in matches:
172
        color = code.split(';')[-1]
173
        if color == '32':
174
            pattern_chars.append('g')
175
        elif color == '33':
176
            pattern_chars.append('y')
177
        else:
178
            pattern_chars.append('b')
179
        letters.append(letter)
180
    return ''.join(letters), ''.join(pattern_chars)
181

182

183
def read_until(sock: socket.socket, targets: List[bytes], timeout: float = 5.0) -> bytes:
184
    sock.settimeout(timeout)
185
    data = b''
186
    deadline = time.time() + timeout
187
    while time.time() < deadline:
188
        for target in targets:
189
            if target in data:
190
                return data
191
        try:
192
            chunk = sock.recv(4096)
193
        except socket.timeout:
194
            continue
195
        if not chunk:
196
            return data
197
        data += chunk
198
    return data
199

200

201
def drain_socket(sock: socket.socket, timeout: float = 2.0) -> str:
202
    sock.settimeout(timeout)
203
    chunks = []
204
    while True:
205
        try:
206
            chunk = sock.recv(4096)
207
        except socket.timeout:
208
            break
209
        if not chunk:
210
            break
211
        chunks.append(chunk)
212
        if b'FLAG{' in chunk.upper():
213
            break
214
    if not chunks:
215
        return ''
216
    return b''.join(chunks).decode('utf-8', errors='replace')
217

218

219
def main():
220
    global ALLOWED_WORDS
221
    sock = socket.create_connection(('3.39.86.84', 31337))
222
    try:
223
        initial = read_until(sock, [b'Enter your guess:'])
224
        if b'FLAG{' in initial.upper():
225
            print(initial.decode('utf-8', errors='replace'))
226
            return
227
        print('Connected to server, starting solver...')
228
        round_num = 1
229
        while True:
230
            candidates = WORDS[:]
231
            used = set()
232
            solved = False
233
            attempt = 1
234
            max_attempts = 6
235
            attempts_used = None
236
            last_followup = b''
237
            while attempt <= max_attempts:
238
                remaining = max_attempts - attempt + 1
239
                if attempt == 1:
240
                    first_choices = [w for w in ('arise', 'stare', 'alone', 'irate', 'raise') if w in candidates]
241
                    guess = first_choices[0] if first_choices else choose_guess(candidates, ALLOWED_WORDS, used, remaining)
242
                else:
243
                    guess = choose_guess(candidates, ALLOWED_WORDS, used, remaining)
244
                print(f'[Round {round_num} Attempt {attempt}] {guess}')
245
                sock.sendall((guess + '\n').encode())
246
                response = read_until(sock, [b'Enter your guess:', b'FLAG', b'Flag', b'Correct', b'Round '], timeout=2.0)
247
                decoded = response.decode('utf-8', errors='replace')
248
                if 'Invalid word' in decoded:
249
                    print(f'  -> rejected by server')
250
                    if guess in ALLOWED_WORDS:
251
                        ALLOWED_WORDS = [w for w in ALLOWED_WORDS if w != guess]
252
                    candidates = [word for word in candidates if word != guess]
253
                    continue
254
                if 'You lost!' in decoded:
255
                    raise RuntimeError(f'Lost round {round_num}')
256
                used.add(guess)
257
                if 'Correct!' in decoded:
258
                    solved = True
259
                    attempts_used = attempt
260
                    print(f'  -> solved (server confirmed)')
261
                    followup = read_until(sock, [b'Enter your guess:', b'Round', b'FLAG', b'Flag'], timeout=2.0)
262
                    if followup:
263
                        last_followup = followup
264
                        if b'FLAG{' in followup.upper():
265
                            print(followup.decode('utf-8', errors='replace'))
266
                            return
267
                    break
268
                before = len(candidates)
269
                try:
270
                    _, pattern = parse_feedback(decoded)
271
                except ValueError:
272
                    if 'FLAG{' in decoded.upper():
273
                        print(decoded)
274
                        return
275
                    raise
276
                if pattern == 'ggggg':
277
                    solved = True
278
                    attempts_used = attempt
279
                    print('  -> solved exactly')
280
                    followup = read_until(sock, [b'Enter your guess:', b'Round', b'FLAG', b'Flag'], timeout=2.0)
281
                    if followup:
282
                        last_followup = followup
283
                        if b'FLAG{' in followup.upper():
284
                            print(followup.decode('utf-8', errors='replace'))
285
                            return
286
                    break
287
                candidates = filter_candidates(candidates, guess, pattern)
288
                print(f'  -> pattern {pattern}, {before} -> {len(candidates)} candidates')
289
                attempt += 1
290
            if not solved:
291
                raise RuntimeError(f'Failed to solve round {round_num}')
292
            if attempts_used is not None:
293
                print(f'Round {round_num} solved in {attempts_used} attempts')
294
            if round_num >= 100:
295
                if last_followup:
296
                    text_out = last_followup.decode('utf-8', errors='replace')
297
                    print(text_out)
298
                    if 'FLAG{' in text_out.upper():
299
                        return
300
                remainder = drain_socket(sock)
301
                if remainder:
302
                    print(remainder)
303
                return
304
            round_num += 1
305
    finally:
306
        sock.close()
307

308

309
if __name__ == '__main__':
310
    main()

1
[Round 100 Attempt 4] snack
2
  -> solved (server confirmed)
3
Round 100 solved in 4 attempts
4
--------------------------------
5
Congratulations! You cleared 100 rounds!
6
Here is your flag: hspace{830fc3076a183c74dfa2e053b689747f}