最常见的程序员面试题(10)字符串的处理

最新推荐文章于 2022-11-04 23:58:48 发布
最新推荐文章于 2022-11-04 23:58:48 发布
阅读量741 收藏
点赞数
分类专栏： 数据结构&算法
字符串的搜索，匹配，查找，压缩，编码/解码，是一类非常常见的问题。

(1) 压缩一个字符串当中的空格,例如把" I  like   csdn    "压缩成"I like csdn"。注意，单词之间的空格，N个空格要压缩到1个，也就是要减少N-1个空格。行首/行尾的空格全部去掉。
     算法复杂度O(n)，扫描一遍，在扫描的过程中记住当前已经有了多少个多余的空格(pos)，然后把非空格的字符都向前移动pos个字符。处理完了整个字符串以后再从行尾往前扫描到底一个非空格字符，再其后面填上'\0'，工作完成。

[cpp] view plain copy print ?
  1. #include<string>   
  2. using namespace std;  
  3. void f(char* str){//输入/输出参数   
  4.     if(str==nullptr || str[0]=='\0')return;//错误处理   
  5.     size_t len = strlen(str);  
  6.     size_t pos = 0;//当前已经压缩的空格数量   
  7.     bool fSpace = false;  
  8.     bool fIsTail = false;  
  9.     for(size_t i = 0; i<len; ++ i){  
  10.         if(str[i]==' '){  
  11.             if(!fSpace){  
  12.                 fSpace=true;//开始空格子串   
  13.                 if(i==0){  
  14.                     ++pos;//行首空格   
  15.                 }  
  16.             }else{//有了标志位了,说明是多余空格   
  17.                 ++pos;  
  18.             }  
  19.         }else{//当前不是空格   
  20.             if(fSpace==true)fSpace=false;  
  21.             str[i-pos]=str[i];  
  22.             str[i]=' ';  
  23.         }  
  24.     }  
  25.     while(str[--len]==' ');  
  26.     str[len+1]='\0';  
  27. }  
  28. int main(){  
  29.     char buf[]=" I  like   csdn    ";  
  30.     f(buf);//压缩空格   
  31.     printf("%s,%d\n",buf,strlen(buf));  
  32.     return 0;  
  33. }  
#include<string>
using namespace std;
void f(char* str){//输入/输出参数
	if(str==nullptr || str[0]=='\0')return;//错误处理
	size_t len = strlen(str);
	size_t pos = 0;//当前已经压缩的空格数量
	bool fSpace = false;
	bool fIsTail = false;
	for(size_t i = 0; i<len; ++ i){
		if(str[i]==' '){
			if(!fSpace){
				fSpace=true;//开始空格子串
				if(i==0){
					++pos;//行首空格
				}
			}else{//有了标志位了,说明是多余空格
				++pos;
			}
		}else{//当前不是空格
			if(fSpace==true)fSpace=false;
			str[i-pos]=str[i];
			str[i]=' ';
		}
	}
	while(str[--len]==' ');
	str[len+1]='\0';
}
int main(){
	char buf[]=" I  like   csdn    ";
	f(buf);//压缩空格
	printf("%s,%d\n",buf,strlen(buf));
	return 0;
}

(2) 汉字编码的题目，例如输入一个数字串"00001204567809001"输出"一万两千零四十五亿六千七百八十万九千零一"
分析: k可以分步骤进行，先对字符串进行错误处理，然后遍历前面的0，找到真正的数字开始的地方。
计算的过程需要将整个字符串分段，8个字符一段(亿)，其中又要再次分为两段(万)，然后对于4位数进行编码

[cpp] view plain copy print ?
  1. #include"stdafx.h"   
  2. #include <iostream>   
  3. #include <cassert>   
  4. #include <cstring>   
  5. #include <string>   
  6. #include <vector>   
  7. using namespace std;  
  8.   
  9. const char yi[]  = "亿";  
  10. const char wan[] = "万";  
  11. const char* table[] ={  
  12.     "十","百","千",  
  13. };  
  14. const char* digits[] ={  
  15.     "零","一","二","三","四","五","六","七","八","九"  
  16. };  
  17. char* preprocess(char* psz){//错误处理，预处理   
  18.     if(psz==nullptr||*psz==0)return nullptr;  
  19.     size_t len = strlen(psz);  
  20.     size_t nIndex = 0;  
  21.     for(;nIndex<len;++nIndex){  
  22.         if(psz[nIndex]!='0')break;  
  23.     }  
  24.     if(nIndex==len-1)return nullptr;  
  25.     char* pret = psz+nIndex;//去掉了字符串前面的0串   
  26.     return pret;  
  27. }  
  28. size_t sum(const char*psz, size_t len){  
  29.     size_t ret=0;  
  30.     for(size_t s=0;s<len;++s){  
  31.         ret+=psz[s];  
  32.     }  
  33.     return ret;  
  34. }  
  35. string sRet="";//输出字符串   
  36. void addyi(size_t len){  
  37.     for(size_t n=0;n<len;++n){  
  38.         sRet+=yi;  
  39.     }  
  40. }  
  41. void processNdigits(const char*psz,size_t N){//处理4个数字,N<=4   
  42.     assert(N<=4);  
  43.     bool fZero=false;  
  44.     for(size_t s=0;s<N;++s){  
  45.         if(psz[s]=='0'){  
  46.             if(fZero==false){  
  47.                 fZero=true;//连零的请款也只输出一个零   
  48.                 if(s!=N-1)sRet+=digits[0];//个位的0不打印   
  49.             }  
  50.         }else{  
  51.             fZero=false;//清除0标记   
  52.             sRet+=digits[psz[s]-'0'];  
  53.   
  54.             int index=N-2-s;              
  55.             if(index>=0)  
  56.                 sRet+=table[index];//加上十百千的单位   
  57.         }  
  58.     }  
  59. }  
  60. void process4digits(const char*psz){  
  61.     processNdigits(psz,4);  
  62. }  
  63. void process(char* psz){//处理算法   
  64.     char* s = preprocess(psz);  
  65.     if(s==nullptr){  
  66.         sRet="空";  
  67.         return;  
  68.     }  
  69.   
  70.     size_t len = strlen(s);  
  71.     size_t nSection = len>>3; //按照"亿"分段   
  72.     char* pSection = s;  
  73.     for(size_t n=0;n<=nSection;++n){ //处理每个分段   
  74.         //首先计算当前段的长度和起始指针。除了第一个段长度可能比8少以外，其他都是8个字节   
  75.         size_t nSectionLen=(n==0)?(len%8):8;//当前段的长度   
  76.         if(nSectionLen==0)continue;  
  77.   
  78.         //每个分段划分成前4个数字(万位)和后4个数字   
  79.         else if(nSectionLen==8){  
  80.             if(sum(pSection,4)==0){//如果万位全0，那么需要给万位自身输出一个'零'   
  81.                 pSection+=4;  
  82.                 sRet+=table[0];//输出'零'   
  83.             }else{//处理万位的4个数字并加上万   
  84.                 process4digits(pSection);  
  85.                 sRet+=wan;  
  86.             }  
  87.   
  88.             pSection+=4;  
  89.             process4digits(pSection);//处理千位到个位的4个数字   
  90.         }else{//开始的一段数字，不够8位   
  91.             if(nSectionLen>4){  
  92.                 size_t leadingLen = nSectionLen-4;  
  93.                 processNdigits(pSection,leadingLen);  
  94.                 nSectionLen=4;  
  95.                 pSection+=leadingLen;  
  96.                 sRet+=wan;  
  97.             }  
  98.             processNdigits(pSection,nSectionLen);  
  99.             pSection+=nSectionLen;  
  100.         }  
  101.         addyi(nSection-n);  
  102.     }  
  103.     cout<<sRet<<endl;  
  104. }  
  105.   
  106. int main()  
  107. {  
  108.     char di[]="00001204567809001";  
  109.     process(di);  
  110.     return 0;  
  111. }  
#include"stdafx.h"
#include <iostream>
#include <cassert>
#include <cstring>
#include <string>
#include <vector>
using namespace std;

const char yi[]  = "亿";
const char wan[] = "万";
const char* table[] ={
    "十","百","千",
};
const char* digits[] ={
    "零","一","二","三","四","五","六","七","八","九"
};
char* preprocess(char* psz){//错误处理，预处理
    if(psz==nullptr||*psz==0)return nullptr;
    size_t len = strlen(psz);
    size_t nIndex = 0;
    for(;nIndex<len;++nIndex){
        if(psz[nIndex]!='0')break;
    }
    if(nIndex==len-1)return nullptr;
    char* pret = psz+nIndex;//去掉了字符串前面的0串
    return pret;
}
size_t sum(const char*psz, size_t len){
    size_t ret=0;
    for(size_t s=0;s<len;++s){
        ret+=psz[s];
    }
    return ret;
}
string sRet="";//输出字符串
void addyi(size_t len){
    for(size_t n=0;n<len;++n){
        sRet+=yi;
    }
}
void processNdigits(const char*psz,size_t N){//处理4个数字,N<=4
	assert(N<=4);
    bool fZero=false;
    for(size_t s=0;s<N;++s){
        if(psz[s]=='0'){
            if(fZero==false){
                fZero=true;//连零的请款也只输出一个零
                if(s!=N-1)sRet+=digits[0];//个位的0不打印
            }
        }else{
            fZero=false;//清除0标记
            sRet+=digits[psz[s]-'0'];

			int index=N-2-s;			
			if(index>=0)
				sRet+=table[index];//加上十百千的单位
        }
    }
}
void process4digits(const char*psz){
	processNdigits(psz,4);
}
void process(char* psz){//处理算法
    char* s = preprocess(psz);
    if(s==nullptr){
		sRet="空";
        return;
	}

    size_t len = strlen(s);
    size_t nSection = len>>3; //按照"亿"分段
	char* pSection = s;
    for(size_t n=0;n<=nSection;++n){ //处理每个分段
        //首先计算当前段的长度和起始指针。除了第一个段长度可能比8少以外，其他都是8个字节
        size_t nSectionLen=(n==0)?(len%8):8;//当前段的长度
		if(nSectionLen==0)continue;

        //每个分段划分成前4个数字(万位)和后4个数字
		else if(nSectionLen==8){
			if(sum(pSection,4)==0){//如果万位全0，那么需要给万位自身输出一个'零'
				pSection+=4;
				sRet+=table[0];//输出'零'
			}else{//处理万位的4个数字并加上万
				process4digits(pSection);
				sRet+=wan;
			}

			pSection+=4;
			process4digits(pSection);//处理千位到个位的4个数字
		}else{//开始的一段数字，不够8位
			if(nSectionLen>4){
				size_t leadingLen = nSectionLen-4;
				processNdigits(pSection,leadingLen);
				nSectionLen=4;
				pSection+=leadingLen;
				sRet+=wan;
			}
			processNdigits(pSection,nSectionLen);
			pSection+=nSectionLen;
		}
        addyi(nSection-n);
    }
	cout<<sRet<<endl;
}

int main()
{
    char di[]="00001204567809001";
    process(di);
    return 0;
}

(3) 字符串编码/反编码的问题。游程编码是一类经典的问题。

[cpp] view plain copy print ?
  1. #include"stdafx.h"   
  2. #include<Windows.h>   
  3. #include<iostream>   
  4. #include<vector>   
  5. using namespace std;  
  6. /* 
  7.  * 游程编码的问题: 
  8.  * 游程编码的输入可能是一个二进制串或者字符串，长度未知(因为可能很长) 
  9.  * 需要用"[内容-长度]对"的方式对其进行编码。例如0000111222编码成041323 
  10.  * 也就是0有4个，1有3个，2有3个，编码成041323 
  11.  * 需要注意的问题是: 
  12.  * (1)如果只有一个字符/一种字符的情况 
  13.  * (2)结束的情况 
  14.  * (3)重复个数很多的情况: 因为我们用固定的"一个字节"来表示长度 
  15.  * 因此每个"[内容-长度]对"表示最大长度就是255字节。 
  16.  * 更多的重复要用多个"[内容-长度]对"来表示 
  17.  */  
  18. int main()  
  19. {  
  20.     char arr[]="0000111222";  
  21.     struct encode{  
  22.         char c;  
  23.         BYTE length;  
  24.         encode(char _c,BYTE _length):  
  25.             c(_c),length(_length)  
  26.         {}  
  27.     };  
  28.     vector<encode> vEncode;  
  29.     char* psz=arr;  
  30.     char cCurrent = '\0';  
  31.     size_t nCount = 1;  
  32.     while(*psz!='\0'){  
  33.         cCurrent=*psz;  
  34.         if(nCount==255){  
  35.             vEncode.push_back(encode(cCurrent,(BYTE)nCount));  
  36.             nCount=1;  
  37.         }  
  38.         if(* ++psz ==cCurrent){  
  39.             ++nCount;  
  40.             continue;  
  41.         }else{  
  42.             vEncode.push_back(encode(cCurrent,(BYTE)nCount));  
  43.             nCount=1;  
  44.         }  
  45.     }  
  46.     for( auto it = vEncode.begin(); it != vEncode.end(); ++ it ){  
  47.         cout<<it->c<<(int)it->length<<endl;  
  48.     }  
  49.     return 0;  
  50. }  
#include"stdafx.h"
#include<Windows.h>
#include<iostream>
#include<vector>
using namespace std;
/*
 * 游程编码的问题:
 * 游程编码的输入可能是一个二进制串或者字符串，长度未知(因为可能很长)
 * 需要用"[内容-长度]对"的方式对其进行编码。例如0000111222编码成041323
 * 也就是0有4个，1有3个，2有3个，编码成041323
 * 需要注意的问题是:
 * (1)如果只有一个字符/一种字符的情况
 * (2)结束的情况
 * (3)重复个数很多的情况: 因为我们用固定的"一个字节"来表示长度
 * 因此每个"[内容-长度]对"表示最大长度就是255字节。
 * 更多的重复要用多个"[内容-长度]对"来表示
 */
int main()
{
    char arr[]="0000111222";
	struct encode{
		char c;
		BYTE length;
		encode(char _c,BYTE _length):
			c(_c),length(_length)
		{}
	};
	vector<encode> vEncode;
	char* psz=arr;
	char cCurrent = '\0';
	size_t nCount = 1;
	while(*psz!='\0'){
		cCurrent=*psz;
		if(nCount==255){
			vEncode.push_back(encode(cCurrent,(BYTE)nCount));
			nCount=1;
		}
		if(* ++psz ==cCurrent){
			++nCount;
			continue;
		}else{
			vEncode.push_back(encode(cCurrent,(BYTE)nCount));
			nCount=1;
		}
	}
	for( auto it = vEncode.begin(); it != vEncode.end(); ++ it ){
		cout<<it->c<<(int)it->length<<endl;
	}
    return 0;
}


zealot_2002
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
面试题（一）-------面试中常见的字符串类型题目及思路解答
Stanley-Hwang学习交流分享
02-17 3511
1.左旋转字符串 2.替换空格 题目：请实现一个函数，把字符串中的每个空格替换成“%20”。例如输入“We are happy.”,则输出"We%20are%20happy"。 思路扩展题目：有两个排序的数组A1和A2，内存在A1的末尾有足够多的空余空间容纳A2。请实现一个函数，把A2中的所有数字插入到A1中并且所有的数字是排序的 3.字符串的排列 题目：输入一个字符串，打印出该
程序员面试题精选-输出一个字符串的所有子串
03-12
对于面试而言，理解和掌握这两种方法有助于展示候选人在字符串处理和算法设计上的能力。同时，这也体现了在面对复杂问题时，如何通过变换思维角度，将问题简化为更易于处理的形式，这是编程解决问题的重要技巧之一。...
字符串处理面试题;
一份耕耘 一份收货
11-13 502
<?php //$contents=file_get_contents('http://news.baidu.com/'); header('Content-type:text/html;charset=utf8'); /* 字符串处理面试题; */ $str="this is a string?;\r\nYes,it's!"; //处理为：array("this is a string",
关于字符串的面试题总结
yuanlanxiaup
12-25 208
看到关于字符串的面试题总结，第一题我就曾经遇到过- - 摘录于下， 来源：http://rjwyr.blog.163.com/blog/static/112986400201153061911864/ 字符串操作 #include &lt;iostream&gt; #include &lt;sstream&gt; #include &lt;limi...
（程序员面试题）字符串处理之寻找最大不重复子串
11-17 1116
寻找最大不重复子串
华为面试题--字符串处理
weixin_44001521的博客
03-31 575
//输入一个字符串，字符串中包含了全量字符集和已占用字符集，两个字符集用@相连。 //@前的字符集合为全量字符集，@后的字符集为已占用字符集合。 //已占用字符集中的字符一定是全量字符集中的字符。 //字符集中的字符跟字符之间使用英文逗号分隔。 //字符集中的字符表示为字符加数字，字符跟数字使用英文冒号分隔，比如a:1，表示1个a字符。 //字符只考虑英文字母，区分大小写，数字只考虑正整形，数量不...
CC++程序员应聘常见面试题.docx
11-27
《C/C++程序员应聘常见面试题解析》 在IT行业中，C/C++程序员的角色至关重要，他们的技能水平直接影响到软件的质量和性能。面试是检验候选人技术实力的重要环节，其中常见的面试题往往能反映出应聘者的全然功底和...
c++面试题字符串拷贝函数示例
09-04
在C++编程语言中，字符串处理是非常重要的一部分，特别是在面试和笔试中，考察开发者对指针操作和字符串类的理解是常见的题目。本文将详细探讨题目中提到的“字符串拷贝函数”及其相关的知识点。 首先，我们来看...
Java常见技术面试题程序员面试合集资料
最新发布
05-27
- 正则表达式在字符串处理中的应用。 6. **多线程**： - 线程的创建方式：实现Runnable接口和继承Thread类。 - 线程同步方法：synchronized关键字，wait()、notify()和notifyAll()方法。 - 线程池的理解与...
总结C/C++面试中可能会碰到的字符串指针题
08-31
在C/C++编程中，字符串处理是至关重要的部分，尤其在面试中，字符串指针题经常作为考察程序员基础技能和思维能力的手段。本篇文章主要针对C/C++面试中可能出现的字符串指针题目进行深入解析。 首先，让我们回顾一下...
字符串常见笔试题
07-25
1 将字符串转化为整数。2 将整数转化为字符串(考虑正负号的问题)。3 实现字符串拷贝函数strcpy（程序的完整性）。4 编程实现memcpy函数（以字节为单位的拷贝）。5 编程实现memmove函数。 等笔试题。
[经典面试题][腾讯]字符串匹配
SmartSi
02-14 232
题目 假设两个字符串中所含有的字符和个数都相同我们就叫这两个字符串匹配，比如：abcda和adabc,由于出现的字符个数都是相同，只是顺序不同，所以这两个字符串是匹配的。要求高效。 思路 假定字符串中都是ASCII字符。用一个数组来计数，前者加，后者减，全部为0则匹配。 代码 /*--------------------------------------------- * 日期：...
算法面试题之字符串子串
Yummy
07-30 825
网易2017年校园招聘题“字符串子串”
一道处理字符串的面试题
wangyangkobe的专栏
03-07 1036
编写如下形式的字符串处理函数，要求将S1指向的字符串倒向复制给S2，如*S1 = "hello",则使 *S2 = "olleh"。且不能使用除S1，和S2以外的其余任何变量。还不能使用任何strlen等库函数。void ReverseStr( const char* s1 ,char* s2);#include using namespace std; void ReverseStr(const char *src, char *dst) { if(*src != '/0') //若sr
字符串处理面试题_字符串包含问题
oLinChuan1的专栏
03-27 639
为了准备面试中出现的字符串问题，我决定做一个系列，以我自己的标准，将自己认为比较优秀的字符串面试题整理一些。希望这样做能够形成解决字符串问题的一般思路，能够比较高效地解决字符串问题。 故特别声明：所有问题的解决思路都是网上大牛们提供的，感谢他们的分享。我做的事情是理解这些思路，用自己的话转述一遍，而不是简单地复制粘贴。我也会注明资料的来源，如果作者觉得有侵权行为，请联系我。 这个问题是看了
前端面试题(字符串处理)
weixin_34159110的博客
06-04 464
写一个字符串转成驼峰的方法 var str = 'boder-bottom-color'; function test(str) { var arr = str.split('-'); for(var i = 1; i<arr.length;i++ ) { arr[i] = arr[i].charAt(0).toUpperCase() + arr[i].su...
常见的字符串面试题
热门推荐
阿咪
01-23 1万+
      基本上求职者进行笔试时没有不考字符串的。字符串也是一种相对简单的数据结构，结合指针，容易多次引起面试官反复发问。我曾不止一次在笔试或面试时遇到下面几道试题。事实上，字符串也是一个考验程序员编程规范和编程习惯的重要考点。不能忽视这些细节，因为这些细节会体现你在操作系统、软件工程、边界内存处理等方面的知识掌控能力。一、整数与字符串之间的相互转换1.将字符串转换成整数      例如
字符串(面试)
hello_bravo_的博客
12-28 594
最近看书看不下去就刷面试题，决定把字符串有关面试题都写这个文章里1.实现一个函数在字符串中把空格替换成”%20” 注意是否会发生内存溢出#include <iostream> #include <cstring>using namespace std; void changeZi(char** buff, int size) { int num = 0;//多少个空格 char*
字符串基础面试题
扬帆天涯
11-04 635
字符串面试题（2022）
c 经典面试题经典版
11-19
这个答案能够得到10分，因为它不仅正确地处理了字符串的结尾符'\0'，还考虑了源字符串长度超过目标字符串长度的情况。通过检查指针之间的差异来避免字符串溢出，确保不会访问无效的内存空间。 面试题考查敏捷的思维...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值