下载地址：http://lanzou.com.cn/id539439c

项目结构列表：

Project Structure

Folder : yinhangtupilianghejisuanai

Files : 26

Size : 101.4 KB

Generated: 2026-03-21 15:55:08

yinhangtupilianghejisuanai/
├── README.md [206 B]
├── config/
│ ├── Client.xml [1.7 KB]
│ ├── Queue.xml [1.6 KB]
│ ├── Resolver.json [706 B]
│ └── Worker.json [706 B]
├── extensions/
├── kubernetes/
│ ├── Controller.js [4.4 KB]
│ └── Util.py [5.7 KB]
├── package.json [706 B]
├── pom.xml [1.7 KB]
├── projection/
│ ├── Manager.js [3.2 KB]
│ ├── Parser.py [6.3 KB]
│ ├── Scheduler.py [4.5 KB]
│ ├── Service.js [4.8 KB]
│ └── Validator.js [4.2 KB]
├── records/
│ ├── Dispatcher.py [4 KB]
│ ├── Engine.py [4.9 KB]
│ ├── Handler.java [7.8 KB]
│ └── Helper.js [3 KB]
└── src/
├── main/
│ ├── java/
│ │ ├── Buffer.java [4.4 KB]
│ │ ├── Builder.java [5.7 KB]
│ │ ├── Cache.java [6.5 KB]
│ │ ├── Converter.java [4.7 KB]
│ │ ├── Factory.java [7.1 KB]
│ │ ├── Processor.java [5.6 KB]
│ │ └── Wrapper.java [7.3 KB]
│ └── resources/
└── test/
└── java/

python

!/usr/bin/env python3

-- coding: utf-8 --

"""
Aheui 代码生成器 - 完整版
支持: 算术运算、条件判断、循环、函数、多种数据结构
"""

import random
from typing import List, Tuple, Optional, Dict, Any

class AheuiGenerator:
"""Aheui 语言代码生成器"""

# 韩文字符映射表
CHOSEONG = {
    # 基本操作
    'push': 'ㅇ',      # 推入数字
    'add': 'ㄷ',       # 加法 (a+b)
    'sub': 'ㄸ',       # 减法 (a-b)
    'mul': 'ㅂ',       # 乘法
    'div': 'ㅃ',       # 除法 (整除)
    'mod': 'ㅅ',       # 取模
    'cmp': 'ㅈ',       # 比较 (大于)
    'dup': 'ㅎ',       # 复制栈顶
    'swap': 'ㅋ',      # 交换栈顶两个元素
    'pop': 'ㅌ',       # 弹出
    'out_num': 'ㅍ',   # 输出数字
    'out_char': 'ㅊ',  # 输出字符
    'in_num': 'ㅉ',    # 输入数字
    'in_char': 'ㄲ',   # 输入字符
    'end': 'ㅎ',       # 结束程序
    'nop': 'ㅁ',       # 空操作
    'jump': 'ㄱ',      # 跳转
    'call': 'ㄴ',      # 调用
    'ret': 'ㄹ',       # 返回
    # 扩展操作
    'and': 'ㅆ',       # 逻辑与
    'or': 'ㅉ',        # 逻辑或
    'not': 'ㅊ',       # 逻辑非
    'shl': 'ㅋ',       # 左移
    'shr': 'ㅌ',       # 右移
}

JUNGSEONG = {
    'stack': 'ㅏ',      # 当前栈
    'queue': 'ㅓ',      # 当前队列
    'stack2': 'ㅗ',     # 第二个栈
    'queue2': 'ㅜ',     # 第二个队列
    'stack3': 'ㅛ',     # 第三个栈
    'queue3': 'ㅠ',     # 第三个队列
    'ctrl': 'ㅡ',       # 控制流
    'dir': 'ㅣ',        # 方向控制
}

JONGSEONG = {
    0: '', 1: 'ㄱ', 2: 'ㄴ', 3: 'ㄷ', 4: 'ㄹ',
    5: 'ㅁ', 6: 'ㅂ', 7: 'ㅅ', 8: 'ㅇ', 9: 'ㅈ',
    10: 'ㅊ', 11: 'ㅋ', 12: 'ㅌ', 13: 'ㅍ', 14: 'ㅎ',
}

NUMBERS = {
    0: '아', 1: '애', 2: '야', 3: '얘',
    4: '어', 5: '에', 6: '여', 7: '예',
    8: '오', 9: '와', 10: '외', 11: '위',
}

DIRECTIONS = {
    'right': 'ㅏ', 'left': 'ㅓ', 'down': 'ㅗ', 'up': 'ㅜ',
    'right_down': 'ㅛ', 'right_up': 'ㅠ', 'left_down': 'ㅑ', 'left_up': 'ㅕ'
}

def __init__(self):
    self.program = []
    self.labels = {}
    self.variables = {}
    self.stack_depth = 0

def generate_push(self, value: int) -> str:
    """生成推入数字的代码"""
    if value < 0:
        raise ValueError("不支持负数直接推入，请使用运算")

    if value <= 11:
        return self.NUMBERS.get(value, '아')

    # 多位数字分解
    digits = []
    while value > 0:
        digits.append(value % 10)
        value //= 10

    result = ''
    for d in reversed(digits):
        result += self.NUMBERS[d]
    return result

def generate_op(self, op: str, storage: str = 'stack') -> str:
    """生成操作码"""
    if op not in self.CHOSEONG:
        raise ValueError(f"未知操作: {op}")
    if storage not in self.JUNGSEONG:
        raise ValueError(f"未知存储: {storage}")

    # 部分操作需要终声修饰
    base = self.CHOSEONG[op] + self.JUNGSEONG[storage]

    # 添加随机终声以增加代码多样性（可选）
    if op in ['push', 'nop', 'end']:
        pass  # 这些已有固定终声
    else:
        # 可添加随机终声，但不影响功能
        pass

    return base

def arithmetic(self, a: int, b: int, op: str) -> List[str]:
    """生成算术运算代码"""
    code = []
    code.append(self.generate_push(a))
    code.append(self.generate_push(b))
    code.append(self.generate_op(op))
    return code

def add(self, a: int, b: int) -> List[str]:
    """生成加法代码"""
    return self.arithmetic(a, b, 'add')

def sub(self, a: int, b: int) -> List[str]:
    """生成减法代码"""
    return self.arithmetic(a, b, 'sub')

def mul(self, a: int, b: int) -> List[str]:
    """生成乘法代码"""
    return self.arithmetic(a, b, 'mul')

def div(self, a: int, b: int) -> List[str]:
    """生成除法代码"""
    return self.arithmetic(a, b, 'div')

def mod(self, a: int, b: int) -> List[str]:
    """生成取模代码"""
    return self.arithmetic(a, b, 'mod')

def compare(self, a: int, b: int) -> List[str]:
    """生成比较代码，返回 1 如果 a > b 否则 0"""
    code = []
    code.append(self.generate_push(a))
    code.append(self.generate_push(b))
    code.append(self.generate_op('cmp'))
    return code

def fibonacci(self, n: int) -> List[str]:
    """生成斐波那契数列生成器"""
    code = []
    # 初始化
    code.append(self.generate_push(1))  # F(1)
    code.append(self.generate_push(1))  # F(2)

    for i in range(n):
        # 计算下一个
        code.append(self.generate_op('dup'))      # 复制栈顶
        code.append(self.generate_op('swap'))     # 交换
        code.append(self.generate_op('add'))      # 相加
        code.append(self.generate_op('swap'))     # 交换回来
        # 输出当前值
        code.append(self.generate_op('dup'))
        code.append(self.generate_op('out_num'))

    return code

def factorial(self, n: int) -> List[str]:
    """生成阶乘计算器"""
    code = []
    code.append(self.generate_push(1))  # 结果初始为1
    code.append(self.generate_push(n))  # 计数器

    # 循环
    for i in range(n, 0, -1):
        code.append(self.generate_op('dup'))   # 复制计数器
        code.append(self.generate_op('mul'))   # 相乘
        code.append(self.generate_push(1))     # 推入1
        code.append(self.generate_op('sub'))   # 计数器减1

    code.append(self.generate_op('out_num'))   # 输出结果
    return code

def power(self, base: int, exp: int) -> List[str]:
    """生成幂运算"""
    code = []
    code.append(self.generate_push(1))  # 结果

    for _ in range(exp):
        code.append(self.generate_push(base))
        code.append(self.generate_op('mul'))

    return code

def gcd(self, a: int, b: int) -> List[str]:
    """生成最大公约数计算器（欧几里得算法）"""
    code = []
    code.append(self.generate_push(a))
    code.append(self.generate_push(b))

    # 循环直到栈顶为0
    for _ in range(100):  # 足够多的循环
        # 计算 a % b
        code.append(self.generate_op('dup'))      # 复制b
        code.append(self.generate_op('swap'))     # 交换，得到 a, b, b
        code.append(self.generate_op('swap'))     # 得到 b, a, b
        code.append(self.generate_op('mod'))      # 得到 a % b, b

        # 检查是否为零
        code.append(self.generate_op('dup'))      # 复制余数
        code.append(self.generate_push(0))
        code.append(self.generate_op('cmp'))      # 比较余数是否 > 0
        # 如果余数为0则结束

    return code

def prime_sieve(self, limit: int) -> List[str]:
    """生成素数筛法（埃拉托斯特尼筛法）"""
    code = []
    # 简化版：检查每个数是否为素数
    for num in range(2, limit + 1):
        is_prime = True
        for i in range(2, int(num ** 0.5) + 1):
            if num % i == 0:
                is_prime = False
                break
        if is_prime:
            code.append(self.generate_push(num))
            code.append(self.generate_op('out_num'))

    return code

def collatz(self, n: int) -> List[str]:
    """生成考拉兹猜想序列"""
    code = []
    code.append(self.generate_push(n))

    for _ in range(100):  # 限制步数
        # 输出当前值
        code.append(self.generate_op('dup'))
        code.append(self.generate_op('out_num'))

        # 检查是否为1
        code.append(self.generate_op('dup'))
        code.append(self.generate_push(1))
        code.append(self.generate_op('cmp'))

        # 如果是偶数，除以2；如果是奇数，3n+1
        # 这里简化：只生成序列，不实现条件跳转

    return code

def generate_program(self, instructions: List[str], 
                    width: int = 10, 
                    height: int = 10,
                    random_layout: bool = False) -> str:
    """
    生成完整程序，支持二维布局
    """
    if random_layout:
        return self._generate_random_layout(instructions, width, height)
    else:
        return ''.join(instructions)

def _generate_random_layout(self, instructions: List[str], 
                           width: int, height: int) -> str:
    """生成随机二维布局"""
    # 创建网格
    grid = [[' ' for _ in range(width)] for _ in range(height)]

    # 放置指令
    for i, instr in enumerate(instructions):
        x = i % width
        y = (i // width) % height
        grid[y][x] = instr

    # 添加方向控制符确保程序流动
    # 在每行末尾添加右箭头
    for y in range(height):
        if y < height - 1:
            grid[y][width-1] = self.DIRECTIONS['down']

    # 转换为字符串
    result = ''
    for y in range(height):
        result += ''.join(grid[y]) + '\n'

    return result

def generate_with_comments(self, instructions: List[str], 
                           comments: List[str]) -> str:
    """生成带注释的代码"""
    result = []
    for instr, comment in zip(instructions, comments):
        result.append(f"{instr}  # {comment}")
    return '\n'.join(result)

def optimize(self, instructions: List[str]) -> List[str]:
    """优化生成的代码（去除冗余操作）"""
    optimized = []
    i = 0
    while i < len(instructions):
        # 检测 push-pop 对
        if (i + 1 < len(instructions) and 
            instructions[i] in self.NUMBERS.values() and 
            instructions[i+1] == self.generate_op('pop')):
            i += 2  # 跳过这对
            continue
        optimized.append(instructions[i])
        i += 1
    return optimized

def generate_expression(self, expr: str) -> List[str]:
    """
    生成算术表达式代码（支持 + - * / 和括号）
    """
    # 简化版：将表达式转换为逆波兰表达式
    tokens = expr.replace('(', ' ( ').replace(')', ' ) ').split()

    def infix_to_rpn(tokens):
        precedence = {'+': 1, '-': 1, '*': 2, '/': 2}
        output = []
        stack = []

        for token in tokens:
            if token.isdigit():
                output.append(int(token))
            elif token in precedence:
                while (stack and stack[-1] in precedence and 
                       precedence[stack[-1]] >= precedence[token]):
                    output.append(stack.pop())
                stack.append(token)
            elif token == '(':
                stack.append(token)
            elif token == ')':
                while stack and stack[-1] != '(':
                    output.append(stack.pop())
                stack.pop()

        while stack:
            output.append(stack.pop())

        return output

    rpn = infix_to_rpn(tokens)

    # 生成代码
    code = []
    stack = []
    for token in rpn:
        if isinstance(token, int):
            code.append(self.generate_push(token))
            stack.append(token)
        else:
            code.append(self.generate_op(token))
            # 更新栈状态
            if len(stack) >= 2:
                b = stack.pop()
                a = stack.pop()
                if token == '+':
                    stack.append(a + b)
                elif token == '-':
                    stack.append(a - b)
                elif token == '*':
                    stack.append(a * b)
                elif token == '/':
                    stack.append(a // b)

    return code

def generate_loop(self, body: List[str], count: int) -> List[str]:
    """生成循环代码"""
    code = []
    code.append(self.generate_push(count))  # 循环计数器

    for _ in range(count):
        code.extend(body)
        # 计数器减1
        code.append(self.generate_push(1))
        code.append(self.generate_op('sub'))

    return code

def generate_function(self, name: str, body: List[str]) -> Dict[str, List[str]]:
    """生成函数定义"""
    self.labels[name] = body
    return {name: body}

def call_function(self, name: str) -> List[str]:
    """生成函数调用"""
    if name not in self.labels:
        raise ValueError(f"未定义的函数: {name}")
    return [self.generate_op('call')] + self.labels[name] + [self.generate_op('ret')]

def main():
"""演示生成器的各种功能"""
gen = AheuiGenerator()

print("=" * 60)
print("Aheui 代码生成器 - 完整演示")
print("=" * 60)

# 1. 基本算术
print("\n1. 基本算术运算:")
code_add = gen.add(15, 27)
print(f"   15 + 27 = {''.join(code_add)}")

code_mul = gen.mul(12, 8)
print(f"   12 * 8 = {''.join(code_mul)}")

# 2. 斐波那契数列
print("\n2. 斐波那契数列（前10项）:")
fib_code = gen.fibonacci(10)
print(f"   代码长度: {len(fib_code)} 字符")
print(f"   {''.join(fib_code[:20])}...")

# 3. 阶乘计算
print("\n3. 阶乘计算（10!）:")
fact_code = gen.factorial(10)
print(f"   代码: {''.join(fact_code)}")

# 4. 幂运算
print("\n4. 幂运算（2^10）:")
power_code = gen.power(2, 10)
print(f"   代码: {''.join(power_code)}")

# 5. 算术表达式
print("\n5. 算术表达式（(3+5)*2-4/2）:")
expr_code = gen.generate_expression("(3+5)*2-4/2")
print(f"   代码: {''.join(expr_code)}")

# 6. 循环
print("\n6. 循环（打印1-5）:")
loop_body = [gen.generate_push(i) for i in range(1, 6)]
loop_body.append(gen.generate_op('out_num'))
loop_code = gen.generate_loop(loop_body, 1)
print(f"   代码: {''.join(loop_code)}")

# 7. 优化示例
print("\n7. 代码优化:")
unoptimized = [gen.generate_push(5), gen.generate_push(3), 
               gen.generate_op('add'), gen.generate_op('pop')]
optimized = gen.optimize(unoptimized)
print(f"   优化前: {''.join(unoptimized)}")
print(f"   优化后: {''.join(optimized)}")

# 8. 二维布局
print("\n8. 二维布局（5x5网格）:")
simple_code = gen.add(10, 20)
layout = gen.generate_program(simple_code, width=5, height=5, random_layout=True)
print(layout)

# 9. 素数生成
print("\n9. 素数生成（2-20）:")
prime_code = gen.prime_sieve(20)
print(f"   代码: {''.join(prime_code)}")

# 10. 完整程序示例
print("\n10. 完整程序示例:")
full_program = []
full_program.extend(gen.add(100, 200))
full_program.append(gen.generate_op('out_num'))
full_program.append(gen.generate_push(42))
full_program.append(gen.generate_op('out_num'))
full_program.append(gen.generate_op('end'))

print(f"   代码: {''.join(full_program)}")

# 11. 生成器性能统计
print("\n" + "=" * 60)
print("生成器统计:")
print(f"   支持的操作数: {len(gen.CHOSEONG)}")
print(f"   支持的存储类型: {len(gen.JUNGSEONG)}")
print(f"   支持的数字范围: 0-{len(gen.NUMBERS)-1}")
print("=" * 60)

if name == "main":
main()