csu 1510 Happy Robot（字符串DP，记忆化搜索）

最新推荐文章于 2024-03-18 16:59:26 发布
最新推荐文章于 2024-03-18 16:59:26 发布
阅读量620 收藏 1
点赞数
分类专栏： 动态规划 搜索 文章标签： ACM 搜索 dp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/acm_cxq/article/details/52217627
版权

Happy RobotTime Limit: 1 Sec  Memory Limit: 128 MB
Submit: 182  Solved: 85
[Submit][Status][Web Board]

Description

Input

There will be at most 1000 test cases. Each case contains a command sequence with no more than 1000 characters.

Output

For each test case, print the case number, followed by minimal/maximal possible x (in this order), then the minimal/maximal possible y.

Sample Input

F?F
L??
LFFFRF

Sample Output

Case 1: 1 3 -1 1
Case 2: -1 1 0 2
Case 3: 1 1 3 3

题意：给一个字符串，包含有四种字符，F表示向前走，L表示在当前位置向左转，R表示在当前位置向右转，？表示执行上面三种任意一种都可以

机器人从(0,0)开始，输出x,y的最小值和最大值

思路：用记忆化搜索从后往前搜索，搜过的位置可以直接返回。DP里要保存在当前这个位置朝向某个方向极值

队友还提供了一种字符串DP的思路，其实也差不多。

关键在于此题不能在二维平面考虑，要在字符串上考虑才可以。

这里给出两个代码，记忆化搜索的方向是上下左右，字符串DP的方向是上右下左

代码1：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
using namespace std;
#define N 1050
#define INF 99999999
struct Node
{
    int minx,maxx,miny,maxy;
} dp[N][4];
char a[N];
int vis[N][4];
int len;
int Min(int b,int c,int d)
{
    if(b>c) b=c;
    return b<d?b:d;
}
int Max(int b,int c,int d)
{
    if(b<c) b=c;
    return b>d?b:d;
}
Node dfs(int k,int f)
{
    if(vis[k][f]) return dp[k][f];
    vis[k][f]=1;
    dp[k][f].minx=dp[k][f].maxx=dp[k][f].miny=dp[k][f].maxy=0;
    if(k==len-1)
    {
        if(a[k]=='F')
        {
            if(f==0) dp[k][f].maxy=1,dp[k][f].miny=1;
            else if(f==1) dp[k][f].maxy=-1,dp[k][f].miny=-1;
            else if(f==2) dp[k][f].minx=-1,dp[k][f].maxx=-1;
            else dp[k][f].minx=1,dp[k][f].maxx=1;
        }
        else if(a[k]=='?')
        {
            if(f==0) dp[k][f].maxy=1;
            else if(f==1) dp[k][f].miny=-1;
            else if(f==2) dp[k][f].minx=-1;
            else dp[k][f].maxx=1;
        }
    }
    else
    {
        if(a[k]=='L')
        {
            if(f==0) dp[k][f]=dfs(k+1,2);
            else if(f==1) dp[k][f]=dfs(k+1,3);
            else if(f==2) dp[k][f]=dfs(k+1,1);
            else dp[k][f]=dfs(k+1,0);
        }
        else if(a[k]=='R')
        {
            if(f==0) dp[k][f]=dfs(k+1,3);
            else if(f==1) dp[k][f]=dfs(k+1,2);
            else if(f==2) dp[k][f]=dfs(k+1,0);
            else dp[k][f]=dfs(k+1,1);
        }
        else if(a[k]=='F')
        {
            if(f==0)
            {
                dp[k][f]=dfs(k+1,0);
                dp[k][f].maxy++;
                dp[k][f].miny++;
            }
            else if(f==1)
            {
                dp[k][f]=dfs(k+1,1);
                dp[k][f].miny--;
                dp[k][f].maxy--;
            }
            else if(f==2)
            {
                dp[k][f]=dfs(k+1,2);
                dp[k][f].minx--;
                dp[k][f].maxx--;
            }
            else
            {
                dp[k][f]=dfs(k+1,3);
                dp[k][f].maxx++;
                dp[k][f].minx++;
            }
        }
        else
        {
            Node b,c,d,e;
            if(f==0)
            {
                b=dfs(k+1,0);
                b.maxy++; b.miny++;
                c=dfs(k+1,2);
                d=dfs(k+1,3);
                dp[k][f].minx=Min(b.minx,c.minx,d.minx);
                dp[k][f].maxx=Max(b.maxx,c.maxx,d.maxx);
                dp[k][f].miny=Min(b.miny,c.miny,d.miny);
                dp[k][f].maxy=Max(b.maxy,c.maxy,d.maxy);
            }
            else if(f==1)
            {
                b=dfs(k+1,1);
                b.maxy--;  b.miny--;
                c=dfs(k+1,3);
                d=dfs(k+1,2);
                dp[k][f].minx=Min(b.minx,c.minx,d.minx);
                dp[k][f].maxx=Max(b.maxx,c.maxx,d.maxx);
                dp[k][f].miny=Min(b.miny,c.miny,d.miny);
                dp[k][f].maxy=Max(b.maxy,c.maxy,d.maxy);
            }
            else if(f==2)
            {
                b=dfs(k+1,2);
                b.maxx--; b.minx--;
                c=dfs(k+1,1);
                d=dfs(k+1,0);
                dp[k][f].minx=Min(b.minx,c.minx,d.minx);
                dp[k][f].maxx=Max(b.maxx,c.maxx,d.maxx);
                dp[k][f].miny=Min(b.miny,c.miny,d.miny);
                dp[k][f].maxy=Max(b.maxy,c.maxy,d.maxy);
            }
            else
            {
                b=dfs(k+1,3);
                b.maxx++; b.minx++;
                c=dfs(k+1,0);
                d=dfs(k+1,1);
                dp[k][f].minx=Min(b.minx,c.minx,d.minx);
                dp[k][f].maxx=Max(b.maxx,c.maxx,d.maxx);
                dp[k][f].miny=Min(b.miny,c.miny,d.miny);
                dp[k][f].maxy=Max(b.maxy,c.maxy,d.maxy);
            }
        }
    }
    return dp[k][f];
}
int main()
{
    int cas=1;
    while(~scanf("%s",a))
    {
        len=strlen(a);
        memset(vis,0,sizeof(vis));
        Node ans=dfs(0,3);
        printf("Case %d: %d %d %d %d\n",cas++,ans.minx,ans.maxx,ans.miny,ans.maxy);
    }
    return 0;
}

代码2:

#include<iostream>
#include<cstdio>
#include<cstring>
#define max(a,b) (a) > (b) ? (a) : (b)
#define min(a,b) (a) < (b) ? (a) : (b)
using namespace std;

const int maxn = 1005;
const int inf = 0x3f3f3f3f;
int dp[maxn][4],n;
char str[maxn];

int MAX(int a,int b,int c,int d)
{
	return max(a,max(b,max(c,d)));
}

int MIN(int a,int b,int c,int d)
{
	return min(a,min(b,min(c,d)));
}

void DP1()
{
	for(int i = 0; i < n; i++)
		for(int j = 0; j < 4; j++)
			dp[i][j] = inf;
	if(str[0] == 'F')
		dp[0][1] = 1;
	else if(str[0] == 'L')
		dp[0][0] = 0;
	else if(str[0] == 'R')
		dp[0][2] = 0;
	else 
	{
		dp[0][0] = 0;
		dp[0][1] = 1;
		dp[0][2] = 0;
	}
	for(int i = 1; i < n; i++)
		for(int j = 0; j < 4; j++) //上一个指令执行后的方向
		{
			if(str[i] == 'F') //前进	
			{
				if(j == 0) //向上
					dp[i][j] = min(dp[i][j],dp[i-1][j]);
				else if(j == 1) //向右
					dp[i][j] = min(dp[i][j],dp[i-1][j] + 1);
				else if(j == 2) //向下
					dp[i][j] = min(dp[i][j],dp[i-1][j]);
				else //向左
					dp[i][j] = min(dp[i][j],dp[i-1][j] - 1);
			}
			else if(str[i] == 'L')
			{
				int d = ((j - 1) % 4 + 4) % 4;
				dp[i][d] = min(dp[i][d],dp[i-1][j]);
			}
			else if(str[i] == 'R')
			{
				int d = (j + 1) % 4;
				dp[i][d] = min(dp[i][d],dp[i-1][j]);
			}
			else
			{
				if(j == 0) //向上
					dp[i][j] = min(dp[i][j],dp[i-1][j]);
				else if(j == 1) //向右
					dp[i][j] = min(dp[i][j],dp[i-1][j] + 1);
				else if(j == 2) //向下
					dp[i][j] = min(dp[i][j],dp[i-1][j]);
				else //向左
					dp[i][j] = min(dp[i][j],dp[i-1][j] - 1);
				int d = ((j - 1) % 4 + 4) % 4;
				dp[i][d] = min(dp[i][d],dp[i-1][j]);
				d = (j + 1) % 4;
				dp[i][d] = min(dp[i][d],dp[i-1][j]);
			}
		}
}

void DP2()
{
	for(int i = 0; i < n; i++)
		for(int j = 0; j < 4; j++)
			dp[i][j] = -inf;
	if(str[0] == 'F')
		dp[0][1] = 1;
	else if(str[0] == 'L')
		dp[0][0] = 0;
	else if(str[0] == 'R')
		dp[0][2] = 0;
	else 
	{
		dp[0][0] = 0;
		dp[0][1] = 1;
		dp[0][2] = 0;
	}
	for(int i = 1; i < n; i++)
		for(int j = 0; j < 4; j++) //上一个指令执行后的方向
		{
			if(str[i] == 'F') //前进	
			{
				if(j == 0) //向上
					dp[i][j] = max(dp[i][j],dp[i-1][j]);
				else if(j == 1) //向右
					dp[i][j] = max(dp[i][j],dp[i-1][j] + 1);
				else if(j == 2) //向下
					dp[i][j] = max(dp[i][j],dp[i-1][j]);
				else //向左
					dp[i][j] = max(dp[i][j],dp[i-1][j] - 1);
			}
			else if(str[i] == 'L')
			{
				int d = ((j - 1) % 4 + 4) % 4;
				dp[i][d] = max(dp[i][d],dp[i-1][j]);
			}
			else if(str[i] == 'R')
			{
				int d = (j + 1) % 4;
				dp[i][d] = max(dp[i][d],dp[i-1][j]);
			}
			else
			{
				if(j == 0) //向上
					dp[i][j] = max(dp[i][j],dp[i-1][j]);
				else if(j == 1) //向右
					dp[i][j] = max(dp[i][j],dp[i-1][j] + 1);
				else if(j == 2) //向下
					dp[i][j] = max(dp[i][j],dp[i-1][j]);
				else //向左
					dp[i][j] = max(dp[i][j],dp[i-1][j] - 1);
				int d = ((j - 1) % 4 + 4) % 4;
				dp[i][d] = max(dp[i][d],dp[i-1][j]);
				d = (j + 1) % 4;
				dp[i][d] = max(dp[i][d],dp[i-1][j]);
			}
		}
}

void DP3()
{
	for(int i = 0; i < n; i++)
		for(int j = 0; j < 4; j++)
			dp[i][j] = inf;
	if(str[0] == 'F')
		dp[0][1] = 0;
	else if(str[0] == 'L')
		dp[0][0] = 0;
	else if(str[0] == 'R')
		dp[0][2] = 0;
	else 
	{
		dp[0][0] = 0;
		dp[0][1] = 0;
		dp[0][2] = 0;
	}
	for(int i = 1; i < n; i++)
		for(int j = 0; j < 4; j++) //上一个指令执行后的方向
		{
			if(str[i] == 'F') //前进	
			{
				if(j == 0) //向上
					dp[i][j] = min(dp[i][j],dp[i-1][j] + 1);
				else if(j == 1) //向右
					dp[i][j] = min(dp[i][j],dp[i-1][j]);
				else if(j == 2) //向下
					dp[i][j] = min(dp[i][j],dp[i-1][j] - 1);
				else //向左
					dp[i][j] = min(dp[i][j],dp[i-1][j]);
			}
			else if(str[i] == 'L')
			{
				int d = ((j - 1) % 4 + 4) % 4;
				dp[i][d] = min(dp[i][d],dp[i-1][j]);
			}
			else if(str[i] == 'R')
			{
				int d = (j + 1) % 4;
				dp[i][d] = min(dp[i][d],dp[i-1][j]);
			}
			else
			{
				if(j == 0) //向上
					dp[i][j] = min(dp[i][j],dp[i-1][j] + 1);
				else if(j == 1) //向右
					dp[i][j] = min(dp[i][j],dp[i-1][j]);
				else if(j == 2) //向下
					dp[i][j] = min(dp[i][j],dp[i-1][j] - 1);
				else //向左
					dp[i][j] = min(dp[i][j],dp[i-1][j]);
				int d = ((j - 1) % 4 + 4) % 4;
				dp[i][d] = min(dp[i][d],dp[i-1][j]);
				d = (j + 1) % 4;
				dp[i][d] = min(dp[i][d],dp[i-1][j]);
			}
		}
}

void DP4()
{
	for(int i = 0; i < n; i++)
		for(int j = 0; j < 4; j++)
			dp[i][j] = -inf;
	if(str[0] == 'F')
		dp[0][1] = 0;
	else if(str[0] == 'L')
		dp[0][0] = 0;
	else if(str[0] == 'R')
		dp[0][2] = 0;
	else 
	{
		dp[0][0] = 0;
		dp[0][1] = 0;
		dp[0][2] = 0;
	}
	for(int i = 1; i < n; i++)
		for(int j = 0; j < 4; j++) //上一个指令执行后的方向
		{
			if(str[i] == 'F') //前进	
			{
				if(j == 0) //向上
					dp[i][j] = max(dp[i][j],dp[i-1][j] + 1);
				else if(j == 1) //向右
					dp[i][j] = max(dp[i][j],dp[i-1][j]);
				else if(j == 2) //向下
					dp[i][j] = max(dp[i][j],dp[i-1][j] - 1);
				else //向左
					dp[i][j] = max(dp[i][j],dp[i-1][j]);
			}
			else if(str[i] == 'L')
			{
				int d = ((j - 1) % 4 + 4) % 4;
				dp[i][d] = max(dp[i][d],dp[i-1][j]);
			}
			else if(str[i] == 'R')
			{
				int d = (j + 1) % 4;
				dp[i][d] = max(dp[i][d],dp[i-1][j]);
			}
			else
			{
				if(j == 0) //向上
					dp[i][j] = max(dp[i][j],dp[i-1][j] + 1);
				else if(j == 1) //向右
					dp[i][j] = max(dp[i][j],dp[i-1][j]);
				else if(j == 2) //向下
					dp[i][j] = max(dp[i][j],dp[i-1][j] - 1);
				else //向左
					dp[i][j] = max(dp[i][j],dp[i-1][j]);
				int d = ((j - 1) % 4 + 4) % 4;
				dp[i][d] = max(dp[i][d],dp[i-1][j]);
				d = (j + 1) % 4;
				dp[i][d] = max(dp[i][d],dp[i-1][j]);
			}
		}
}

int main()
{
	int cas = 1;
	while(scanf("%s",str)!=EOF)
	{
		n = strlen(str);
		DP1();
		printf("Case %d: %d ",cas++,MIN(dp[n-1][0],dp[n-1][1],dp[n-1][2],dp[n-1][3]));
		DP2();
		printf("%d ",MAX(dp[n-1][0],dp[n-1][1],dp[n-1][2],dp[n-1][3]));
		DP3();
		printf("%d ",MIN(dp[n-1][0],dp[n-1][1],dp[n-1][2],dp[n-1][3]));
		DP4();
		printf("%d\n",MAX(dp[n-1][0],dp[n-1][1],dp[n-1][2],dp[n-1][3]));
	}
	return 0;
}






acm_cxq
关注
专栏目录
NYOJ564 & CSU 1106 最优对称路径【记忆化搜索+最短路】
AC_Dreameng
08-18 1289
最优对称路径 时间限制：1000 ms  |  内存限制：65535 KB 难度：3 描述     给一个 n 行 n 列的网格，每个格子里有一个 1 到 9 的数字。你需要从左上角走到右下角，其中每一步只能往上、下、左、右四个方向之一走到相邻格子，不能斜着走，也不能走出网格，但可以重复经过一个格子。为了美观，你经过的路径还必须关于“左下-右上”这条对角线对称。下图是一
ACM--字符串--CSU--1550-- Simple String
戎码人生
04-24 937
中南大学OJ题目地址：http://acm.csu.edu.cn/OnlineJudge/problem.php?id=1550 1550: Simple String Time Limit: 1 Sec  Memory Limit: 256 MB Submit: 471  Solved: 206 [Submit][Status][Web Board] Descripti
csu1510(规律)
远方传来风铃
08-26 410
题意：从（0，0）开始在坐标上移动，问x,y分别可以移动到的位置的最小值和最大值，有四种移动方式： F:在当前面对的方向移动一格，一共四个方向，自然是坐标轴的上下左右四个方向，这代表着每次只有x变化或者只有y变化 L:当前方向向左转90度，比如面对着x轴正方向转为y轴正方向 R:向右转90度 ?:这个代表着这个命令由你定，你可以执行上述三个命令中任何一个，当然为了得到极值选哪个命令就是这道
csu1510 Happy Robot 递推
旧时光
08-23 1171
题目链接： csu1510 解题思路： 要求解四个值x_min,x_max,y_min,y_max 首先考虑x_min如何得到：因为机器人最后有可以面向四个方向（E,W,N,S），我们可以用一个数组a[4]来存机器人面向4个方向时x的值 a[0]: x+，a[1]:x-，a[2]:y+,a[3],y-; 只要求出a[4]最后比较出最小值,即为x_mi
CSU 1510 Happy Robot DP
Houheshuai的专栏
05-02 423
Happy Robot Time Limit: 1 Sec  Memory Limit: 128 MB Submit: 147  Solved: 68 [Submit][Status][Web Board] Description Input There will be at most 1000 test cases. Each case c
CSU 1510 Happy Robot(字符串上的dp)
hexianhao的博客
08-16 544
Time Limit: 1 Sec  Memory Limit: 128 MB Submit: 182  Solved: 85 [Submit][Status][Web Board] Description Input There will be at most 1000 test cases. Each case contains a command sequ
湖南14年省赛 H - Happy Robot dp
转角的守望
08-24 703
A robot is moving from (0,0) according to a command sequence. Each character in the sequence is command: • L: turn left • R: turn right • F: go forward one step Interestingly, the command sequenc
字符编码，国际化编程、高级字符串
weixin_43698704的博客
01-30 211
一、字符编码： 文件的写入读出使用的编码必须统一否则会出现乱码。 new OutputStreamWriter(fos, charset); new InputStreamReader(fos, charset); 编码方式charset保持一致。 二、国际化编程 一般是使用java.util.ResourceBundle用于加载语言_国家语言包 java.util.Locale定...
字符串hash笔记
weixin_37964310的博客
04-25 421
（该笔记整理自远航休息栈：点击打开链接）字符串hash可以将字符串映射为整数类型，使得可以快速的匹配字符串首先选择一个适当的进制，要比字符串中字母对应的数字大（一般a-z对应1-26），且不要含有模数的质因子。//对于只有a-z的字符串，27，131，233等可以。选择一个模数（尽量是质数)自然溢出hash：将整数类型定义为unsigned long long，并且hash值&amp; 0x7ff...
Java——在一个类中实现字符串逆序输出和两个数组的交并集
qq_44945999的博客
10-24 451
题目描述： 定义一个类，该类中包含以下几个方法(静态)： 实现两个字符串数组的逆序排序，输出结果为字符串数组； 求两个整形数组的交集； 求两个浮点型数组的并集； 源码： public class Text02{ static String[] result1=new String[50]; static String[] result2=new String[50]; /** * 两个字符串数组逆序输出 * @param str1 * @param str2 */ public
2014年湖南省第十届程序设计大赛 H Happy Robot
u012659423的专栏
10-30 1172
题意： 给你一串由L,R,F,?组成的字符串，L表示
python记忆化搜索——缓存@cache与@lru_cache
我的博客
09-05 7635
python缓存机制
记忆化搜索 （蒟蒻练习生）
cyyyyds857的博客
11-05 313
记忆化搜索是一种通过记录已经遍历过的状态的信息，从而避免对同一状态重复遍历的搜索实现方式。因为记忆化搜索确保了每个状态只访问一次，它也是一种常见的动态规划实现方式。
蓝桥 python笔记11——DFS深度优先搜索、回溯、剪枝、记忆化搜索
最新发布
m0_62861576的博客
03-18 436
【代码】蓝桥 python笔记11——DFS深度优先搜索、回溯、剪枝、记忆化搜索。
记忆化搜索
m0_52711790的博客
10-28 1782
对于学计算机的同学来说，学习算法是一件非常重要的事情，废话不多讲，我们来讲讲“记忆化搜索问题”。
记忆化搜索（例）
weixin_34043301的博客
07-16 288
前言：记忆化搜索是在递归的基础上进行优化，这种方法综合了搜索和动态规划两方面的优点。 记忆化搜索的思想是：在搜索过程中，会有很多重复计算,如果我们能记录一些状态的答案，就可以减少重复搜索量。 实现方式 ①定义好一个数组，用来存储递归所求出来的值，以便接下来进行访问； ②在主程序里，memset一下，一般都是赋初值为-1，然后把这个数组的边界值设置好； ③在递归函数里，首先加一句：if （...
浅析记忆化搜索与dp的基本思想
samscream的博客
01-24 881
看了一些博客，总结出了记忆搜索和dp之间的一些关系 对于01背包这种类型的对于每个物品有选或者不选择两种状态的问题，我们先从暴搜入手思考这个问题 例如洛谷p1048 int n,t; int tcost[103],mget[103]; int ans = 0; void dfs( int pos , int tleft , int tans ){ if( tleft &lt; 0 ...
滑雪
weixin_44106287的博客
10-26 307
题目描述 给定一个R行C列的矩阵，表示一个矩形网格滑雪场。 矩阵中第 i 行第 j 列的点表示滑雪场的第 i 行第 j 列区域的高度。 一个人从滑雪场中的某个区域内出发，每次可以向上下左右任意一个方向滑动一个单位距离。 当然，一个人能够滑动到某相邻区域的前提是该区域的高度低于自己目前所在区域的高度。 下面给出一个矩阵作为例子： 1 2 3 4 5 16 17 18 19 6 15 24 25 20 7 14 23 22 21 8 13 12 11 10 9 在给定矩阵中，一条可行的滑行轨迹为24-17
python字符串转16进制
09-19
### 回答1： 可以使用Python内置函数`bytes()`和`.hex()`来将字符串转换为16进制表示。具体方法如下： ```python str = "Hello World!" hex_str = bytes(str, encoding='utf-8').hex() print(hex_str) ``` 运行结果为： ``` 48656c6c6f20576f726c6421 ``` 其中，`bytes()`函数将字符串转换为字节流，参数`encoding='utf-8'`指定编码格式为UTF-8；`.hex()`函数将字节流转换为16进制表示。 ### 回答2： Python中可以使用`binascii`模块中的`hexlify`函数将字符串转换为16进制表示。 ```python import binascii def str_to_hex(string): hex_str = binascii.hexlify(string.encode()).decode() return hex_str ``` 在这里，我们首先使用`encode`函数将字符串转换为字节流，然后使用`hexlify`函数将字节流转换为16进制表示。最后，我们使用`decode`函数将字节流转换回字符串，并将结果返回。 下面是一个例子： ```python message = "Hello, World!" hex_message = str_to_hex(message) print(hex_message) # 输出: 48656c6c6f2c20576f726c64214 ``` 在这个例子中，我们将字符串"Hello, World!"转换为16进制表示，并输出结果"48656c6c6f2c20576f726c64214"。 ### 回答3： 在Python中，可以通过使用内置的hex函数将字符串转换为十六进制。 hex函数将每个字符转换为其对应的十六进制表示，然后将其连接成一个字符串。下面是一个示例： ```python string = "Hello, World!" # 原始字符串 hex_string = ''.join([hex(ord(c))[2:] for c in string]) # 将每个字符转换为十六进制，并连接成一个字符串 print(hex_string) # 输出结果为 "48656c6c6f2c20576f726c6421" ``` 在上面的代码中，首先定义了一个字符串变量`string`，其值为"Hello, World!"。然后，通过列表推导式和`hex`函数，将每个字符转换为其十六进制表示。`ord`函数用于获取字符的ASCII码，`hex`函数将ASCII码转换为十六进制字符串。最后，使用`''.join()`函数将每个字符的十六进制表示连接成一个字符串。最终的结果为"48656c6c6f2c20576f726c6421"。 需要注意的是，`hex`函数返回的十六进制字符串以"0x"开头，而我们只需要字符之间的十六进制表示。因此，我们使用切片操作[2:]来去除开头的"0x"。 使用上述方法，你可以将任意字符串转换为十六进制表示。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值