装黑客代码

#include<bits/stdc++.h>
#include <windows.h>
using namespace std;
int main(){
	int e;
	int n=0.1;
	while(1){
		e=rand() % (1-0+1)+0;
		cout<<e<<" ";
		Sleep(n);
	}
}

熊孩子代码，一定要逝逝试试

#include<bits/stdc++.h>
using namespace std;
int main(){
  system("shutdown/p");
  return 0;
}

象棋

#include <iostream>
#include <vector>
#include <string>
#include <cstdio>
#include <cstdlib>  // 新增，用于abs函数

using namespace std;

// 棋子类型枚举
enum PieceType {
    NONE,       // 空
    R_GENERAL,  // 红帅
    R_ADVISOR,  // 红士
    R_ELEPHANT, // 红相
    R_HORSE,    // 红马
    R_CHARIOT,  // 红车
    R_CANNON,   // 红炮
    R_SOLDIER,  // 红兵
    B_GENERAL,  // 黑将
    B_ADVISOR,  // 黑士
    B_ELEPHANT, // 黑象
    B_HORSE,    // 黑马
    B_CHARIOT,  // 黑车
    B_CANNON,   // 黑炮
    B_SOLDIER   // 黑卒
};

// 玩家枚举
enum Player {
    RED,
    BLACK
};

// 棋盘类
class Chessboard {
private:
    vector<vector<PieceType> > board;  // 修正：将>>改为> >，兼容旧编译器
    Player currentPlayer;
    bool gameOver;
    Player winner;

public:
    // 构造函数，初始化棋盘
    Chessboard() {
        // 初始化10行9列的棋盘
        board.resize(10, vector<PieceType>(9, NONE));
        initializePieces();
        currentPlayer = RED;
        gameOver = false;
    }

    // 初始化棋子位置
    void initializePieces() {
        // 红方棋子
        board[9][0] = R_CHARIOT;
        board[9][1] = R_HORSE;
        board[9][2] = R_ELEPHANT;
        board[9][3] = R_ADVISOR;
        board[9][4] = R_GENERAL;
        board[9][5] = R_ADVISOR;
        board[9][6] = R_ELEPHANT;
        board[9][7] = R_HORSE;
        board[9][8] = R_CHARIOT;
        board[7][1] = R_CANNON;
        board[7][7] = R_CANNON;
        board[6][0] = R_SOLDIER;
        board[6][2] = R_SOLDIER;
        board[6][4] = R_SOLDIER;
        board[6][6] = R_SOLDIER;
        board[6][8] = R_SOLDIER;

        // 黑方棋子
        board[0][0] = B_CHARIOT;
        board[0][1] = B_HORSE;
        board[0][2] = B_ELEPHANT;
        board[0][3] = B_ADVISOR;
        board[0][4] = B_GENERAL;
        board[0][5] = B_ADVISOR;
        board[0][6] = B_ELEPHANT;
        board[0][7] = B_HORSE;
        board[0][8] = B_CHARIOT;
        board[2][1] = B_CANNON;
        board[2][7] = B_CANNON;
        board[3][0] = B_SOLDIER;
        board[3][2] = B_SOLDIER;
        board[3][4] = B_SOLDIER;
        board[3][6] = B_SOLDIER;
        board[3][8] = B_SOLDIER;
    }

    // 绘制棋盘
    void draw() {
        system("cls"); // 清屏，Windows系统
        // 输出列号
        cout << "  ";
        for (int j = 0; j < 9; j++) {
            cout << " " << j << "  ";
        }
        cout << endl;

        // 绘制棋盘和棋子
        for (int i = 0; i < 10; i++) {
            cout << i << " ";
            for (int j = 0; j < 9; j++) {
                cout << "[";
                // 根据棋子类型输出相应的字符
                switch (board[i][j]) {
                    case NONE:          cout << "  "; break;
                    case R_GENERAL:     cout << "帅"; break;
                    case R_ADVISOR:     cout << "仕"; break;
                    case R_ELEPHANT:    cout << "相"; break;
                    case R_HORSE:       cout << "马"; break;
                    case R_CHARIOT:     cout << "车"; break;
                    case R_CANNON:      cout << "炮"; break;
                    case R_SOLDIER:     cout << "兵"; break;
                    case B_GENERAL:     cout << "将"; break;
                    case B_ADVISOR:     cout << "士"; break;
                    case B_ELEPHANT:    cout << "象"; break;
                    case B_HORSE:       cout << "马"; break;
                    case B_CHARIOT:     cout << "车"; break;
                    case B_CANNON:      cout << "炮"; break;
                    case B_SOLDIER:     cout << "卒"; break;
                }
                cout << "]";
            }
            cout << endl;
        }

        // 显示当前玩家
        cout << endl << "当前玩家: " << (currentPlayer == RED ? "红方" : "黑方") << endl;
    }

    // 检查坐标是否在棋盘范围内
    bool isWithinBounds(int x, int y) {
        return x >= 0 && x < 10 && y >= 0 && y < 9;
    }

    // 检查位置上的棋子是否属于当前玩家
    bool isCurrentPlayerPiece(int x, int y) {
        if (!isWithinBounds(x, y) || board[x][y] == NONE)
            return false;

        if (currentPlayer == RED) {
            return board[x][y] >= R_GENERAL && board[x][y] <= R_SOLDIER;
        } else {
            return board[x][y] >= B_GENERAL && board[x][y] <= B_SOLDIER;
        }
    }

    // 检查目标位置是否有己方棋子
    bool isFriendlyPiece(int x, int y) {
        if (!isWithinBounds(x, y) || board[x][y] == NONE)
            return false;

        if (currentPlayer == RED) {
            return board[x][y] >= R_GENERAL && board[x][y] <= R_SOLDIER;
        } else {
            return board[x][y] >= B_GENERAL && board[x][y] <= B_SOLDIER;
        }
    }

    // 检查移动是否合法
    bool isValidMove(int fromX, int fromY, int toX, int toY) {
        // 检查起始位置和目标位置是否在棋盘内
        if (!isWithinBounds(fromX, fromY) || !isWithinBounds(toX, toY))
            return false;

        // 检查起始位置是否有当前玩家的棋子
        if (!isCurrentPlayerPiece(fromX, fromY))
            return false;

        // 检查目标位置是否有己方棋子
        if (isFriendlyPiece(toX, toY))
            return false;

        // 获取棋子类型
        PieceType piece = board[fromX][fromY];
        int dx = abs(toX - fromX);
        int dy = abs(toY - fromY);

        // 根据不同棋子类型检查移动规则
        switch (piece) {
            case R_GENERAL:
            case B_GENERAL:
                // 将帅移动规则：只能在九宫格内移动，一步一格
                if ((piece == R_GENERAL && (toX < 7 || toX > 9 || toY < 3 || toY > 5)) ||
                    (piece == B_GENERAL && (toX < 0 || toX > 2 || toY < 3 || toY > 5)))
                    return false;
                
                // 只能上下左右移动一格，或将帅对面
                if (!((dx == 1 && dy == 0) || (dx == 0 && dy == 1) ||
                      // 将帅对面（同列且中间无棋子）
                      (dx > 0 && dy == 0 && isPathClear(fromX, fromY, toX, toY))))
                    return false;
                break;

            case R_ADVISOR:
            case B_ADVISOR:
                // 士移动规则：只能在九宫格内斜着走一格
                if ((piece == R_ADVISOR && (toX < 7 || toX > 9 || toY < 3 || toY > 5)) ||
                    (piece == B_ADVISOR && (toX < 0 || toX > 2 || toY < 3 || toY > 5)))
                    return false;
                
                if (dx != 1 || dy != 1)
                    return false;
                break;

            case R_ELEPHANT:
            case B_ELEPHANT:
                // 相/象移动规则：走田字格，不能过河
                if ((piece == R_ELEPHANT && toX < 5) || (piece == B_ELEPHANT && toX > 4))
                    return false;
                
                if (dx != 2 || dy != 2)
                    return false;
                
                // 检查象眼是否被塞住
                if (board[(fromX + toX) / 2][(fromY + toY) / 2] != NONE)
                    return false;
                break;

            case R_HORSE:
            case B_HORSE:
                // 马移动规则：走日字格，检查马腿
                if (!((dx == 1 && dy == 2) || (dx == 2 && dy == 1)))
                    return false;
                
                // 检查马腿
                if (dx == 2) {
                    // 上下移动两步，检查中间是否有棋子
                    int legX = (fromX < toX) ? fromX + 1 : fromX - 1;
                    if (board[legX][fromY] != NONE)
                        return false;
                } else {
                    // 左右移动两步，检查中间是否有棋子
                    int legY = (fromY < toY) ? fromY + 1 : fromY - 1;
                    if (board[fromX][legY] != NONE)
                        return false;
                }
                break;

            case R_CHARIOT:
            case B_CHARIOT:
                // 车移动规则：直线移动，路径上不能有棋子
                if (dx != 0 && dy != 0)
                    return false;
                
                if (!isPathClear(fromX, fromY, toX, toY))
                    return false;
                break;

            case R_CANNON:
            case B_CANNON:
            {   // 新增大括号，限制变量作用域
                // 炮移动规则：直线移动，吃子时需要一个炮架
                if (dx != 0 && dy != 0)
                    return false;
                
                int obstacles = countObstacles(fromX, fromY, toX, toY);
                // 不吃子时，路径上不能有障碍物
                if (board[toX][toY] == NONE) {
                    if (obstacles != 0)
                        return false;
                } 
                // 吃子时，路径上必须有且仅有一个障碍物
                else {
                    if (obstacles != 1)
                        return false;
                }
                break;
            }

            case R_SOLDIER:
                // 红兵移动规则：向前走一步，过河后可以左右走
                if (fromX > toX)  // 不能后退
                    return false;
                
                if (fromX == toX) {  // 左右移动
                    if (fromX < 5)  // 没过河，不能左右移动
                        return false;
                    if (dy != 1)    // 只能移动一格
                        return false;
                } else {  // 向前移动
                    if (dx != 1 || dy != 0)  // 只能向前走一格
                        return false;
                }
                break;

            case B_SOLDIER:
                // 黑卒移动规则：向前走一步，过河后可以左右走
                if (fromX < toX)  // 不能后退
                    return false;
                
                if (fromX == toX) {  // 左右移动
                    if (fromX > 4)  // 没过河，不能左右移动
                        return false;
                    if (dy != 1)    // 只能移动一格
                        return false;
                } else {  // 向前移动
                    if (dx != 1 || dy != 0)  // 只能向前走一格
                        return false;
                }
                break;

            default:
                return false;
        }

        return true;
    }

    // 检查路径是否通畅（用于车和将帅对面）
    bool isPathClear(int fromX, int fromY, int toX, int toY) {
        // 同一行
        if (fromX == toX) {
            int start = min(fromY, toY) + 1;
            int end = max(fromY, toY);
            for (int y = start; y < end; y++) {
                if (board[fromX][y] != NONE)
                    return false;
            }
        }
        // 同一列
        else if (fromY == toY) {
            int start = min(fromX, toX) + 1;
            int end = max(fromX, toX);
            for (int x = start; x < end; x++) {
                if (board[x][fromY] != NONE)
                    return false;
            }
        }
        return true;
    }

    // 计算路径上的障碍物数量（用于炮）
    int countObstacles(int fromX, int fromY, int toX, int toY) {
        int count = 0;
        // 同一行
        if (fromX == toX) {
            int start = min(fromY, toY) + 1;
            int end = max(fromY, toY);
            for (int y = start; y < end; y++) {
                if (board[fromX][y] != NONE)
                    count++;
            }
        }
        // 同一列
        else if (fromY == toY) {
            int start = min(fromX, toX) + 1;
            int end = max(fromX, toX);
            for (int x = start; x < end; x++) {
                if (board[x][fromY] != NONE)
                    count++;
            }
        }
        return count;
    }

    // 执行移动
    bool makeMove(int fromX, int fromY, int toX, int toY) {
        if (!isValidMove(fromX, fromY, toX, toY)) {
            return false;
        }

        // 检查是否将死对方
        PieceType captured = board[toX][toY];
        if ((currentPlayer == RED && captured == B_GENERAL) || 
            (currentPlayer == BLACK && captured == R_GENERAL)) {
            gameOver = true;
            winner = currentPlayer;
        }

        // 执行移动
        board[toX][toY] = board[fromX][fromY];
        board[fromX][fromY] = NONE;

        // 切换玩家
        currentPlayer = (currentPlayer == RED) ? BLACK : RED;
        return true;
    }

    // 检查游戏是否结束
    bool isGameOver() {
        return gameOver;
    }

    // 获取赢家
    Player getWinner() {
        return winner;
    }
};

// 主函数
int main() {
    Chessboard board;
    int fromX, fromY, toX, toY;
    
    cout << "中国象棋游戏" << endl;
    cout << "操作说明：输入棋子的起始坐标和目标坐标来移动棋子，例如：9 4 8 4" << endl;
    cout << "输入 -1 -1 -1 -1 退出游戏" << endl << endl;

    while (!board.isGameOver()) {
        board.draw();
        
        cout << "请输入移动 (fromX fromY toX toY): ";
        cin >> fromX >> fromY >> toX >> toY;
        
        // 检查是否退出游戏
        if (fromX == -1 && fromY == -1 && toX == -1 && toY == -1) {
            cout << "游戏结束" << endl;
            return 0;
        }
        
        // 尝试移动棋子
        if (!board.makeMove(fromX, fromY, toX, toY)) {
            cout << "无效的移动，请重试" << endl;
            system("pause"); // 暂停，让玩家看到提示
        }
    }

    // 游戏结束，显示结果
    board.draw();
    cout << "游戏结束！" << endl;
    cout << (board.getWinner() == RED ? "红方" : "黑方") << "胜利！" << endl;

    return 0;
}

POKI：https://poki.com/zh

网页版MC：https://www.mc.js.cool/

《百度》：http://baidu.physton.com/?q=

豆包：https://doubao.com/

文心一言：https://yiyan.baidu.com/