华为OD机试 - 转骰子（Python/JS/C/C++ 2024 E卷 100分）

于 2024-10-05 21:01:35 发布
阅读量401 收藏 7
点赞数 11
分类专栏： 搬砖工逆袭Java架构师 文章标签： 华为od python javascript
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/guorui_java/article/details/142715928
版权

在这里插入图片描述

华为OD机试 2024E卷题库疯狂收录中，刷题点这里

专栏导读

本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。

一、题目描述

假设有一个立方体，每个面有一个数字，初始为：前1，右2，前3（观察者方向），后4，上5，下6，用123456表示这个状态，放置在平面上。

  • 可以向左翻转（用L表示向左翻转1次）；
  • 可以向右翻转（用R表示向右翻转1次）；
  • 可以向前翻转（用F表示向前翻转1次）；
  • 可以向后翻转（用B表示向后翻转1次）；
  • 可以以逆时针旋转（用A表示逆时针旋转90度）；
  • 可以以顺时针旋转（用C表示顺时针旋转90度）。

现在从123456这个初始状态开始，根据输入的动作/指令，计算得出最终的状态。

在这里插入图片描述

二、输入描述

输入一行，为只包含LRFBAC的字母序列，最大长度为50，字母可重复。

三、输出描述

输出最终状态。

四、测试用例

测试用例1：

1、输入

LR

2、输出

123456

3、说明

立方体先向左翻转，再向右翻转回去，最终还是恢复到初始状态123456。

测试用例2：

1、输入

FCR

2、输出

342156

3、说明

立方体先向前翻转，状态变为125643，然后顺时针旋转，状态变为651243，最后向右翻转，状态变为342156。

五、解题思路

模拟一个立方体在平面上的翻转和旋转操作。立方体有六个面，分别标记为左（Left）、右（Right）、前（Front）、后（Back）、上（Up）、下（Down），每个面上有一个数字。初始状态为123456，表示左1、右2、前3、后4、上5、下6。

每个操作（L、R、F、B、A、C）会改变立方体各面的数字位置。为了实现这一点，我们可以使用一个长度为6的数组state来表示立方体的六个面，索引分别对应左、右、前、后、上、下。每个操作对应一个特定的数组置换，通过预定义的旋转方法rotate来实现。

  1. 定义立方体状态：使用一个长度为6的数组state来表示立方体的六个面，索引分别对应左、右、前、后、上、下。
  2. 实现旋转方法：定义一个通用的旋转方法rotate，用于交换立方体上四个面的值。每个具体的操作（L、R、F、B、A、C）将调用rotate方法，传入相应的面索引。
  3. 读取输入并执行操作：使用Scanner读取输入的操作序列，逐个执行对应的操作方法。
  4. 输出最终状态：按照左、右、前、后、上、下的顺序输出state数组中的数字。

六、Python算法源码

import sys

def rotate(state, a, b, c, d):
    """
    通用的旋转方法，用于交换立方体上四个面的值。
    通过传入四个索引，按顺序交换这四个面的位置。
    
    参数:
    state (list): 当前立方体的六个面列表，依次表示 左、右、前、后、上、下。
    a (int): 要交换的第一个面索引
    b (int): 要交换的第二个面索引
    c (int): 要交换的第三个面索引
    d (int): 要交换的第四个面索引
    """
    temp = state[a]      # 临时保存第一个面的值
    state[a] = state[b]  # 第二个面的值赋给第一个面
    state[b] = state[c]  # 第三个面的值赋给第二个面
    state[c] = state[d]  # 第四个面的值赋给第三个面
    state[d] = temp      # 第一个面的值赋给第四个面

def turnL(state):
    """
    向左翻转 (L)：
    将左 -> 上 -> 右 -> 下 -> 左
    """
    rotate(state, 0, 4, 1, 5)  # 左->上->右->下->左

def turnR(state):
    """
    向右翻转 (R)：
    将左 -> 下 ->右 -> 上 -> 左
    """
    rotate(state, 0, 5, 1, 4)  # 左->下->右->上->左

def turnF(state):
    """
    向前翻转 (F)：
    将前 -> 上 -> 后 -> 下 -> 前
    """
    rotate(state, 2, 4, 3, 5)  # 前->上->后->下->前

def turnB(state):
    """
    向后翻转 (B)：
    将前 -> 下 -> 后 -> 上 -> 前
    """
    rotate(state, 2, 5, 3, 4)  # 前->下->后->上->前

def turnA(state):
    """
    逆时针旋转 (A)：
    将左 -> 后 -> 右 -> 前 -> 左
    """
    rotate(state, 0, 3, 1, 2)  # 左->后->右->前->左

def turnC(state):
    """
    顺时针旋转 (C)：
    将左 -> 前 -> 右 -> 后 -> 左
    """
    rotate(state, 0, 2, 1, 3)  # 左->前->右->后->左

def main():
    # 读取用户输入的指令序列
    s = sys.stdin.read().strip()
    
    # 初始状态：左、右、前、后、上、下
    state = [1, 2, 3, 4, 5, 6]  # 左1，右2，前3，后4，上5，下6
    
    # 遍历每一个指令字符，并执行相应的操作
    for ch in s:
        if ch == 'L':
            turnL(state)  # 执行左翻转
        elif ch == 'R':
            turnR(state)  # 执行右翻转
        elif ch == 'F':
            turnF(state)  # 执行前翻转
        elif ch == 'B':
            turnB(state)  # 执行后翻转
        elif ch == 'A':
            turnA(state)  # 执行逆时针旋转
        elif ch == 'C':
            turnC(state)  # 执行顺时针旋转
        # 忽略无效字符
    
    # 输出最终立方体的六个面状态，按照左、右、前、后、上、下的顺序
    print(''.join(map(str, state)))

if __name__ == "__main__":
    main()

七、JavaScript算法源码

const readline = require('readline');

// 创建接口以读取标准输入
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

/**
 * 通用的旋转方法，用于交换立方体上四个面的值。
 * 通过传入四个索引，按顺序交换这四个面的位置。
 *
 * @param {number[]} state - 当前立方体的六个面数组，依次表示 左、右、前、后、上、下。
 * @param {number} a - 要交换的第一个面索引
 * @param {number} b - 要交换的第二个面索引
 * @param {number} c - 要交换的第三个面索引
 * @param {number} d - 要交换的第四个面索引
 */
function rotate(state, a, b, c, d) {
    let temp = state[a];      // 临时保存第一个面的值
    state[a] = state[b];      // 第二个面的值赋给第一个面
    state[b] = state[c];      // 第三个面的值赋给第二个面
    state[c] = state[d];      // 第四个面的值赋给第三个面
    state[d] = temp;          // 第一个面的值赋给第四个面
}

/**
 * 向左翻转 (L)：
 * 将左 -> 上 -> 右 -> 下 -> 左
 */
function turnL(state) {
    rotate(state, 0, 4, 1, 5); // 左->上->右->下->左
}

/**
 * 向右翻转 (R)：
 * 将左 -> 下 ->右 -> 上 -> 左
 */
function turnR(state) {
    rotate(state, 0, 5, 1, 4); // 左->下->右->上->左
}

/**
 * 向前翻转 (F)：
 * 将前 -> 上 -> 后 -> 下 -> 前
 */
function turnF(state) {
    rotate(state, 2, 4, 3, 5); // 前->上->后->下->前
}

/**
 * 向后翻转 (B)：
 * 将前 -> 下 -> 后 -> 上 -> 前
 */
function turnB(state) {
    rotate(state, 2, 5, 3, 4); // 前->下->后->上->前
}

/**
 * 逆时针旋转 (A)：
 * 将左 -> 后 -> 右 -> 前 -> 左
 */
function turnA(state) {
    rotate(state, 0, 3, 1, 2); // 左->后->右->前->左
}

/**
 * 顺时针旋转 (C)：
 * 将左 -> 前 -> 右 -> 后 -> 左
 */
function turnC(state) {
    rotate(state, 0, 2, 1, 3); // 左->前->右->后->左
}

rl.on('line', (input) => {
    let s = input.trim(); // 读取输入并去除首尾空格
    
    // 初始状态：左、右、前、后、上、下
    let state = [1, 2, 3, 4, 5, 6]; // 左1，右2，前3，后4，上5，下6
    
    // 遍历每一个指令字符，并执行相应的操作
    for (let ch of s) {
        switch(ch) {
            case 'L':
                turnL(state); // 执行左翻转
                break;
            case 'R':
                turnR(state); // 执行右翻转
                break;
            case 'F':
                turnF(state); // 执行前翻转
                break;
            case 'B':
                turnB(state); // 执行后翻转
                break;
            case 'A':
                turnA(state); // 执行逆时针旋转
                break;
            case 'C':
                turnC(state); // 执行顺时针旋转
                break;
            // 忽略无效字符
        }
    }
    
    // 输出最终立方体的六个面状态，按照左、右、前、后、上、下的顺序
    console.log(state.join(''));
    
    rl.close(); // 关闭接口
});

八、C算法源码

#include <stdio.h>
#include <string.h>

// 通用的旋转方法，用于交换立方体上四个面的值。
// 通过传入四个索引，按顺序交换这四个面的位置。
void rotate(int state[], int a, int b, int c, int d) {
    int temp = state[a];   // 临时保存第一个面的值
    state[a] = state[b];   // 第二个面的值赋给第一个面
    state[b] = state[c];   // 第三个面的值赋给第二个面
    state[c] = state[d];   // 第四个面的值赋给第三个面
    state[d] = temp;       // 第一个面的值赋给第四个面
}

// 向左翻转 (L)：将左 -> 上 -> 右 -> 下 -> 左
void turnL(int state[]) {
    rotate(state, 0, 4, 1, 5); // 左->上->右->下->左
}

// 向右翻转 (R)：将左 -> 下 ->右 -> 上 -> 左
void turnR(int state[]) {
    rotate(state, 0, 5, 1, 4); // 左->下->右->上->左
}

// 向前翻转 (F)：将前 -> 上 -> 后 -> 下 -> 前
void turnF(int state[]) {
    rotate(state, 2, 4, 3, 5); // 前->上->后->下->前
}

// 向后翻转 (B)：将前 -> 下 -> 后 -> 上 -> 前
void turnB(int state[]) {
    rotate(state, 2, 5, 3, 4); // 前->下->后->上->前
}

// 逆时针旋转 (A)：将左 -> 后 -> 右 -> 前 -> 左
void turnA(int state[]) {
    rotate(state, 0, 3, 1, 2); // 左->后->右->前->左
}

// 顺时针旋转 (C)：将左 -> 前 -> 右 -> 后 -> 左
void turnC(int state[]) {
    rotate(state, 0, 2, 1, 3); // 左->前->右->后->左
}

int main() {
    char s[51]; // 定义最多50个字符的指令序列，加1为结束符
    scanf("%s", s); // 读取输入的指令序列
    
    // 初始状态：左、右、前、后、上、下
    int state[6] = {1, 2, 3, 4, 5, 6}; // 左1，右2，前3，后4，上5，下6
    
    // 遍历每一个指令字符，并执行相应的操作
    for(int i = 0; i < strlen(s); i++) {
        char ch = s[i];
        switch(ch) {
            case 'L':
                turnL(state); // 执行左翻转
                break;
            case 'R':
                turnR(state); // 执行右翻转
                break;
            case 'F':
                turnF(state); // 执行前翻转
                break;
            case 'B':
                turnB(state); // 执行后翻转
                break;
            case 'A':
                turnA(state); // 执行逆时针旋转
                break;
            case 'C':
                turnC(state); // 执行顺时针旋转
                break;
            // 忽略无效字符
            default:
                break;
        }
    }
    
    // 输出最终立方体的六个面状态，按照左、右、前、后、上、下的顺序
    for(int i = 0; i < 6; i++) {
        printf("%d", state[i]);
    }
    
    return 0;
}

九、C++算法源码

#include <iostream>
#include <string>
using namespace std;

/**
 * 通用的旋转方法，用于交换立方体上四个面的值。
 * 通过传入四个索引，按顺序交换这四个面的位置。
 *
 * @param state 当前立方体的六个面数组，依次表示 左、右、前、后、上、下。
 * @param a     要交换的第一个面索引
 * @param b     要交换的第二个面索引
 * @param c     要交换的第三个面索引
 * @param d     要交换的第四个面索引
 */
void rotate(int state[], int a, int b, int c, int d) {
    int temp = state[a];   // 临时保存第一个面的值
    state[a] = state[b];   // 第二个面的值赋给第一个面
    state[b] = state[c];   // 第三个面的值赋给第二个面
    state[c] = state[d];   // 第四个面的值赋给第三个面
    state[d] = temp;       // 第一个面的值赋给第四个面
}

/**
 * 向左翻转 (L)：
 * 将左 -> 上 -> 右 -> 下 -> 左
 */
void turnL(int state[]) {
    rotate(state, 0, 4, 1, 5); // 左->上->右->下->左
}

/**
 * 向右翻转 (R)：
 * 将左 -> 下 ->右 -> 上 -> 左
 */
void turnR(int state[]) {
    rotate(state, 0, 5, 1, 4); // 左->下->右->上->左
}

/**
 * 向前翻转 (F)：
 * 将前 -> 上 -> 后 -> 下 -> 前
 */
void turnF(int state[]) {
    rotate(state, 2, 4, 3, 5); // 前->上->后->下->前
}

/**
 * 向后翻转 (B)：
 * 将前 -> 下 -> 后 -> 上 -> 前
 */
void turnB(int state[]) {
    rotate(state, 2, 5, 3, 4); // 前->下->后->上->前
}

/**
 * 逆时针旋转 (A)：
 * 将左 -> 后 -> 右 -> 前 -> 左
 */
void turnA(int state[]) {
    rotate(state, 0, 3, 1, 2); // 左->后->右->前->左
}

/**
 * 顺时针旋转 (C)：
 * 将左 -> 前 -> 右 -> 后 -> 左
 */
void turnC(int state[]) {
    rotate(state, 0, 2, 1, 3); // 左->前->右->后->左
}

int main(){
    string s;
    cin >> s; // 读取输入的指令序列
    
    // 初始状态：左、右、前、后、上、下
    int state[6] = {1, 2, 3, 4, 5, 6}; // 左1，右2，前3，后4，上5，下6
    
    // 遍历每一个指令字符，并执行相应的操作
    for(char ch : s){
        switch(ch){
            case 'L':
                turnL(state); // 执行左翻转
                break;
            case 'R':
                turnR(state); // 执行右翻转
                break;
            case 'F':
                turnF(state); // 执行前翻转
                break;
            case 'B':
                turnB(state); // 执行后翻转
                break;
            case 'A':
                turnA(state); // 执行逆时针旋转
                break;
            case 'C':
                turnC(state); // 执行顺时针旋转
                break;
            // 忽略无效字符
            default:
                break;
        }
    }
    
    // 输出最终立方体的六个面状态，按照左、右、前、后、上、下的顺序
    for(int i = 0; i < 6; i++){
        cout << state[i];
    }
    
    return 0;
}

🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2024 E卷 200分）

🏆本文收录于，华为OD机试真题（Python/JS/C/C++）

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。

在这里插入图片描述

哪 吒
关注
专栏目录
2024华为OD机试题库-(A卷+B卷+C卷+D卷+E)-(JAVA、Python、C++)
goldarmour的博客
03-28 4万+
博主是一名资深后端开发人员，精通C++，Python，Java，乐于分享面试经验，已帮助千余名同学通过OD机考！这些题目博主每一道都刷了至少两遍，每一行代码都蕴含了博主从业以来所积累的所有经验和技巧，可谓干货满满！
华为OD机试真题目录汇总（C语言）2024 B+C+D+E卷 （484道）
KJ.JK
08-09 8万+
本文是华为OD机试真题（C语言）专栏的目录贴（持续更新中…）华为OD是Outsourcing Dispacth模式，是华为和外企德科联合招聘的简称。目前华为大多数是OD招聘。OD模式也是华为提出的一种新的用工形式，每年都会从OD项目挑优秀员工转为正编。所有OD和正式员工一样对待，没有差别，部门平时开会、评审等活动都是一起参加的，是同薪同酬，都是由华为的HR直接定的薪资，看的是我们技术能力。华为是大企业，能到华为上班也是有能力的，每个部门都有好多职位，是金子，在哪都会发光。
2024华为OD机试真题目录 B+C+D+E卷，使用C语言进行解答（484道）
KJ.JK
04-15 14万+
本文是华为OD机试真题(C语言)专栏的目录贴（持续更新中…）定期更新华为OD各个时间阶段的机试真题，每日定时更新，本专栏将使用C语言进行更新解答，包含真题，思路分析，代码参考，欢迎大家订阅学习华为OD机试真题(C语言）定期更新华为OD各个时间阶段的机试真题，每日定时更新，本专栏将使用C语言进行更新解答，包含真题，思路分析，代码参考，欢迎大家订阅学习。
2024华为OD机试（JAVA）真题【E卷+A卷+B卷+C卷+D卷】目录
热门推荐
MISAYAONE的博客
11-20 24万+
2022.11 开始华为机试 Od 应该加新题了，优先更新最新的题目。
【华为OD】2024年华为OD机试C卷、D卷真题集：最新的真题集题库 C/C++/Java/python/JavaScript
十年以上编程经验的干货分享
04-01 2688
2024年华为OD机试C卷真题题集题库，有2种分数的题目列表分别是100分的列表、200分的列表从2023年11月开始，华为OD题目切换到C卷，基本上大概率会使用半年左右，要在2024年5月之前把这些题目都好好练习一下，可以得到很好的收获，基本上都是出的原题，提前恭喜大家都上岸。目前通过大大提供的真题练习，已经有上百人成功上岸了，而且大大还是一个老师，通过大大指导进入华为OD的学生已经有上千人了。 2024年5月之前，碰到原题的概率是98%以上。
【免费题库】华为OD机试 - 转骰子（Java & JS & Python & C & C++）
m0_66793065的博客
04-07 4576
## 题目描述 骰子是一个立方体，每个面一个数字，初始为左1，右2，前3(观察者方向)，后4，上5，下6，用123456表示这个状态，放置在平面上， 可以向左翻转(用L表示向左翻转1次)， 可以向右翻转(用R表示向右翻转1次)， 可以向前翻转(用F表示向前翻转1次)， 可以向后翻转(用B表示向后翻转1次)， 可以逆时针旋转(用A表示逆时针旋转90度)， 可以顺时针旋转(用C表示顺时针旋转90度)， 现从123456这个初始状态开始，根据输入的动作序列，计算得到最终的状态。 骰子的初始状态和初始状态转动后
华为OD机试E卷 - 转骰子（Java & Python& JS & C++ & C ）
算法大师！
09-30 147
华为OD机试E卷 - 转骰子.骰子是一个立方体，每个面一个数字，初始为左1，右2，前3(观察者方向)，后4，上5，下6，用123456表示这个状态，放置在平面上，
【华为OD】2024年机试C卷、D卷真题集：最新的真题集题库 C/C++/Java/python/JavaScript
十年以上编程经验的干货分享
03-27 2505
2024年C卷真题题集题库，有2种分数的题目列表，分别是100分的列表、200分的列表 从2023年11月开始，华为OD题目切换到C卷，基本上大概率会使用半年左右，要在2024年5月之前把这些题目都好好练习一下，可以得到很好的收获，基本上都是出的原题，提前恭喜大家都上岸。目前通过大大提供的真题练习，已经有上百人成功上岸了，而且大大还是一个老师，通过大大指导进入华为OD的学生已经有上千人了。 2024年5月之前，碰到原题的概率是98%以上。
2024华为OD机试真题目录汇总 B+C+D+E卷（570道）（Python语言）
KJ.JK
07-12 16万+
本文是华为OD机试真题（Python 语言）专栏的目录贴（持续更新中…）华为OD是Outsourcing Dispacth模式，是华为和外企德科联合招聘的简称。目前华为大多数是OD招聘。OD模式也是华为提出的一种新的用工形式，每年都会从OD项目挑优秀员工转为正编。所有OD和正式员工一样对待，没有差别，部门平时开会、评审等活动都是一起参加的，是同薪同酬，都是由华为的HR直接定的薪资，看的是我们技术能力。华为是大企业，能到华为上班也是有能力的，每个部门都有好多职位，是金子，在哪都会发光。
【免费题库】华为OD机试 - 转骰子（Java & JS & Python & C & C++）.html
04-19
【免费题库】华为OD机试 - 转骰子（Java & JS & Python & C & C++）.html
编码能力提升计划 - 华为OD统一考试(E卷)
学习,你不是一个人在战斗 ～ 961302305（QQ,微信）
10-01 577
编码能力提升计划 - 华为OD统一考试(E卷) 为了提升软件编码能力，小王制定了刷题计划，他选了题库中的n道题，编号从0到n-1，并计划在m天内按照题目编号顺序刷完所有的题目(注意，小王不能用多天完成同一题)。 在小王刷题计划中，小王需要用 `time[i]` 的时间完成编号 `i`的题目。此外，小王还可以查看答案，可以省去该题的做题时间。为了真正达到刷题效果，小王每天最多直接看一次答案。 我们定义m天中做题时间最多的一天耗时为T(直接看答案的题目不计入做题总时间)。请你帮小王求出最小的T是多少。
报数游戏 - 华为OD统一考试(E卷)
学习,你不是一个人在战斗 ～ 961302305（QQ,微信）
09-28 657
报数游戏 - 华为OD统一考试(E卷) 100个人围成一圈，每个人有一个编号，编号从1开始到100。他们从1开始依次报数，报到为M的人自动退出圈圈，然后下一个人接着从1开始报数，直到剩余的人数小于M。请问最后剩余的人在原先的编号为多少？
（笔记）第三期书生·浦语大模型实战营（十一卷王场）--书生入门岛通关第2关Python 基础知识
haidizym的博客
10-02 457
学员闯关手册：https://aicarrier.feishu.cn/wiki/ZcgkwqteZi9s4ZkYr0Gcayg1n1g?课程视频：https://www.bilibili.com/video/BV1mS421X7h4/课程文档：https://github.com/InternLM/Tutorial/tree/camp3/docs/L0/Python。
遥感影像-实例分割数据集：iSAID 从切图到YOLO格式数据集制作详细介绍
GIS潮流
09-30 1137
开源数据集isaid标注包含实例分割，但是原始影像太大，很吃显存，一般显卡无法用原始影像直接训练，所以需要对影像进行裁剪，并生成对应的标签，因为想用yolo系列跑模型，所以将标签需要转为txt格式。
酷炫音乐盒: 使用Python和Tkinter配合Pygame打造自己的音乐播放器
宇宙第一小趴菜的博客
09-29 1221
Tkinter是一个功能强大且简单易用的库，适合构建轻量级的GUI应用程序。它在不同的操作系统上具有相同的外观和行为，因此可以实现跨平台的应用程序。当然，Tkinter还有更多的功能和细节，通过阅读官方文档和教程，你可以更深入地了解和学习如何运用Tkinter来创建各种GUI应用程序。
Python | Leetcode Python题解之第448题找到所有数组中消失的数字
Mopes__的博客
10-01 398
Python | Leetcode Python题解之第448题找到所有数组中消失的数字
Python编写的贪吃蛇小游戏
最新发布
WwLK123的博客
10-03 362
Python编写贪吃蛇小游戏。
合并两个有序数组
Sudo_Wang的学习记录
09-30 425
我们可以使用双指针法从后向前遍历，避免将已经排序的数组打乱。这个方法的核心思路是从。的末尾开始填充较大的元素，因为末尾是用零填充的空闲区域，这样我们可以避免覆盖。这个方法能够高效地解决问题，并且符合进阶要求的 O(m + n) 复杂度。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

哪 吒

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值