Hello Navi

import hashlib, string, random

# WC3: md5(md5(plaintext) + "zomgsalt")
digest = hashlib.md5(
    hashlib.md5(word.encode()).hexdigest().encode() + b"zomgsalt"
).hexdigest()

# WC4: sha1("zomgsalt4" + password + salt + "zomgsalt4") + salt
t = hashlib.sha1(b"zomgsalt4" + password.encode() + salt.encode() + b"zomgsalt4")
digest = t.hexdigest() + salt  # salt 追加到 hash 末尾

import hashlib, string

# 从页面提取 hash 列表
wc3_hashes = [...]   # 17 条 hex hash
wc4_raw = [...]      # 17 条 hash+salt（44 hex chars = 40 hash + 8 salt）

# 字典攻击
for word in dictionary:
    # WC3
    h = hashlib.md5(hashlib.md5(word.encode()).hexdigest().encode() + b"zomgsalt").hexdigest()
    if h in wc3_hashes:
        found_wc3.append((len(word), word))

    # WC4 — 每条 hash 的 salt 不同
    for entry in wc4_raw:
        target_hash = entry[:-8]   # 前 40 hex = SHA1
        salt = entry[-8:]          # 后 8 hex = 4 bytes salt
        t = hashlib.sha1(b"zomgsalt4" + word.encode() + bytes.fromhex(salt) + b"zomgsalt4").hexdigest()
        if t == target_hash:
            found_wc4.append((len(word), word))

found_wc3.sort(reverse=True)
found_wc4.sort(reverse=True)
answer = f"{found_wc3[0][1]},{found_wc3[1][1]},{found_wc4[0][1]},{found_wc4[1][1]}"

from sympy.ntheory.modular import crt
from sympy import integer_nthroot

C, mod = crt([n1, n2, n3], [c1, c2, c3])
m, exact = integer_nthroot(int(C), 3)
assert exact
print(str(m)[-20:])

import re, urllib.request

URL = 'http://www.wechall.net/en/challenge/Z/save_the_world/index.php'
COOKIE = 'WC=...'

req = urllib.request.Request(URL, headers={'Cookie': COOKIE})
html = urllib.request.urlopen(req, timeout=20).read().decode()
clean = re.sub(r'<br\s*/?>', '', html)  # 关键：去掉 <br/> 标签

def extract(pattern):
    m = re.search(pattern, clean)
    return int(m.group(1).replace('\n', '').replace(' ', ''))

n1 = extract(r'n1=(\d[\d\s\n]*?)')
c1 = extract(r'c1=(\d[\d\s\n]*?)')
n2 = extract(r'n2=(\d[\d\s\n]*?)')
c2 = extract(r'c2=(\d[\d\s\n]*?)')
n3 = extract(r'n3=(\d[\d\s\n]*?)')
c3 = extract(r'c3=(\d[\d\s\n]*?)')

from sympy.ntheory.modular import crt
from sympy import integer_nthroot

C, mod = crt([n1, n2, n3], [c1, c2, c3])
m, exact = integer_nthroot(int(C), 3)
assert exact
print(str(m)[-20:])

def gizcrypt_decrypt(ct, key):
    klen = len(key)
    x, k = 1, -1
    e = 101  # ord('e')
    plain = bytearray()
    for b in ct:
        k += x
        if k >= klen:
            k = 0
            x += 1
            if x >= klen:
                x = 1
        plain.append(key[k % klen] ^ b ^ e)
    return bytes(plain)

import string
from collections import Counter

alphabet = string.ascii_letters  # 52 chars

def key_index_seq(length, klen=11):
    seq = []
    x, k = 1, -1
    for _ in range(length):
        k += x
        if k >= klen:
            k = 0; x += 1
            if x >= klen: x = 1
        seq.append(k % klen)
    return seq

seq = key_index_seq(len(ct))
groups = {i: [] for i in range(11)}
for i, kpos in enumerate(seq):
    groups[kpos].append(ct[i])

key = []
for pos in range(11):
    best = None
    best_score = -9999
    for k in alphabet:
        plain = bytes(k ^ c ^ 101 for c in groups[pos])
        score = sum(4 if b in (32,101,116,97,111) else
                    2 if chr(b).isalpha() or b in (44,46,39) else
                    1 if 32 <= b < 127 else -10
                    for b in plain)
        if score > best_score:
            best_score = score
            best = k
    key.append(best)

full_key = ''.join(key)  # ItsPassword
plain = gizcrypt_decrypt(ct, full_key.encode())
print(plain.decode())     # 包含 answer: 9DD4752982DC

import requests, re

BASE = 'https://www.wechall.net/challenge/lettergrid'
sess = requests.Session()
sess.cookies.set('WC', '...', domain='www.wechall.net')

# 1. 构建 Trie（单词 >= 6 字符）
class TrieNode:
    __slots__ = ('children', 'is_word')
    def __init__(self):
        self.children = {}
        self.is_word = False

root = TrieNode()
for word in open('/usr/share/dict/words'):
    w = word.strip().lower()
    if len(w) >= 6:
        node = root
        for ch in w:
            node = node.children.setdefault(ch, TrieNode())
        node.is_word = True

# 2. 获取网格
r = sess.get(f'{BASE}/generate.php')
match = re.search(r'<pre>(.*?)</pre>', r.text, re.DOTALL)
grid = [list(line.strip().lower()) for line in match.group(1).strip().split('\n') if line.strip()]
ROWS, COLS = len(grid), len(grid[0])

# 3. 8 方向搜索（用 Trie 实时剪枝）
DIRS = [(0,1),(0,-1),(1,0),(-1,0),(1,1),(1,-1),(-1,1),(-1,-1)]
found = {}  # word -> (start_r, start_c)

for r in range(ROWS):
    for c in range(COLS):
        for dr, dc in DIRS:
            node, last_word, last_len = root, None, 0
            for step in range(max(ROWS, COLS)):
                nr, nc = r + dr*step, c + dc*step
                if not (0 <= nr < ROWS and 0 <= nc < COLS): break
                ch = grid[nr][nc]
                if ch not in node.children: break
                node = node.children[ch]
                if node.is_word:
                    word = ''.join(grid[r+dr*s][c+dc*s] for s in range(step+1))
                    if word not in found:
                        found[word] = (r, c)

# 4. 按起始位置排序后提交
answer = ''.join(sorted(found.keys(), key=lambda w: found[w]))
print(f'Found {len(found)} words: {sorted(found.keys())}')

r = sess.get(f'{BASE}/index.php', params={'solution': answer, 'cmd': 'Submit Answer'})
if 'solved' in r.text.lower() or 'correct' in r.text.lower():
    print('SOLVED!')

import requests

BASE = 'https://www.wechall.net/en/challenge/training/programming/knapsaak'
COOKIES = {'WC': '...'}

def parse_problem(text):
    items = []
    meta = {}
    for line in text.strip().split('\n'):
        if '=' not in line: continue
        k, v = line.split('=', 1)
        k, v = k.strip(), v.strip()
        if k in ('Items', 'Sum', 'Stock', 'Level'):
            meta[k] = int(v)
        else:
            items.append((k, int(v)))   # (name, price)
    return items, meta['Items'], meta['Sum'], meta['Stock']

def solve(items, need_count, need_sum, stock):
    n = len(items)
    prices = [p for _, p in items]
    names = [n for n, _ in items]
    # 按价格降序排列（剪枝效果更好）
    order = sorted(range(n), key=lambda i: -prices[i])
    sp = [prices[i] for i in order]

    memo = {}
    def dfs(idx, ri, rs):
        if ri == 0 and rs == 0:
            return [0] * (n - idx)
        if idx == n or ri < 0 or rs < 0:
            return None
        key = (idx, ri, rs)
        if key in memo:
            return memo[key]
        # 剪枝：剩余件数超出库存限制
        if ri > stock * (n - idx):
            memo[key] = None; return None
        # 剪枝：剩余金额超出价格范围
        min_p, max_p = min(sp[idx:]), max(sp[idx:])
        if rs < ri * min_p or rs > ri * max_p:
            memo[key] = None; return None

        p = sp[idx]
        for qty in range(min(stock, ri, rs // p) + 1):
            sub = dfs(idx + 1, ri - qty, rs - qty * p)
            if sub is not None:
                memo[key] = [qty] + sub
                return memo[key]
        memo[key] = None
        return None

    qs = dfs(0, need_count, need_sum)
    if qs is None: return None
    # 按原始顺序还原
    quants = [0] * n
    for i, orig_idx in enumerate(order):
        quants[orig_idx] = qs[i]
    # 拼接答案：qtyName...
    return ''.join(str(quants[i]) + names[i]
                   for i in range(n) if quants[i] > 0)

s = requests.Session()
s.cookies.update(COOKIES)

for round_num in range(5):
    resp = s.get(f'{BASE}/problem.php')
    items, cnt, target, stock = parse_problem(resp.text)
    answer = solve(items, cnt, target, stock)
    resp2 = s.get(f'{BASE}/answer.php', params={'answer': answer})
    print(f'Round {round_num+1}: {resp2.text.strip()}')

def from_base(s, charset, base):
    value = 0
    table = {ch: i for i, ch in enumerate(charset[:base])}
    for ch in s:
        value = value * base + table[ch]
    return value

def to_base(n, charset, base):
    if n == 0:
        return charset[0]
    out = []
    while n:
        n, r = divmod(n, base)
        out.append(charset[r])
    return ''.join(reversed(out))

import re, sys
from urllib.request import Request, urlopen

CHALL_URL = 'http://www.wechall.net/en/challenge/anto/FlowOverAstronomy/index.php'
COOKIE = 'WC=...'

def fetch():
    req = Request(CHALL_URL, headers={'Cookie': COOKIE})
    return urlopen(req, timeout=10).read().decode()

def from_base(s, charset, base):
    table = {ch: i for i, ch in enumerate(charset[:base])}
    v = 0
    for ch in s: v = v * base + table[ch]
    return v

def to_base(n, charset, base):
    if n == 0: return charset[0]
    out = []
    while n: n, r = divmod(n, base); out.append(charset[r])
    return ''.join(reversed(out))

html = fetch()
# Parse parameters
charset  = re.search(r'Charset:\s*(\S+)', html).group(1)
in_base  = int(re.search(r'Input Base:\s*(\d+)', html).group(1))
out_base = int(re.search(r'Solution Base:\s*(\d+)', html).group(1))
# Parse equation — split on operators, handle multi-line
eq_match = re.search(r'Equation\s*\n(.*?)(?=\n©)', html, re.DOTALL)
eq = eq_match.group(1).replace('\n', '').strip()

# Evaluate: split by + first, then *
terms = eq.split('+')
product_terms = terms[0].split('*')
add_term = terms[1].strip()

result = 1
for t in product_terms:
    result *= from_base(t.strip(), charset, in_base)
result += from_base(add_term, charset, in_base)

answer = to_base(result, charset, out_base)
print(answer)  # 提交这个值

import sys
P = sys.hash_info.modulus  # 64-bit CPython: 2**61 - 1 = 2305843009213693951

import sys
P = sys.hash_info.modulus
candidate = 31337 + P  # 2305843009213725288
print(hash(candidate))  # 31337

import sys

def fly_away(num: int) -> bool:
    return hash(num) == 31337

P = sys.hash_info.modulus          # 2**61 - 1
num = 31337 + P                    # 2305843009213725288
assert fly_away(num)               # True
print(num)                         # 提交这个数

import colorsys

r, g, b = 135, 194, 41

# RGB -> HSV
h, s, v = colorsys.rgb_to_hsv(r/255, g/255, b/255)
# h = 83° (色相角度), s = 79% (饱和度), v = 76% (明度)

# HSV -> RGB (可逆)
r2, g2, b2 = colorsys.hsv_to_rgb(h, s, v)
# (r2,g2,b2) == (135,194,41)  # 无损还原

#!/usr/bin/env python3
from PIL import Image
import colorsys
from collections import Counter

img = Image.open('caterpillar.png').convert('RGBA')
w, h = img.size

# 逐列取最常见的非白色 Hue
x_hues = {}
for x in range(w):
    hues = []
    for y in range(h):
        r, g, b, a = img.getpixel((x, y))
        if (r, g, b) == (255, 255, 255):
            continue
        h_val, _, _ = colorsys.rgb_to_hsv(r/255, g/255, b/255)
        hues.append(round(h_val * 360))
    if hues:
        x_hues[x] = Counter(hues).most_common(1)[0][0]

# 合并连续相同 Hue 为段，只保留稳定段（>=10 列宽）
result = []
run_h, run_start, run_len = None, None, 0
for x in range(w):
    h = x_hues.get(x)
    if h == run_h:
        run_len += 1
    else:
        if run_len >= 10 and 32 <= run_h <= 126:
            result.append(chr(run_h))
        run_h, run_start, run_len = h, x, 1

if run_len >= 10 and 32 <= run_h <= 126:
    result.append(chr(run_h))

decoded = ''.join(result)
print(f'Decoded Hue sequence: {decoded}')
print(f'Answer (last word):   {decoded.split()[-1]}')