【华为OD-E卷 - 转骰子 100分（python、java、c++、js、c）】
【华为OD-E卷 - 转骰子 100分（python、java、c++、js、c）】
题目
骰子是一个立方体，每个面一个数字，初始为左1，右2，前3(观察者方向)，后4，上5，下6，用123456表示这个状态，放置在平面上，
可以向左翻转(用L表示向左翻转1次)， 可以向右翻转(用R表示向右翻转1次)， 可以向前翻转(用F表示向前翻转1次)， 可以向后翻转(用B表示向后翻转1次)， 可以逆时针旋转(用A表示逆时针旋转90度)， 可以顺时针旋转(用C表示顺时针旋转90度)， 现从123456这个初始状态开始，根据输入的动作序列，计算得到最终的状态。
骰子的初始状态和初始状态转动后的状态如图所示。
输入描述
- 输入一行，为只包含LRFBAC的字母序列，最大长度为50，字母可重复
输出描述
- 输出最终状态
用例
用例一：
输入：
LR
输出：
123456
用例二：
输入：
FCR
输出：
342156
python解法
- 解题思路：
- 目标描述：实现一个模拟骰子滚动和旋转的程序，最终输出骰子每个面当前的数字顺序。骰子的初始状态为 [1, 2, 3, 4, 5, 6]，表示左、右、前、后、上、下的数字。
骰子状态表示：
使用一个长度为 6 的列表来表示骰子 6 个面的当前数字。
按顺序 [左, 右, 前, 后, 上, 下] 来存储每个面的状态。
骰子滚动和旋转规则：
骰子可以左滚 (L)，右滚 ®，前滚 (F)，后滚 (B)，逆时针旋转 (A)，顺时针旋转 ©。
每种滚动或旋转操作会改变骰子 6 个面数字的顺序。通过列表索引调整顺序实现。
实现步骤：
定义一个 Dice 类，用于表示骰子及其操作。
定义具体的滚动和旋转方法，直接更新骰子状态。
编写 move 方法，接收单个指令并调用对应操作。
编写 simulate_dice_movement 函数，用于读取一系列动作并模拟骰子滚动，最后返回骰子状态。
输入输出：
输入是一串字符，表示动作指令（如 LRFAC）。
输出是骰子所有面按照 [左, 右, 前, 后, 上, 下] 顺序的数字
class Dice:
def __init__(self):
# 初始化骰子状态，[左, 右, 前, 后, 上, 下]
self.state = [1, 2, 3, 4, 5, 6]
def left(self):
# 骰子向左滚动，更新状态
self.state = [self.state[4], self.state[5], self.state[2], self.state[3], self.state[1], self.state[0]]
def right(self):
# 骰子向右滚动，更新状态
self.state = [self.state[5], self.state[4], self.state[2], self.state[3], self.state[0], self.state[1]]
def forward(self):
# 骰子向前滚动，更新状态
self.state = [self.state[0], self.state[1], self.state[4], self.state[5], self.state[3], self.state[2]]
def backward(self):
# 骰子向后滚动，更新状态
self.state = [self.state[0], self.state[1], self.state[5], self.state[4], self.state[2], self.state[3]]
def rotate_anticlockwise(self):
# 骰子逆时针旋转，更新状态
self.state = [self.state[3], self.state[2], self.state[0], self.state[1], self.state[4], self.state[5]]
def rotate_clockwise(self):
# 骰子顺时针旋转，更新状态
self.state = [self.state[2], self.state[3], self.state[1], self.state[0], self.state[4], self.state[5]]
def move(self, action):
# 根据给定动作执行对应的骰子操作
if action == 'L':
self.left() # 向左滚动
elif action == 'R':
self.right() # 向右滚动
elif action == 'F':
self.forward() # 向前滚动
elif action == 'B':
self.backward() # 向后滚动
elif action == 'A':
self.rotate_anticlockwise() # 逆时针旋转
elif action == 'C':
self.rotate_clockwise() # 顺时针旋转
def __str__(self):
# 返回骰子当前状态的字符串表示
return ''.join(map(str, self.state))
def simulate_dice_movement(actions):
# 创建一个骰子对象
dice = Dice()
# 按照动作序列依次执行操作
for action in actions:
dice.move(action)
# 返回最终骰子状态
return str(dice)
# 读取输入并执行模拟
actions = input().strip() # 读取输入动作序列
result = simulate_dice_movement(actions) # 模拟骰子动作
print(result) # 输出最终状态
java解法
- 解题思路
- 目标描述： 模拟骰子的滚动和旋转，最终输出骰子所有面的状态（按 [左, 右, 前, 后, 上, 下] 的顺序）。骰子初始面为 l=1, r=2, f=3, b=4, t=5, bot=6，分别表示左、右、前、后、上、下六个面。
状态表示：
用六个整型变量 l, r, f, b, t, bot 分别表示骰子的 6 个面。
滚动或旋转时，通过交换这些变量的值来更新状态。
操作规则：
每个动作（如 L，R，F 等）都有明确的规则，表示骰子如何滚动或旋转。
通过临时变量辅助交换值，完成对应的操作。
实现步骤：
定义 Dice 类来管理骰子的状态和动作。
为每个动作编写对应的方法（如 turnL 表示左滚动）。
编写 Main 类，读取用户输入的动作序列，逐步对骰子执行操作。
最后，输出骰子的当前状态。
输入输出：
输入是一串字符，表示动作指令（如 LRFAC）。
输出是骰子 6 个面当前的数字顺序，按 [左, 右, 前, 后, 上, 下] 顺序。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String directives = sc.nextLine(); // 获取指令字符串
Dice dice = new Dice(); // 创建一个 Dice 对象表示骰子
// 遍历指令字符串中的每个字符
for (char directive : directives.toCharArray()) {
switch (directive) {
case 'L': // 左滚动
dice.turnL();
break;
case 'R': // 右滚动
dice.turnR();
break;
case 'F': // 前滚动
dice.turnF();
break;
case 'B': // 后滚动
dice.turnB();
break;
case 'A': // 逆时针旋转
dice.turnA();
break;
case 'C': // 顺时针旋转
dice.turnC();
break;
}
}
dice.print(); // 输出最终状态
}
}
// 定义 Dice 类，用于表示骰子和其操作
class Dice {
int l = 1, r = 2, f = 3, b = 4, t = 5, bot = 6; // 初始化 6 个面的数字
// 骰子向左滚动
public void turnL() {
int tmp = r; // 临时存储右面的值
r = bot; // 右面变为底面
bot = l; // 底面变为左面
l = t; // 左面变为顶面
t = tmp; // 顶面变为原来的右面
}
// 骰子向右滚动
public void turnR() {
int tmp = l; // 临时存储左面的值
l = bot; // 左面变为底面
bot = r; // 底面变为右面
r = t; // 右面变为顶面
t = tmp; // 顶面变为原来的左面
}
// 骰子向前滚动
public void turnF() {
int tmp = f; // 临时存储前面的值
f = t; // 前面变为顶面
t = b; // 顶面变为后面
b = bot; // 后面变为底面
bot = tmp; // 底面变为原来的前面
}
// 骰子向后滚动
public void turnB() {
int tmp = t; // 临时存储顶面的值
t = f; // 顶面变为前面
f = bot; // 前面变为底面
bot = b; // 底面变为后面
b = tmp; // 后面变为原来的顶面
}
// 骰子逆时针旋转
public void turnA() {
int tmp = r; // 临时存储右面的值
r = f; // 右面变为前面
f = l; // 前面变为左面
l = b; // 左面变为后面
b = tmp; // 后面变为原来的右面
}
// 骰子顺时针旋转
public void turnC() {
int tmp = f; // 临时存储前面的值
f = r; // 前面变为右面
r = b; // 右面变为后面
b = l; // 后面变为左面
l = tmp; // 左面变为原来的前面
}
// 输出当前骰子状态
public void print() {
// 将 6 个面的状态按顺序拼接为字符串并输出
String state = "" + l + r + f + b + t + bot;
System.out.println(state);
}
}
C++解法
- 解题思路
- 问题描述： 模拟骰子的滚动和旋转，根据用户输入的指令序列（如 LRFAC）对骰子进行操作，最终输出骰子六个面的状态（按 [左, 右, 前, 后, 上, 下] 的顺序）。
骰子状态表示：
使用六个整数变量表示骰子的六个面：
l（左）、r（右）、f（前）、b（后）、t（上）、bot（下）。
初始状态为：
css
复制
编辑
l=1, r=2, f=3, b=4, t=5, bot=6
操作规则：
每个指令对应一个操作：
L（左滚）：左 -> 顶，顶 -> 右，右 -> 底，底 -> 左
R（右滚）：右 -> 顶，顶 -> 左，左 -> 底，底 -> 右
F（前滚）：前 -> 顶，顶 -> 后，后 -> 底，底 -> 前
B（后滚）：后 -> 顶，顶 -> 前，前 -> 底，底 -> 后
A（逆时针旋转）：前 -> 左，左 -> 后，后 -> 右，右 -> 前
C（顺时针旋转）：前 -> 右，右 -> 后，后 -> 左，左 -> 前
每个操作通过交换变量值实现。
实现步骤：
定义 Dice 类，封装骰子的状态和操作。
在 Dice 类中，为每个操作定义一个方法，直接修改状态。
编写主程序：
从标准输入读取用户指令序列。
逐个解析指令，调用对应的骰子操作方法。
输出骰子最终状态。
输入输出：
输入：一个字符串，表示动作指令序列（如 LRFAC）。
输出：骰子六个面的状态，按 [左, 右, 前, 后, 上, 下] 的顺序输出。
#include <iostream>
#include <string>
using namespace std;
// 定义骰子类
class Dice {
public:
// 定义六个面的初始状态
int l = 1, r = 2, f = 3, b = 4, t = 5, bot = 6;
// 骰子向左滚动
void turnL() {
int tmp = r; // 保存右面的值
r = bot; // 右面变为底面
bot = l; // 底面变为左面
l = t; // 左面变为顶面
t = tmp; // 顶面变为原来的右面
}
// 骰子向右滚动
void turnR() {
int tmp = l; // 保存左面的值
l = bot; // 左面变为底面
bot = r; // 底面变为右面
r = t; // 右面变为顶面
t = tmp; // 顶面变为原来的左面
}
// 骰子向前滚动
void turnF() {
int tmp = f; // 保存前面的值
f = t; // 前面变为顶面
t = b; // 顶面变为后面
b = bot; // 后面变为底面
bot = tmp; // 底面变为原来的前面
}
// 骰子向后滚动
void turnB() {
int tmp = t; // 保存顶面的值
t = f; // 顶面变为前面
f = bot; // 前面变为底面
bot = b; // 底面变为后面
b = tmp; // 后面变为原来的顶面
}
// 骰子逆时针旋转
void turnA() {
int tmp = r; // 保存右面的值
r = f; // 右面变为前面
f = l; // 前面变为左面
l = b; // 左面变为后面
b = tmp; // 后面变为原来的右面
}
// 骰子顺时针旋转
void turnC() {
int tmp = f; // 保存前面的值
f = r; // 前面变为右面
r = b; // 右面变为后面
b = l; // 后面变为左面
l = tmp; // 左面变为原来的前面
}
// 打印当前骰子状态
void print() {
// 按顺序输出 [左, 右, 前, 后, 上, 下] 的状态
cout << l << r << f << b << t << bot << endl;
}
};
int main() {
string directives; // 定义用于存储指令序列的字符串
getline(cin, directives); // 从输入中读取整行指令字符串
Dice dice; // 创建一个骰子对象
// 遍历指令字符串中的每个字符，依次执行对应操作
for (char directive : directives) {
switch (directive) {
case 'L': dice.turnL(); break; // 左滚
case 'R': dice.turnR(); break; // 右滚
case 'F': dice.turnF(); break; // 前滚
case 'B': dice.turnB(); break; // 后滚
case 'A': dice.turnA(); break; // 逆时针旋转
case 'C': dice.turnC(); break; // 顺时针旋转
}
}
dice.print(); // 输出骰子的最终状态
return 0; // 程序结束
}
C解法
更新中
JS解法
更新中
注意：
如果发现代码有用例覆盖不到的情况，欢迎反馈！会在第一时间修正，更新。
解题不易，如对您有帮助，欢迎点赞/收藏