精华内容
下载资源
问答
  • c++语言处理中文字符串
    千次阅读
    2020-06-17 20:20:08

    一、中文字符串

    • 问题来源:
      中文字符长度不固定,按字节处理往往出现乱码或错误分割。在unicode中每个中文为2个字节,而中文中间夹杂的英文和半角标点则仍然是1个字节。
    • 解决方案:
      构造三层逻辑结构:输入层、逻辑处理层、输出层。
      – 输入层接收char输入,并将其转换为wchar.
      – 逻辑处理层在 wchar* 或 wstring 的基础上进行字符串操作,此时操作最小单位为中文字符,不会再有乱码。
      – 输出层将wchar的结果再次转换为char ,返回给外部。
      这样,对外部来说,仍然是输入char*, 输出char*, 但在这个过程中不再有分割汉字的操作或乱码。
    #include <iostream>
    #include <string>
    using namespace std;
    
    wchar_t* MBCS2Unicode(wchar_t * buff, const char * str)
    
    {
    
        wchar_t * wp = buff;
    
        char * p = (char *)str;
    
        while (*p)
    
        {
    
            if (*p & 0x80)
    
            {
    
                *wp = *(wchar_t *)p;
    
                p++;
    
            }
    
            else {
    
                *wp = (wchar_t)*p;
    
            }
    
            wp++;
    
            p++;
    
        }
    
        *wp = 0x0000;
    
        return buff;
    
    }
    
    char * Unicode2MBCS(char * buff, const wchar_t * str)
    
    {
    
        wchar_t * wp = (wchar_t *)str;
    
        char * p = buff, *tmp;
    
        while (*wp) {
    
            tmp = (char *)wp;
    
            if (*wp & 0xFF00) {
    
                *p = *tmp;
    
                p++; tmp++;
    
                *p = *tmp;
    
                p++;
    
            }
    
            else {
    
                *p = *tmp;
    
                p++;
    
            }
    
            wp++;
    
        }
    
        *p = 0x00;
    
        return buff;
    
    }
    
    wstring str2wstr(string str)
    
    {
    
        size_t len = str.size();
    
        wchar_t * b = (wchar_t *)malloc((len + 1) * sizeof(wchar_t));
    
        MBCS2Unicode(b, str.c_str());
    
        wstring r(b);
    
        free(b);
    
        return r;
    
    }
    
    int wputs(const wchar_t * wstr);
    
    int wputs(wstring wstr)
    
    {
    
        wputs(wstr.c_str());
    
        return 0;
    
    }
    
    int wputs(const wchar_t * wstr)
    
    {
        int len = wcslen(wstr);
    
        char * buff = (char *)malloc((len * 2 + 1) * sizeof(char));
    
        Unicode2MBCS(buff, wstr);
    
        printf("%s", buff);
    
        free(buff);
    
        return 0;
    
    }
    
    string wstr2str(wstring wstr)
    
    {
    
        size_t len = wstr.size();
    
        char * b = (char *)malloc((2 * len + 1) * sizeof(char));
    
        Unicode2MBCS(b, wstr.c_str());
    
        string r(b);
    
        free(b);
    
        return r;
    
    
    
    int main()
    
    {
    
        //输入层:接收char*输入,并将其转换为wchar*
    
        string input = "今天你在武汉!!";
    
        string temp = "在";
    
        //逻辑层在whcar*或wstring的基础上进行字符串操作,此时操作最小单位为中文字符,不会再有乱码。
    
        wstring buff = str2wstr(input);
    
        wstring temp_buff = str2wstr(temp);
    
        cout << "input的中文个数:"<<wcslen(buff.c_str()) << "   temp的中文个数:" << wcslen(temp_buff.c_str()) << endl;
    
        cout << "判断input第三个是否是'在':" << (buff[3] == temp_buff[0]) << endl;;
    
        //输出层将wchar*的结果再次转换为char*,返回给外部
    
        wputs(buff);
    
        return 0;
    
    }
    

    二、c++几种编码之前的转换

    .h

    #pragma once  
    #include "stdafx.h"  
    #include "windows.h"  
    #include <iostream>  
    #include <string>  
    using namespace std;  
      
    //**************string******************//  
    // ASCII与Unicode互转  
    wstring AsciiToUnicode(const string& str);  
    string  UnicodeToAscii(const wstring& wstr);  
    // UTF8与Unicode互转  
    wstring Utf8ToUnicode(const string& str);  
    string  UnicodeToUtf8(const wstring& wstr);  
    // ASCII与UTF8互转  
    string  AsciiToUtf8(const string& str);  
    string  Utf8ToAscii(const string& str);  
    string Utf8ToAnsi(const char* su8);
    //**************CString******************//  
    // ASCII与Unicode互转  
    CStringW    AsciiToUnicode_CSTR(const CStringA& str);  
    CStringA    UnicodeToAscii_CSTR(const CStringW& wstr);  
    // UTF8与Unicode互转  
    CStringW    Utf8ToUnicode_CSTR(const CStringA& str);  
    CStringA    UnicodeToUtf8_CSTR(const CStringW& wstr);  
    // ASCII与UTF8互转  
    CStringA    AsciiToUtf8_CSTR(const CStringA& str);  
    CStringA    Utf8ToAscii_CSTR(const CStringA& str);  
    /************string-int***************/  
    // string 转 Int  
    int StringToInt(const string& str);  
    string IntToString(int i);  
    string IntToString(char i);  
    string IntToString(double i);  
    

    .cpp

    #pragma once  
    #include "stdafx.h"  
    #include "UTN.h"  
      
    wstring AsciiToUnicode(const string& str) {  
        // 预算-缓冲区中宽字节的长度    
        int unicodeLen = MultiByteToWideChar(CP_ACP, 0, str.c_str(), -1, nullptr, 0);  
        // 给指向缓冲区的指针变量分配内存    
        wchar_t *pUnicode = (wchar_t*)malloc(sizeof(wchar_t)*unicodeLen);  
        // 开始向缓冲区转换字节    
        MultiByteToWideChar(CP_ACP, 0, str.c_str(), -1, pUnicode, unicodeLen);  
        wstring ret_str = pUnicode;  
        free(pUnicode);  
        return ret_str;  
    }  
    string UnicodeToAscii(const wstring& wstr) {  
        // 预算-缓冲区中多字节的长度    
        int ansiiLen = WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), -1, nullptr, 0, nullptr, nullptr);  
        // 给指向缓冲区的指针变量分配内存    
        char *pAssii = (char*)malloc(sizeof(char)*ansiiLen);  
        // 开始向缓冲区转换字节    
        WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), -1, pAssii, ansiiLen, nullptr, nullptr);  
        string ret_str = pAssii;  
        free(pAssii);  
        return ret_str;  
    }  
    wstring Utf8ToUnicode(const string& str) {  
        // 预算-缓冲区中宽字节的长度    
        int unicodeLen = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, nullptr, 0);  
        // 给指向缓冲区的指针变量分配内存    
        wchar_t *pUnicode = (wchar_t*)malloc(sizeof(wchar_t)*unicodeLen);  
        // 开始向缓冲区转换字节    
        MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, pUnicode, unicodeLen);  
        wstring ret_str = pUnicode;  
        free(pUnicode);  
        return ret_str;  
    }  
    
    string Utf8ToAnsi(const char* su8){
    	int wcsLen = ::MultiByteToWideChar(CP_UTF8, NULL, su8, strlen(su8), NULL, 0);
    	wchar_t* wszMultiByte = new wchar_t[wcsLen+1];
    	::MultiByteToWideChar(CP_UTF8, NULL, su8, strlen(su8), wszMultiByte, wcsLen);
    	
    	int ansiLen = ::MultiByteToWideChar(CP_UTF8, NULL, wszMultiByte, wcsLen(wszMultiByte), NULL, 0, NULL, NULL);
    	char* szAnsi = new char[ansiLen + 1];
    	szAnsi[ansiLen] = '\0';
    	::MultiByteToWideChar(CP_UTF8, NULL, wszMultiByte, wcsLen(wszMultiByte), szAnsi, ansiLen, NULL, NULL);
    	string = szAnsi;
    	delete[] szAnsi;
    	delete[] wszMultiByte;
    	
    	return s;
    }
    string UnicodeToUtf8(const wstring& wstr) {  
        // 预算-缓冲区中多字节的长度    
        int ansiiLen = WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), -1, nullptr, 0, nullptr, nullptr);  
        // 给指向缓冲区的指针变量分配内存    
        char *pAssii = (char*)malloc(sizeof(char)*ansiiLen);  
        // 开始向缓冲区转换字节    
        WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), -1, pAssii, ansiiLen, nullptr, nullptr);  
        string ret_str = pAssii;  
        free(pAssii);  
        return ret_str;  
    }  
    string AsciiToUtf8(const string& str) {  
        return UnicodeToUtf8(AsciiToUnicode(str));  
    }  
    string Utf8ToAscii(const string& str) {  
        return UnicodeToAscii(Utf8ToUnicode(str));  
    }  
    // ASCII与Unicode互转  
    CStringW    AsciiToUnicode_CSTR(const CStringA& str) {  
        return AsciiToUnicode(LPCSTR(str)).c_str();  
    }  
    CStringA    UnicodeToAscii_CSTR(const CStringW& wstr) {  
        return UnicodeToAscii(LPCWSTR(wstr)).c_str();  
    }  
    // UTF8与Unicode互转  
    CStringW    Utf8ToUnicode_CSTR(const CStringA& str) {  
        return Utf8ToUnicode(LPCSTR(str)).c_str();  
    }  
    CStringA    UnicodeToUtf8_CSTR(const CStringW& wstr) {  
        return UnicodeToUtf8(LPCWSTR(wstr)).c_str();  
    }  
    // ASCII与UTF8互转  
    CStringA    AsciiToUtf8_CSTR(const CStringA& str) {  
        return UnicodeToUtf8_CSTR(AsciiToUnicode_CSTR(str));  
    }  
    CStringA    Utf8ToAscii_CSTR(const CStringA& str) {  
        return UnicodeToAscii_CSTR(Utf8ToUnicode_CSTR(str));  
    }  
    // string 与 Int 互转  
    int StringToInt(const string& str) {  
        return atoi(str.c_str());  
    }  
    string IntToString(int i) {  
        char ch[1024];  
        memset(ch, 0, 1024);  
        sprintf_s(ch, sizeof(ch), "%d", i);  
        return ch;  
    }  
    string IntToString(char i) {  
        char ch[1024];  
        memset(ch, 0, 1024);  
        sprintf_s(ch, sizeof(ch), "%c", i);  
        return ch;  
    }  
    string IntToString(double i) {  
        char ch[1024];  
        memset(ch, 0, 1024);  
        sprintf_s(ch, sizeof(ch), "%f", i);  
        return ch;  
    }  
    
    更多相关内容
  • C++中汉字字符处理

    2021-05-23 06:42:54
    我希望它在ListView正确显示名称和ID,但结果是:我希望有人能帮我解决这个问题。下面是场景:这是从我的服务器返回的JSON数据,它是一个职员姓名列表,其中大部分是用日文汉字写的名字。[{"staff": {"id": 121,"name":...

    我希望它在ListView中正确显示名称和ID,但结果是:

    oqmtg.png%E2%80%9Dalt=%E2%80%9Center

    我希望有人能帮我解决这个问题。

    下面是场景:

    这是从我的服务器返回的JSON数据,它是一个职员姓名列表,其中大部分是用日文汉字写的名字。

    [

    {

    "staff": {

    "id": 121,

    "name": "ç¦å£« éå",

    "department": [

    {

    "_id": 3,

    "name": "äºæ¥­æ¨é²æ¬é¨"

    }

    ]

    }

    },

    {

    "staff": {

    "id": 12,

    "name": "å島 ç¾å¥",

    "department": [

    {

    "_id": 4,

    "name": "äºæ¥­éçºæ¬é¨"

    }

    ]

    }

    },

    {

    "staff": {

    "id": 151,

    "name": "大河å ç´å¸",

    "department": [

    {

    "_id": 3,

    "name": "äºæ¥­æ¨é²æ¬é¨"

    }

    ]

    }

    }

    ]

    这是我的dll项目(amscpsrest)中的代码。这是获取数据并传递到我的clr项目的方法:

    std::map staffMap;

    auto GetStaffMap() -> std::map {

    return staffMap;

    }

    void display_json(json::value const & jvalue, utility::string_t const & prefix)

    {

    try {

    //==== Iterate through json data and make an associative array ====/

    auto DataArray = jvalue.as_array();

    // loop through 'data' object

    for (int i = 0; i < DataArray.size(); i++)

    {

    try

    {

    auto data = DataArray[i];

    auto dataObj = data.at(U("staff")).as_object();

    int key;

    std::string value;

    // loop through each object of 'data'

    for (auto iterInner = dataObj.cbegin(); iterInner != dataObj.cend(); ++iterInner)

    {

    auto &propertyName = iterInner->first;

    auto &propertyValue = iterInner->second;

    if (propertyName == L"_id")

    {

    key = propertyValue.as_integer();

    }

    else if (propertyName == L"name")

    {

    value = conversions::to_utf8string(propertyValue.as_string());

    }

    }

    staffMap.insert(std::make_pair(key, value));

    }

    catch (const std::exception& e)

    {

    std::wcout << e.what() << std::endl;

    }

    }

    }

    catch (const std::exception& e) {

    std::wcout << e.what() << std::endl;

    }

    }

    pplx::task task_request(http_client & client, method mtd, json::value const & jvalue, std::string searchText)

    {

    //std::string url = "/api/authenticate/searchStaffs/";

    std::string url = "/api/authenticate/oldgms/staffs_id_name/";

    return client.request(mtd, utility::conversions::to_string_t(url));

    }

    void make_request(http_client & client, method mtd, json::value const & jvalue, std::string searchText)

    {

    task_request(client, mtd, jvalue, searchText)

    .then([](http_response response)

    {

    if (response.status_code() == status_codes::OK)

    {

    return response.extract_json();

    }

    return pplx::task_from_result(json::value());

    })

    .then([](pplx::task<:value> previousTask)

    {

    try

    {

    display_json(previousTask.get(), L"R: ");

    }

    catch (http_exception const & e)

    {

    std::wcout << e.what() << std::endl;

    }

    })

    .wait();

    }

    int SearchStaff(std::string searchText)

    {

    //clear staffMap every call

    staffMap.clear();

    http_client client(U("http://52.68.13.154:3000"));

    auto nullValue = json::value::null();

    //std::string search_text = conversions::to_utf8string(L"å島 ç¾å¥");

    make_request(client, methods::GET, nullValue, searchText);

    return staff_id;

    }

    这是我在clr项目中的代码(时间戳)。这就是我如何接受来自我的dll项目的数据并显示到用户界面。

    String^ input = searchBox->Text;

    std::string searchText = msclr::interop::marshal_as<:string>(input);

    // Clear listView item every type in searchbox

    listView1->Items->Clear();

    Staffs::SearchStaff(searchText);

    std::map staffMap = Staffs::GetStaffMap();

    std::map::iterator iter;

    for (iter = staffMap.begin(); iter != staffMap.end(); iter++)

    {

    String^ value = msclr::interop::marshal_as<:string>(iter->second);

    int key = iter->first;

    listViewItem = gcnew Windows::Forms::ListViewItem(value);

    listViewItem->SubItems->Add(System::Convert::ToString(key));

    this->listView1->Items->Add(this->listViewItem);

    }

    我希望它在ListView中正确显示名称和ID,但结果是:

    oqMtG.png

    我希望有人能帮我解决这个问题。

    展开全文
  • 主要给大家介绍了关于C++如何过滤出字符串中文的相关资料,文中通过示例代码介绍的非常详细,对大家学习或者使用C++具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • C++字符串处理专题

    千次阅读 2022-03-13 20:00:28
    7-1 字符串排序 本题要求编写程序,读入5个字符串,按由小到大的顺序输出。 输入格式: 输入为由空格分隔的5个非空字符串,每个字符串不包括空格、制表符、换行符等空白字符,长度小于80。 输出格式: 按照以下格式...

    7-1 字符串排序

    本题要求编写程序,读入5个字符串,按由小到大的顺序输出。

    输入格式:
    输入为由空格分隔的5个非空字符串,每个字符串不包括空格、制表符、换行符等空白字符,长度小于80。

    输出格式:
    按照以下格式输出排序后的结果:

    After sorted:
    每行一个字符串
    输入样例:
    red yellow blue black white
    输出样例:
    After sorted:
    black
    blue
    red
    white
    yellow

    #include <bits/stdc++.h>
    
    using namespace std;
    
    string s[10]; 
    
    int main()
    {
    	for(int i=0;i<5;++i)cin>>s[i];
    	sort(s,s+5);
    	cout<<"After sorted:"<<endl;
    	for(int i=0;i<5;++i)cout<<s[i]<<endl; 
    	return 0;
    }
    

    7-2 删除重复字符

    本题要求编写程序,将给定字符串去掉重复的字符后,按照字符ASCII码顺序从小到大排序后输出。

    输入格式:
    输入是一个以回车结束的非空字符串(少于80个字符)。

    输出格式:
    输出去重排序后的结果字符串。

    输入样例:
    ad2f3adjfeainzzzv
    输出样例:
    23adefijnvz

    #include <bits/stdc++.h>
    
    using namespace std;
    
    string s;
    char ans[100];
    bool st[300];
    int p=0;
    
    int main()
    {
    	getline(cin,s);
    	for(int i=0;i<s.size();++i)
    	{
    		if(st[s[i]])continue;
    		ans[p++]=s[i];
    		st[s[i]]=true;
    	}
    	sort(ans,ans+p);
    	cout<<ans;
    	return 0;
    }
    

    7-3 统计字符出现次数

    本题要求编写程序,统计并输出某给定字符在给定字符串中出现的次数。

    输入格式:
    输入第一行给出一个以回车结束的字符串(少于80个字符);第二行输入一个字符。

    输出格式:
    在一行中输出给定字符在给定字符串中出现的次数。

    输入样例:
    programming is More fun!
    m
    输出样例:
    2

    #include <bits/stdc++.h>
    
    using namespace std;
    
    string s;
    int cnt[300];
    
    int main()
    {
    	getline(cin,s);
    	for(int i=0;i<s.size();++i)
    	{
    		cnt[s[i]]++;
    	}
    	char c;c=getchar();
    	cout<<cnt[c]<<endl;
    	return 0;
    }
    

    7-4 IP地址转换

    一个IP地址是用四个字节(每个字节8个位)的二进制码组成。请将32位二进制码表示的IP地址转换为十进制格式表示的IP地址输出。

    输入格式:
    输入在一行中给出32位二进制字符串。

    输出格式:
    在一行中输出十进制格式的IP地址,其由4个十进制数组成(分别对应4个8位的二进制数),中间用“.”分隔开。

    输入样例:
    11001100100101000001010101110010
    输出样例:
    204.148.21.114

    #include <bits/stdc++.h>
    
    using namespace std;
    
    
    int main()
    {
    	char c;
    	for(int i=0;i<4;++i)
    	{
    		int n=0;
    		for(int j=0;j<8;++j)
    		{
    			c=getchar();
    			n*=2;
    			n+=c-'0';
    		}
    		if(i!=3)cout<<n<<".";
    		else cout<<n;
    	}
    	return 0;
    }
    

    7-5 英文单词排序

    本题要求编写程序,输入若干英文单词,对这些单词按长度从小到大排序后输出。如果长度相同,按照输入的顺序不变。

    输入格式:
    输入为若干英文单词,每行一个,以#作为输入结束标志。其中英文单词总数不超过20个,英文单词为长度小于10的仅由小写英文字母组成的字符串。

    输出格式:
    输出为排序后的结果,每个单词后面都额外输出一个空格。

    输入样例:
    blue
    red
    yellow
    green
    purple

    输出样例:
    red blue green yellow purple

    #include <bits/stdc++.h>
    
    using namespace std;
    
    class node 
    {
    	public:
    	string s;
    	int len,id;
    	node(string str,int a,int b){
    		s=str;len=a;id=b;
    	}
    	node(){
    	}
    }ns[100];
    int p;
    bool cmp(node a,node b)
    {
    	if(a.len!=b.len)return a.len<b.len;
    	return a.id<b.id;
    }
    
    int main()
    {
    	string s;
    	while(cin>>s)
    	{
    		if(s=="#")break;
    		ns[p++]=node(s,s.size(),p);
    	}
    	sort(ns,ns+p,cmp);
    	for(int i=0;i<p;++i)cout<<ns[i].s<<" ";
    	return 0;
    }
    

    7-6 藏尾诗

    本题要求编写一个解密藏尾诗的程序。

    输入格式:
    输入为一首中文藏尾诗,一共四句。每句一行,但句子不一定是等长的,最短一个汉字,最长九个汉字。注意:一个汉字占两个字节。

    输出格式:
    取出每句的最后一个汉字并连接在一起形成一个字符串并输出。同时在末尾输入一个换行符。

    输入样例:
    悠悠田园风
    然而心难平
    兰花轻涌浪
    兰香愈幽静
    输出样例:
    风平浪静

    #include <bits/stdc++.h>
    
    using namespace std;
    
    string s[4],ans;
    
    int main()
    {
    	for(int i=0;i<4;++i)cin>>s[i];
    	for(int i=0;i<4;++i)
    	{
    		int len=s[i].size();
    		ans+=s[i][len-2];
    		ans+=s[i][len-1];
    	}
    	cout<<ans;
    	return 0;
    }
    

    7-7 删除字符串中的子串

    输入2个字符串S1和S2,要求删除字符串S1中出现的所有子串S2,即结果字符串中不能包含S2。

    输入格式:
    输入在2行中分别给出不超过80个字符长度的、以回车结束的2个非空字符串,对应S1和S2。

    输出格式:
    在一行中输出删除字符串S1中出现的所有子串S2后的结果字符串。

    输入样例:
    Tomcat is a male ccatat
    cat
    输出样例:
    Tom is a male

    java 的replace 直接替换,替换成空串,就等于删除子串

    import java.util.Scanner;
    public class Main {
        public static void main(String[] args) {
            Scanner sc= new Scanner(System.in);
            String s1=sc.nextLine();
            String s2=sc.nextLine();
            String s3=s1.replace(s2,"");
            while(!s1.equals(s3)){
                s1=s3;
                s3=s1.replace(s2,"");
            }
            System.out.println(s3);
        }
    }
    

    cpp

    直接手动模拟会很折磨
    用string的find,结合erase或者replace会很舒适
    #include <bits/stdc++.h>
    
    using namespace std;
    
    string s1,s2;
    
    int main()
    {
    	getline(cin,s1);
    	getline(cin,s2);
    	
    	while(s1.find(s2)!=s1.npos)
    	{
    		s1=s1.erase(s1.find(s2),s2.size());
    	}
    	cout<<s1;
    	return 0;
    }
    
    #include <bits/stdc++.h>
    
    using namespace std;
    
    string s1,s2;
    
    int main()
    {
    	getline(cin,s1);
    	getline(cin,s2);
    	
    	while(s1.find(s2)!=s1.npos)
    	{
    		s1=s1.replace(s1.find(s2),s2.size(),"",0,0);
    	}
    	cout<<s1;
    	return 0;
    }
    

    7-8 字符串的冒泡排序

    我们已经知道了将N个整数按从小到大排序的冒泡排序法。本题要求将此方法用于字符串序列,并对任意给定的K(<N),输出扫描完第K遍后的中间结果序列。

    输入格式:
    输入在第1行中给出N和K(1≤K<N≤100),此后N行,每行包含一个长度不超过10的、仅由小写英文字母组成的非空字符串。

    输出格式:
    输出冒泡排序法扫描完第K遍后的中间结果序列,每行包含一个字符串。

    输入样例:
    6 2
    best
    cat
    east
    a
    free
    day
    输出样例:
    best
    a
    cat
    day
    east
    free

    #include <bits/stdc++.h>
    
    using namespace std;
    
    string s[1000];
    
    int main()
    {
    	int n,k;cin>>n>>k;
    	for(int i=0;i<n;++i)cin>>s[i];
    	
    	for(int i=n-1;i>n-1-k;--i)
    	{
    		for(int j=0;j<i;++j)
    		{
    			if(s[j]>s[j+1])swap(s[j],s[j+1]);
    		}
    	}
    	for(int i=0;i<n;++i)cout<<s[i]<<endl;
    	return 0;
    }
    

    7-9 字符串循环左移

    输入一个字符串和一个非负整数N,要求将字符串循环左移N次。

    输入格式:
    输入在第1行中给出一个不超过100个字符长度的、以回车结束的非空字符串;第2行给出非负整数N。

    输出格式:
    在一行中输出循环左移N次后的字符串。

    输入样例:
    Hello World!
    2
    输出样例:
    llo World!He

    #include <bits/stdc++.h>
    
    using namespace std;
    
    string s,t;
    int k;
    
    int main()
    {
    	getline(cin,s);cin>>k;
    	k%=s.size();
    	t=s.substr(0,k);
    	s=s.erase(0,k);
    	s+=t;
    	cout<<s;
    	return 0;
    }
    

    7-10 说反话-加强版

    给定一句英语,要求你编写程序,将句中所有单词的顺序颠倒输出。

    输入格式:
    测试输入包含一个测试用例,在一行内给出总长度不超过500 000的字符串。字符串由若干单词和若干空格组成,其中单词是由英文字母(大小写有区分)组成的字符串,单词之间用若干个空格分开。

    输出格式:
    每个测试用例的输出占一行,输出倒序后的句子,并且保证单词间只有1个空格。

    输入样例:
    Hello World Here I Come

    #include <bits/stdc++.h>
    
    using namespace std;
    
    string s;
    stack<string> stk;
    
    int main()
    {
    	while(cin>>s)stk.push(s);
    	while(!stk.empty())
    	{
            if(stk.size()!=1)
    		cout<<stk.top()<<" ";
            else cout<<stk.top();
    		stk.pop();
    	}
    	return 0;
    }
    

    7-11 切分表达式——写个tokenizer吧

    [先说点出题背景]

    这个题是为低年级同学、学C语言的同学准备的,因为,对这部分同学,这个题目编写起来略有一点复杂。如果是高年级、学过了正则表达式(Regular Expression)的同学或者学过了Java等OO语言的同学做这个题,应当发现这题比较简单吧。哦,对了,什么是tokenizer?请自行查询解决。反正在此处不应翻译成“令牌解析器”。

    [正题]

    四则运算表达式由运算数(必定包含数字,可能包含正或负符号、小数点)、运算符(包括+、-、*、/)以及小括号((和))组成,每个运算数、运算符和括号都是一个token(标记)。现在,对于给定的一个四则运算表达式,请把她的每个token切分出来。题目保证给定的表达式是正确的,不需要做有效性检查。

    输入格式:
    在一行中给出长度不超过40个字符的表达式,其中没有空格,仅由上文中token的字符组成

    输出格式:
    依次输出表达式中的tokens,每个token占一行。

    输入样例:
    32*((2-2)+5)/(-15)
    输出样例:
    32
    *
    (
    (
    2

    2
    )
    +
    5
    )
    /
    (
    -15
    )

    纯模拟,不知道有没有更好的解法

    一开始的思路是用个标记,标记上一个已经输出的类型是什么,一次来判断正负号是运算符还是符号,但是这样不知道有什么问题,反正样例是过去了,而如下的写法还更加简便,也通过了
    #include <bits/stdc++.h>
    
    using namespace std;
    queue<string> q;
    int main()
    {
    	string s,t="";cin>>s;
    	for(int i=0;i<s.size();++i)
    	{
    		if(s[i]=='('||s[i]==')'||s[i]=='*'||s[i]=='/'){
    			string m="";m+=s[i];
    			q.push(m);continue;
    		}
    		if(s[i]=='-'||s[i]=='+'){
    			if(s[i-1]==')'||isdigit(s[i-1]))
    			{
    				string m="";m+=s[i];
    				q.push(m);continue;
    			}
    		}
    		t+=s[i];
    		if(isdigit(s[i])&&!isdigit(s[i+1])&&s[i+1]!='.'){
    			q.push(t);t="";
    		}
    	}
    	while(!q.empty())
    	{
    		if(q.size()!=1)cout<<q.front()<<endl;
    		else cout<<q.front();
    		q.pop();
    	}
    	return 0;
    }
    

    7-12 输出GPLT

    给定一个长度不超过10000的、仅由英文字母构成的字符串。请将字符重新调整顺序,按GPLTGPLT…这样的顺序输出,并忽略其它字符。当然,四种字符(不区分大小写)的个数不一定是一样多的,若某种字符已经输出完,则余下的字符仍按GPLT的顺序打印,直到所有字符都被输出。

    输入格式:
    输入在一行中给出一个长度不超过10000的、仅由英文字母构成的非空字符串。

    输出格式:
    在一行中按题目要求输出排序后的字符串。题目保证输出非空。

    输入样例:
    pcTclnGloRgLrtLhgljkLhGFauPewSKgt
    输出样例:
    GPLTGPLTGLTGLGLL

    #include <bits/stdc++.h>
    
    using namespace std;
    
    int cnt[300],n;
    
    int main()
    {
    	string s;cin>>s;
    	for(int i=0;i<s.size();++i)
    	{
    		s[i]=toupper(s[i]);
    		cnt[s[i]]++;
    		if(s[i]=='G'||s[i]=='P'||s[i]=='L'||s[i]=='T')n++;
    	}
    	while(n)
    	{
    		if(cnt['G'])
    		{
    			cout<<"G";cnt['G']--;n--;
    		}
    		if(cnt['P'])
    		{
    			cout<<"P";cnt['P']--;n--;
    		}
    		if(cnt['L'])
    		{
    			cout<<"L";cnt['L']--;n--;
    		}
    		if(cnt['T'])
    		{
    			cout<<"T";cnt['T']--;n--;
    		}
    	}
    	return 0;
    }
    

    7-13 Left-pad

    根据新浪微博上的消息,有一位开发者不满NPM(Node Package Manager)的做法,收回了自己的开源代码,其中包括一个叫left-pad的模块,就是这个模块把javascript里面的React/Babel干瘫痪了。这是个什么样的模块?就是在字符串前填充一些东西到一定的长度。例如用去填充字符串GPLT,使之长度为10,调用left-pad的结果就应该是*****GPLT。Node社区曾经对left-pad紧急发布了一个替代,被严重吐槽。下面就请你来实现一下这个模块。

    输入格式:
    输入在第一行给出一个正整数N(≤10
    4
    )和一个字符,分别是填充结果字符串的长度和用于填充的字符,中间以1个空格分开。第二行给出原始的非空字符串,以回车结束。

    输出格式:
    在一行中输出结果字符串。

    输入样例1:
    15 _
    I love GPLT
    输出样例1:
    ____I love GPLT
    输入样例2:
    4 *
    this is a sample for cut
    输出样例2:
    cut

    #include <bits/stdc++.h>
    
    using namespace std;
    
    int main()
    {
    	int n;char c;cin>>n>>c;getchar();
    	string s;getline(cin,s);
    	if(s.size()>=n)s=s.substr(s.size()-n,n);
    	else s=s.insert(0,(n-s.size()),c);
    	cout<<s;
    	return 0;
    }
    

    7-14 A-B

    本题要求你计算A−B。不过麻烦的是,A和B都是字符串 —— 即从字符串A中把字符串B所包含的字符全删掉,剩下的字符组成的就是字符串A−B。

    输入格式:
    输入在2行中先后给出字符串A和B。两字符串的长度都不超过10
    4
    ,并且保证每个字符串都是由可见的ASCII码和空白字符组成,最后以换行符结束。

    输出格式:
    在一行中打印出A−B的结果字符串。

    输入样例:
    I love GPLT! It’s a fun game!
    aeiou
    输出样例:
    I lv GPLT! It’s fn gm!

    #include <bits/stdc++.h>
    
    using namespace std;
    
    string a,b;
    int main()
    {
    	getline(cin,a);
    	getline(cin,b);
    	for(int i=0;i<b.size();++i)
    	{
    		int t=a.find(b[i]);
    		while(t!=a.npos)
    		{
    			a.erase(t,1);
    			t=a.find(b[i]);
    		}
    	}
    	cout<<a; 
    	return 0;
    }
    
    #include <bits/stdc++.h>
    
    using namespace std;
    
    string a,b;
    int m[300];
    int main()
    {
    	getline(cin,a);
    	getline(cin,b);
    	for(int i=0;i<b.size();++i)m[b[i]]=1;
    	for(int i=0;i<a.size();++i)if(!m[a[i]])cout<<a[i];
    	return 0;
    }
    

    7-15 最长对称子串

    对给定的字符串,本题要求你输出最长对称子串的长度。例如,给定Is PAT&TAP symmetric?,最长对称子串为s PAT&TAP s,于是你应该输出11。

    输入格式:
    输入在一行中给出长度不超过1000的非空字符串。

    输出格式:
    在一行中输出最长对称子串的长度。

    输入样例:
    Is PAT&TAP symmetric?
    输出样例:
    11

    #include <bits/stdc++.h>
    
    using namespace std;
    
    int f[1005][1005];
    int ans;
    
    int main()
    {
    	string s;getline(cin,s);if(s.size())ans=1;
    	for(int i=0;i<s.size();++i)f[i][i]=1;
    	
    	for(int L=2;L<=s.size();++L)
    	{
    		for(int i=0;i+L-1<s.size();++i)
    		{
    			int j=i+L-1;
    			if(s[i]==s[j])
    			{
    				if(L<=3)f[i][j]=1;
    				else
    				{
    					f[i][j]=f[i+1][j-1];
    				}
    				if(f[i][j])ans=L;
    			}
    		}
    	}
    	cout<<ans;
    	return 0;
    }
    

    7-16 古风排版

    中国的古人写文字,是从右向左竖向排版的。本题就请你编写程序,把一段文字按古风排版。

    输入格式:
    输入在第一行给出一个正整数N(<100),是每一列的字符数。第二行给出一个长度不超过1000的非空字符串,以回车结束。

    输出格式:
    按古风格式排版给定的字符串,每列N个字符(除了最后一列可能不足N个)。

    输入样例:
    4
    This is a test case
    输出样例:
    asa T
    st ih
    e tsi
    ce s

    输出只能用两重循环,需要手动计算当前二维坐标映射到字符串中的一维坐标,同时要注意除法取整问题
    #include <bits/stdc++.h>
    
    using namespace std;
    
    int main()
    {
    	int n,m;string s;cin>>n;getchar();getline(cin,s);
    	if(s.size()%n!=0)m=(s.size()+n)/n;
    	else m=s.size()/n;
    	for(int i=0;i<n;++i)
    	{
    		for(int j=0;j<m;++j)
    		{
    			int t=m-1-j;
    			t*=n;
    			t+=i;
    			if(t<s.size())cout<<s[t];
    			else cout<<" "; 
    		}
    		if(i!=n-1)
    		cout<<endl;
    	}
    	return 0;
    }
    

    7-17 猜数字

    一群人坐在一起,每人猜一个 100 以内的数,谁的数字最接近大家平均数的一半就赢。本题就要求你找出其中的赢家。

    输入格式:
    输入在第一行给出一个正整数N(≤10
    4
    )。随后 N 行,每行给出一个玩家的名字(由不超过8个英文字母组成的字符串)和其猜的正整数(≤ 100)。

    输出格式:
    在一行中顺序输出:大家平均数的一半(只输出整数部分)、赢家的名字,其间以空格分隔。题目保证赢家是唯一的。

    输入样例:
    7
    Bob 35
    Amy 28
    James 98
    Alice 11
    Jack 45
    Smith 33
    Chris 62
    输出样例:
    22 Amy

    #include <bits/stdc++.h>
    
    using namespace std;
    
    class node
    {
    	public:
    		string s;
    		double x;
    }ns[10005];
    double num;
    
    bool cmp(node a,node b)
    {
    	return a.x<b.x;
    }
    int main()
    {
    	int n;cin>>n;
    	for(int i=0;i<n;++i)
    	{
    		cin>>ns[i].s>>ns[i].x;
    		num+=ns[i].x;
    	}
    	num/=n;num/=2;
    	cout<<floor(num)<<" ";
    	sort(ns,ns+n,cmp);
    	bool flag=true;
    	for(int i=0;i<n-1;++i)
    	{
    		if(fabs(ns[i].x-num)<fabs(ns[i+1].x-num))
    		{
    			flag=false;
    			cout<<ns[i].s;break;
    		}
    	}
    	if(flag)cout<<ns[n-1].s;
    	return 0;
    }
    

    7-18 估值一亿的AI核心代码

    AI.jpg

    以上图片来自新浪微博。

    本题要求你实现一个稍微更值钱一点的 AI 英文问答程序,规则是:

    无论用户说什么,首先把对方说的话在一行中原样打印出来;
    消除原文中多余空格:把相邻单词间的多个空格换成 1 个空格,把行首尾的空格全部删掉,把标点符号前面的空格删掉;
    把原文中所有大写英文字母变成小写,除了 I;
    把原文中所有独立的 can you、could you 对应地换成 I can、I could—— 这里“独立”是指被空格或标点符号分隔开的单词;
    把原文中所有独立的 I 和 me 换成 you;
    把原文中所有的问号 ? 换成惊叹号 !;
    在一行中输出替换后的句子作为 AI 的回答。
    输入格式:
    输入首先在第一行给出不超过 10 的正整数 N,随后 N 行,每行给出一句不超过 1000 个字符的、以回车结尾的用户的对话,对话为非空字符串,仅包括字母、数字、空格、可见的半角标点符号。

    输出格式:
    按题面要求输出,每个 AI 的回答前要加上 AI: 和一个空格。

    输入样例:
    6
    Hello ?
    Good to chat with you
    can you speak Chinese?
    Really?
    Could you show me 5
    What Is this prime? I,don 't know
    输出样例:
    Hello ?
    AI: hello!
    Good to chat with you
    AI: good to chat with you
    can you speak Chinese?
    AI: I can speak chinese!
    Really?
    AI: really!
    Could you show me 5
    AI: I could show you 5
    What Is this prime? I,don 't know
    AI: what Is this prime! you,don’t know

    太复杂了,懒得去调
    借鉴别人的代码

    
    #include<iostream>
    #include<algorithm>
    #include<cstring>
    #include<string>
    #include<cmath>
    using namespace std;
    int d(char x)
    {
    	if (x >= 'A'&&x <= 'Z') return -1;
    	if (x >= 'a'&&x <= 'z') return -2;
    	if (x >= '0'&&x <= '9') return -3;
    	if (x == ' ') return 2;
    	return 1;
    }
    string low(string str)
    {
    	string b;
    	b += " ";
    	for (int i = 0; i < str.size(); i++)
    	{
    		if (str[i] >= 'A'&&str[i] <= 'Z'&&str[i] != 'I')
    		{
    			str[i] += 32;
    		}
    		if (str[i] == '?') str[i] = '!';
    	}
    	b += str;
    	b += " ";
    	str.clear();
    	str += " ";
    	for (int i = 1; i < b.size() - 1; i++)
    	{
    		if (b[i] == ' ' && b[i - 1] == ' ')	continue;
    		else if (d(b[i + 1]) == 1 && b[i] == ' ')	continue;
    		else	str += b[i];
    	}
    	str += " ";
    	return str;
    }
    int main()
    {
    	int t, i, j, k;
    	string str;
    	cin >> t;
    	getchar();
    	while (t--)
    	{
    		getline(cin, str);
    		cout << str << endl;
    		cout << "AI: ";
    		bool kong = false;
    		for (i = 0; i < str.size(); i++)
    		{
    			if (str[i] != ' ')
    			{
    				kong = true;
    				break;
    			}
    		}
    		if (kong == false)
    		{
    			cout << endl;
    			continue;
    		}
    		str = low(str);
    		string temp;
    		for (i = 0; i < str.size(); i++)
    		{
    			temp += str[i];
    			if (d(str[i])>0 && str[i + 1] == 'm'&&str[i + 2] == 'e'&&d(str[i + 3])>0)
    			{
    				i += 2;
    				temp += "you";
    			}
    			else if (d(str[i])>0 && str[i + 1] == 'I'&&d(str[i + 2])>0)
    			{
    				i++;
    				temp += "you";
    			}
    			else if (d(str[i])>0 && str[i + 1] == 'c'&& str[i + 2] == 'a'&& str[i + 3] == 'n'&& str[i + 5] == 'y'&& str[i + 6] == 'o'&& str[i + 7] == 'u'&&d(str[i + 8])>0)
    			{
    				i += 7;
    				temp += "I can";
    			}
    			else if (d(str[i])>0 && str[i + 1] == 'c'&& str[i + 2] == 'o'&& str[i + 3] == 'u'&& str[i + 4] == 'l'&& str[i + 5] == 'd'&&  str[i + 7] == 'y'&& str[i + 8] == 'o'&& str[i + 9] == 'u'&&d(str[i + 10])>0)
    			{
    				i += 9;
    				temp += "I could";
    			}
    		}
    		str = "";
    		str += temp;
    		//cout << str << endl;
    		int len;
    		for (i = str.size() - 1; i >= 0; i--)
    		{
    			if (str[i] != ' ')
    			{
    				len = i;
    				break;
    			}
    		}
    		int cnt = 0;
    		for (i = 0; i <= len; i++)
    		{
    			if (i>0 && str[i] == ' '&& d(str[i + 1]) == 1)	continue;
    			if (str[i] != ' ')  cout << str[i], cnt++;
    			else if (cnt>0) cout << " ";
    		}
    		cout << endl;
    	}
    	return 0;
    }
    

    7-19 口罩发放

    为了抗击来势汹汹的 COVID19 新型冠状病毒,全国各地均启动了各项措施控制疫情发展,其中一个重要的环节是口罩的发放。

    某市出于给市民发放口罩的需要,推出了一款小程序让市民填写信息,方便工作的开展。小程序收集了各种信息,包括市民的姓名、身份证、身体情况、提交时间等,但因为数据量太大,需要根据一定规则进行筛选和处理,请你编写程序,按照给定规则输出口罩的寄送名单。

    输入格式:
    输入第一行是两个正整数 D 和 P(1≤D,P≤30),表示有 D 天的数据,市民两次获得口罩的时间至少需要间隔 P 天。

    接下来 D 块数据,每块给出一天的申请信息。第 i 块数据(i=1,⋯,D)的第一行是两个整数 T
    i

    和 S
    i

    (1≤T
    i

    ,S
    i

    ≤1000),表示在第 i 天有 T
    i

    条申请,总共有 S
    i

    个口罩发放名额。随后 T
    i

    行,每行给出一条申请信息,格式如下:

    姓名 身份证号 身体情况 提交时间
    给定数据约束如下:

    姓名 是一个长度不超过 10 的不包含空格的非空字符串;
    身份证号 是一个长度不超过 20 的非空字符串;
    身体情况 是 0 或者 1,0 表示自觉良好,1 表示有相关症状;
    提交时间 是 hh:mm,为24小时时间(由 00:00 到 23:59。例如 09:08。)。注意,给定的记录的提交时间不一定有序;
    身份证号 各不相同,同一个身份证号被认为是同一个人,数据保证同一个身份证号姓名是相同的。
    能发放口罩的记录要求如下:

    身份证号 必须是 18 位的数字(可以包含前导0);
    同一个身份证号若在第 i 天申请成功,则接下来的 P 天不能再次申请。也就是说,若第 i 天申请成功,则等到第 i+P+1 天才能再次申请;
    在上面两条都符合的情况下,按照提交时间的先后顺序发放,直至全部记录处理完毕或 S
    i

    个名额用完。如果提交时间相同,则按照在列表中出现的先后顺序决定。
    输出格式:
    对于每一天的申请记录,每行输出一位得到口罩的人的姓名及身份证号,用一个空格隔开。顺序按照发放顺序确定。

    在输出完发放记录后,你还需要输出有合法记录的、身体状况为 1 的申请人的姓名及身份证号,用空格隔开。顺序按照申请记录中出现的顺序确定,同一个人只需要输出一次。

    输入样例:
    4 2
    5 3
    A 123456789012345670 1 13:58
    B 123456789012345671 0 13:58
    C 12345678901234567 0 13:22
    D 123456789012345672 0 03:24
    C 123456789012345673 0 13:59
    4 3
    A 123456789012345670 1 13:58
    E 123456789012345674 0 13:59
    C 123456789012345673 0 13:59
    F F 0 14:00
    1 3
    E 123456789012345674 1 13:58
    1 1
    A 123456789012345670 0 14:11
    输出样例:
    D 123456789012345672
    A 123456789012345670
    B 123456789012345671
    E 123456789012345674
    C 123456789012345673
    A 123456789012345670
    A 123456789012345670
    E 123456789012345674
    样例解释:
    输出中,第一行到第三行是第一天的部分;第四、五行是第二天的部分;第三天没有符合要求的市民;第六行是第四天的部分。最后两行按照出现顺序输出了可能存在身体不适的人员。

    写了好久不知道错哪了,有个测试点过不去,23分
    23分代码

    #include <bits/stdc++.h>
    
    using namespace std;
    
    int d,pp;
    class node
    {
    	public :
    	string xm,sf,zk,time;int sx;
    	node(string xm,string sf,string zk,string time,int sx)
    	{
    		this->xm=xm;
    		this->sf=sf;
    		this->zk=zk;
    		this->time=time;
    		this->sx=sx;
    	}
    	node(){
    	}
    }ns[30005];
    node tmp[10005];
    map<string,int> mp,mp2;
    int cnt;
    
    bool cmp(node a,node b)
    {
    	if(a.time!=b.time)
    	{
    		return a.time<b.time;
    	}
    	return a.sx<b.sx;
    }
    
    int main()
    {
    	cin>>d>>pp;
    	for(int i=1;i<=d;++i)
    	{
    		int t,s;cin>>t>>s;
    		int p=0;
    		for(int j=1;j<=t;++j)
    		{
    			string xm,sf,zk,time;cin>>xm>>sf>>zk>>time;
    			
    			bool flag=true;
    			if(sf.size()!=18)flag=false;
    			for(int k=0;k<sf.size();++k)if(!isdigit(sf[k]))flag=false;
    			if(flag==false)continue;
    			
    			ns[cnt++]=node(xm,sf,zk,time,cnt);
    			
    			
    			if(mp[sf]!=0&&i-mp[sf]<=pp)continue;
    			tmp[p++]=node(xm,sf,zk,time,cnt);
    			//mp[sf]=i;
    		}
    		sort(tmp,tmp+p,cmp);
    		for(int j=0;j<min(s,p);++j)
    		{
    			cout<<tmp[j].xm<<" "<<tmp[j].sf<<endl;
    			mp[tmp[j].sf]=i;
    		}
    	}
    	
    	for(int i=0;i<cnt;++i)
    	{
    		if(ns[i].zk=="1")
    		{
    			if(mp2[ns[i].sf]==0)
    			{
    				cout<<ns[i].xm<<" "<<ns[i].sf<<endl;
    				mp2[ns[i].sf]=1;
    			}
    		}
    	}
    
    	return 0;
    }
    

    AC代码

    #include <bits/stdc++.h>
    using namespace std;
    struct node {
    	string name, id, Time;
    	int illness, order;
    };
    bool isIllegal(const string &ss) {
    	if (ss.size() != 18) return true;
    	for (char i:ss) if (i < '0' || i > '9') return true;
    	return false;
    }
    bool cmp (const node &a,const node &b) {
    	if (a.Time != b.Time) return a.Time < b.Time;
    	return a.order < b.order;
    }
    vector<node> Record, ill;
    int D, P, t, s, providedNum;
    map<string, int> lastGet;
    set<string> gotten;
    int main() {
    	cin >> D >> P;
    	for (int i = 1; i <= D; i++) {
    		cin >> t >> s;
    		Record.resize(t);
    		providedNum = 0;
    		for (int j = 0; j < t; j++) {
    			cin >> Record[j].name >> Record[j].id >> Record[j].illness >> Record[j].Time;
    			Record[j].order = j;
    			if (isIllegal(Record[j].id)) Record[j].name = "";
    			else {
    				if (!lastGet.count(Record[j].id)) lastGet[Record[j].id] = -30;
    				if (Record[j].illness == 1 && !gotten.count(Record[j].id)) {
    					ill.push_back(Record[j]);
    					gotten.insert(Record[j].id);
    				}
    			}
    		}
    		sort(Record.begin(), Record.end(), cmp);
    		for (int j = 0; j < t && providedNum < s; j++) {
    			if (Record[j].name != "" && i - lastGet[Record[j].id] > P) {
    				lastGet[Record[j].id] = i;
    				providedNum++;
    				cout << Record[j].name << ' ' << Record[j].id << endl;
    			}
    		}
    	}
    	for (node i:ill) cout << i.name << ' ' << i.id << '\n';
    	return 0;
    }
    

    7-20 凯撒密码

    为了防止信息被别人轻易窃取,需要把电码明文通过加密方式变换成为密文。输入一个以回车符为结束标志的字符串(少于80个字符),再输入一个整数offset,用凯撒密码将其加密后输出。恺撒密码是一种简单的替换加密技术,将明文中的所有字母都在字母表上偏移offset位后被替换成密文,当offset大于零时,表示向后偏移;当offset小于零时,表示向前偏移。

    输入格式:
    输入第一行给出一个以回车结束的非空字符串(少于80个字符);第二行输入一个整数offset。

    输出格式:
    输出加密后的结果字符串。

    输入样例1:
    Hello Hangzhou
    2
    输出样例1:
    Jgnnq Jcpibjqw
    输入样例2:
    a=x+y
    -1
    输出样例2:
    z=w+x

    坑点提示:char型变量范围-128到127,而’z’=122,计算偏移过程中可能会发生溢出,需要使用int型作为中间变量来过渡
    #include <bits/stdc++.h>
    
    using namespace std;
    
    int main()
    {
    	string s;getline(cin,s);int p;cin>>p; 
    	for(int i=0;i<s.size();++i)
    	{
    		if(isalpha(s[i]))
    		{
    			int t=p%26;
    			if(s[i]>='a')
    			{
    				int c=s[i];
    				c+=t;
    				if(c>'z')c-=26;
    				else if(c<'a')c+=26;
    				s[i]=c;
    			}
    			else
    			{
    				int c=s[i];
    				c+=t;
    				if(c>'Z')c-=26;
    				else if(c<'A')c+=26;
    				s[i]=c;
    			}
    		}
    	}
    	cout<<s;
    	return 0;
    }
    

    7-21 吉老师的回归

    曾经在天梯赛大杀四方的吉老师决定回归天梯赛赛场啦!

    为了简化题目,我们不妨假设天梯赛的每道题目可以用一个不超过 500 的、只包括可打印符号的字符串描述出来,如:Problem A: Print “Hello world!”。

    众所周知,吉老师的竞赛水平非常高超,你可以认为他每道题目都会做(事实上也是……)。因此,吉老师会按照顺序看题并做题。但吉老师水平太高了,所以签到题他就懒得做了(浪费时间),具体来说,假如题目的字符串里有 qiandao 或者 easy(区分大小写)的话,吉老师看完题目就会跳过这道题目不做。

    现在给定这次天梯赛总共有几道题目以及吉老师已经做完了几道题目,请你告诉大家吉老师现在正在做哪个题,或者吉老师已经把所有他打算做的题目做完了。

    提醒:天梯赛有分数升级的规则,如果不做签到题可能导致团队总分不足以升级,一般的选手请千万不要学习吉老师的酷炫行为!

    输入格式:
    输入第一行是两个正整数 N,M (1≤M≤N≤30),表示本次天梯赛有 N 道题目,吉老师现在做完了 M 道。

    接下来 N 行,每行是一个符合题目描述的字符串,表示天梯赛的题目内容。吉老师会按照给出的顺序看题——第一行就是吉老师看的第一道题,第二行就是第二道,以此类推。

    输出格式:
    在一行中输出吉老师当前正在做的题目对应的题面(即做完了 M 道题目后,吉老师正在做哪个题)。如果吉老师已经把所有他打算做的题目做完了,输出一行 Wo AK le。

    输入样例 1:
    5 1
    L1-1 is a qiandao problem.
    L1-2 is so…easy.
    L1-3 is Easy.
    L1-4 is qianDao.
    Wow, such L1-5, so easy.
    输出样例 1:
    L1-4 is qianDao.
    输入样例 2:
    5 4
    L1-1 is a-qiandao problem.
    L1-2 is so easy.
    L1-3 is Easy.
    L1-4 is qianDao.
    Wow, such L1-5, so!!easy.
    输出样例 2:
    Wo AK le

    #include <bits/stdc++.h>
    
    using namespace std;
    
    int main()
    {
    	int n,m;cin>>n>>m;getchar();
    	string s,ans;
    	bool flag=true;
    	while(n--)
    	{
    		getline(cin,s);
    		if(s.find("qiandao")!=s.npos||s.find("easy")!=s.npos)continue;
    		if(m==0)flag=false,ans=s;
    		m--;
    	}
    	if(flag)ans="Wo AK le";
    	cout<<ans; 
    	return 0;
    }
    
    展开全文
  • C++ 字符串排序

    千次阅读 2020-11-28 22:05:11
    给大一表妹的一次课后作业 ...【strcmp即可直接实现字符串的比较,但是不能实现“不区分大小写”的比较】 “what a beautiful flower” “Hello world” “how are you” “nice to meet you”............
    输入四个英文句子,按照首字母的顺序排序后输出四个句子。
    1.排序时不分区大小写)
    2.若存在两个相同的首字母,则按照第二个字母的顺序排序,如果第二个字母顺序相同,则按照第三个字母顺序排序……
    【strcmp即可直接实现字符串的比较,但是不能实现“不区分大小写”的比较】
    “what a beautiful flower”
    “Hello world”
    “how are you”
    “nice to meet you”
    

     运行截图

    pubfunc.h

    #ifndef _PUBFUNC_H
    #define _PUBFUNC_H
    
    #include<stdio.h>
    
    #define _in_
    #define _out_
    #define MAXSIZE 256
    
    //功能:将单个英文字符转化为大写 非英文字符不变
    //参数:ch 需要转换的字符
    //返回:转换后的字符
    char _to_upper(char _ch);
    
    //功能:将字符串中英文字符转化为大写 非英文字符不变
    //参数:_str 需要转换的字符串
    //返回:转换后的字符串
    char* to_upper(char* _in_ _str);
    
    //功能:将单个英文字符转化为小写 非英文字符不变
    //参数:ch 需要转换的字符
    //返回:转换后的字符
    char _to_lower(char _ch);
    
    //功能:将字符串中英文字符转化为小写 非英文字符不变
    //参数:_str 需要转换的字符串
    //返回:转换后的字符串
    char* to_lower(char* _in_ _str);
    
    //功能:比较字符串_str1和字符串_str2的大小 依据ASCII码大小比较字符串对应顺序单个字符的大小 若首字母相等则比较第二个依次类推 
    //参数:_str1 需要比较的字符串1
    //参数:_str2 需要比较的字符串2
    //返回:0-_str1=_str2  <0-_str1<_str2 >0-_str1>_str2
    int _strcmp(const char* _in_ _str1, const char* _in_ _str2);
    
    //功能:将字符串初始化
    //参数:_dest 需要初始化的字符串
    //参数:_ch 初始化的字符
    //参数:sizeof_str1 初始化的长度
    //返回:初始化后字符串
    void* _memset(char* _in_ _out_ _dest, char _in_ _ch, int sizeof_dest);
    
    //功能:将字符串_sorc复制到_dest
    //参数:_dest 目的地的字符串
    //参数:_sorc 被复制的字符串
    //返回:复制后字符串_dest
    char* _strcpy(char* _in_ _out_ _dest, const char* _in_ _sorc);
    
    //功能:将多个字符串数组排序
    //参数:_array 需要排序的二维数组指针
    //参数:sizeof_array 需要排序的字符串的个数
    //返回:0-成功 -1-失败
    int sort_array(char** _in_ _out_ _array, int sizeof_array);
    
    
    #endif // _PUBFUNC_H

      pubfunc.cpp

    #include "pubfunc.h"
    
    char _to_upper(char _ch)
    {
    	if (_ch >= 'a' && _ch <= 'z')
    	{
    		_ch = _ch - 32;
    	}
    	return _ch;
    }
    
    char* to_upper(char* _in_ _str)
    {
    	if (NULL == _str)
    	{
    		return NULL;
    	}
    
    	char* p = _str;
    	while (*p) *p++ = _to_upper(*p);
    
    	return _str;
    }
    
    char _to_lower(char _ch)
    {
    	if (_ch >= 'A' && _ch <= 'Z')
    	{
    		_ch = _ch + 32;
    	}
    	return _ch;
    }
    
    char* to_lower(char* _in_ _str)
    {
    	if (NULL == _str)
    	{
    		return NULL;
    	}
    
    	char* p = _str;
    	while (*p) *p++ = _to_lower(*p);
    
    	return _str;
    }
    
    int _strcmp(const char* _in_ _str1, const char* _in_ _str2)
    {
        const unsigned char *s1 = (const unsigned char *) p1;
        const unsigned char *s2 = (const unsigned char *) p2;
        unsigned char c1, c2;
    
        do
        {
            c1 = (unsigned char) *s1++;
            c2 = (unsigned char) *s2++;
            if (c1 == '\0')
            return c1 - c2;
        }
        while (c1 == c2);
    
        return c1 - c2;
    }
    
    void* _memset(char* _in_ _out_ _dest, char _in_ _ch, int sizeof_dest)
    {
    	if (NULL == _dest)
    	{
    		return NULL;
    	}
    
    	char* p = _dest;
    	int i;
    	for (i = 0; i< sizeof_dest-1; i++)
    	{
    		*p++ = _ch;
    	}
    	*p = '\0';
    	return _dest;
    }
    
    char* _strcpy(char* _in_ _out_ _dest, const char* _in_ _sorc)
    {
    	if (NULL == _dest || NULL == _sorc)
    	{
    		return NULL;
    	}
    	char* p = _dest;
    	char* q = (char*)_sorc;
    	while (*q)
    	{
    		*p++ = *q++;
    	}
    	*p = '\0';
    	return _dest;
    }
    
    int sort_array(char** _in_ _out_ _array, int sizeof_array)
    {
    	//以指针排序
    	char** p = _array;
    	int len = sizeof_array;
    	//简单的采用冒牌排序
    	char temp[MAXSIZE] = { 0 };
    	int i, j;
    	for (i = 0; i < len - 1; i++) /* 外循环为排序趟数,len个数进行len-1趟 */
    	{
    		for (j = 0; j < len - 1 - i; j++)
    		{ /* 内循环为每趟比较的次数,第i趟比较len-i次 */
    			if (_strcmp(*(p + j), *(p + j + 1)) > 0)
    			{ /* 相邻元素比较,若逆序则交换(升序为左大于右,降序反之) */
    				_memset(temp, 0x00, sizeof(temp));
    				_strcpy(temp, *(p + j));
    
    				_memset(*(p + j), 0x00, MAXSIZE);
    				_strcpy(*(p + j), *(p + j + 1));
    
    				_memset(*(p + j + 1), 0x00, MAXSIZE);
    				_strcpy(*(p + j + 1), temp);
    			}
    		}
    	}
    
    //	//以下是以数组下标排序
    // 	char** p = _array;
    // 	int len = sizeof_array;
    // 	//简单的采用冒牌排序
    // 	char temp[MAXSIZE] = { 0 };
    // 	int i, j;
    // 	for (i = 0; i < len - 1; i++) /* 外循环为排序趟数,len个数进行len-1趟 */
    // 	{
    // 		for (j = 0; j < len - 1 - i; j++)
    // 		{ /* 内循环为每趟比较的次数,第i趟比较len-i次 */
    // 			if (_strcmp(p[j], p[j + 1]) > 0)
    // 			{ /* 相邻元素比较,若逆序则交换(升序为左大于右,降序反之) */
    // 				memset(temp, 0x00, sizeof(temp));
    // 				strcpy(temp, p[j]);
    // 				strcpy(p[j], p[j + 1]);
    // 				strcpy(p[j + 1], temp);
    // 			}
    // 		}
    // 	}
    	
    	return 0;
    }

    main.cpp

    // ConsoleApplication1.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
    //
    #include "pubfunc.h"
    
    int main(int args, char* argv[])
    {
    	char test1[MAXSIZE] = "what a beautiful flower";
    	char test2[MAXSIZE] = "Hello world";
    	char test3[MAXSIZE] = "how are you";
    	char test4[MAXSIZE] = "nice to meet you";
    
    	char *test[] = { test1, test2, test3, test4 };
    
    	printf("排序前:\n");
    	char** q = test;
    	printf("%s\n", (*(q + 0)));
    	printf("%s\n", (*(q + 1)));
    	printf("%s\n", (*(q + 2)));
    	printf("%s\n", (*(q + 3)));
    
    	int ret = sort_array((char**)test, 4);
    	if (0 != ret)
    	{
    		printf("\n排序失败!\n");
    	}
    
    	printf("\n排序后:\n");
    	char** k = (char**)test;
    	printf("%s\n", k[0]);
    	printf("%s\n", k[1]);
    	printf("%s\n", k[2]);
    	printf("%s\n", k[3]);
    
    	return 0;
    }
    

    展开全文
  • string dic[] = { "自然语言处理","准时","课程","作业","有","老番茄","意思","上课","计算语言学","开心" }; // 是否为词表的词或者是词表词的前缀 bool inDict(string str) { bool re = false; int i; ...
  • 在最开始学习C++的时候,当想让计算机“读点儿东西”,我们...接下来将讲解一下关于读取字符、字符串的方法。1. cin简介首先我们先了解下cin到底是什么?它的机制是什么?cin是C++编程语言中的标准输入流对象,即ist...
  • 博文用简洁的顺序查找,处理中文字符串,搜索关键字的位置与关键字的总出现次数。
  • 中文分词作为自然语言处理的分支,也是中文人机自然语言交互的基础模块,与之英文不同的是,中文分词没有词的界限,因此在进行中文自然语言处理时,通常需要先进行分词,分词效果将直接影响词性,句法树等模块的效果...
  • c++ 中文字符串处理方法

    千次阅读 2013-10-07 14:33:06
    C++处理中文的问题困扰我很久了。...c++  char*/string 形式的字符串无法正确的对中文字符串进行处理(如 find, strlen, substr 等常规操作) 。 比如当你在char* find 英文逗号时,有可能匹配的不只是
  • 如今,我们虽然仍然把电脑称为计算机,但是如今它处理的文字...这部分内容介绍了C++中的库,这个库提供了很多方便的处理字符串的抽象。有这个库,你将会更容易编写有趣的应用程序。  Using strings as abstract values
  • 满足混合字符串汉字和数字等字符)批量(非一个字符一个字符),转换为16进制;同样支持16进制转换为字符串C++代码; 在VS2010上编码测试可运行。可用于串口通信数据编码。
  • C/C++/QT字符串

    2022-05-03 17:24:47
    目录C语言字符串C++语言中字符串C语言str系列库函数sizeof()、strlen()、length()和size()Qt字符串 C语言字符串 C语言不存在字符串数据类型,其通过一个以’\0’结尾的字符数组实现;所有字符串都是以...
  • C++ string字符串中提取汉字

    千次阅读 2021-12-30 01:24:54
    在GB2321编码中文的编码范围是:0xB0A1~0xF7FE #include <iostream> # include <string> using namespace std; string moveChinese(string str) { string strR = " "; //int nDest = 0; for...
  • 文本压缩有很多种方法,这里我们只考虑最简单的一种:...这里我们简单地假设原始字符串是完全由英文字母和空格组成的非空字符串。 输入格式: 输入第一行给出一个字符,如果是C就表示下面的字符串需要被压缩;如果...
  • 这时如果能把相关字符串用十六进制的形式打印出来,例如,"abc" 输出成 "\\x61\\x62\\x63" 这对于 i18n 的除错来说是很有帮助的。Python 里面,只需要使用repr()函数就行了。可在 C++ 如何做到这点呢?下面是用 ...
  • Go语言中字符串处理方法示例详解

    千次阅读 2020-12-29 07:42:34
    Go语言字符串是使用UTF-8编码的。UTF-8是Unicode的实现方式之一。Go语言原生支持字符串。使用双引号("")或反引号(``)定义。双引号:"", 用于单行字符串。反引号:``,用于定义多行字符串,内部会原样解析。示例:/...
  • 文章目录 表示数值的字符串 一、题目描述 二、解题思路及代码实现 1、解题思路 2、C++代码实现 三、提交结果 总结 表示数值的字符串 一、题目描述 请实现一个函数用来判断字符串是否表示数值(包括整数和小数)。...
  • 和其他语言不同,在 Go 语言中没有字符类型,字符只是整数的特殊用例。为什么说字符只是整数的特殊用例呢?因为在 Go ,用于表示字符的byte和rune类型都是整型的别名。在 Go 的源码我们可以看到://...
  • C/C++分割字符串strtok

    2021-09-14 16:49:35
    C/C++分割字符串需要自己实现,秋招笔试被处理输入的字符串耽误了几次。。。 #include <iostream> #include <string.h> #include <vector> #include "stdio.h" using namespace std; int main ()...
  • 因工作需要识别限长字符串中中文个数,且需要识别字符串最后两个字节为中文,因长度限制只能识别为乱码,需要截断乱码部分。搜了几篇文章,发现这篇写的最简便:...
  • UE4 C++中字符串处理

    2021-08-05 20:40:17
    C++中字符串使用的是String处理的,可以进行截取,大小写转换,逆序等等功能。而UE4为了游戏中字符串的功能不同而封装了3种字符串的类型,分别是FName,FText和FString。 **FName**:在虚幻引擎(UE4)的**内容...
  • C++语言篇 字符数组与字符串输入

    千次阅读 2018-12-07 14:50:28
    一、在字符数组输入,常用到cin , scanf() , gets() , cin.getline()和cin.get()函数。...cin.getline()和cin.get()可以读取固定长度的字符串,含空格等符号。 1、使用cin函数(不接受空格,...
  • 1、编码在讲字符串之前首先说说编码方式。字符串在程序用用数据类型进行存储,同时数据类型存储的也可以是不同编码方式的字符串。总的来说,常用编码方式有以下几种:ASCII:最古老的编码方式,只使用后7位,可以...
  • 通过 cin 来获取字符串是常用的操作,但是字符串中往往可能会包含空格等空白字符,而在一般的输入场景,由于不能通过键盘输入空字符 '\0'(在存储字符串都以空字符 '\0' 结尾),因此 cin 使用空白字符(空格...
  • C++语言字符串及字符数组练习

    千次阅读 2018-12-06 15:33:36
    本题是简单字符串处理,暴力枚举两串匹配的首字母,不断更新最大匹配值即可,最后的答案需要对最大匹配值和两串总长进行辗转相除。 12:加密的病历单 总时间限制: 1000ms 内存限制: 65536kB 描述 小英是药学专业...
  • C++ 已经提供了一些字符串处理函数,这些函数被封装在头文件 和 &lt;string.h&gt; 。 1.1. 字符串复制 void * memcpy ( void * destination, const void * source, size_t num ); 从 source 指针指向的...
  • c++中判断字符串中是否有汉字

    千次阅读 2019-07-08 00:31:13
    电脑系统英文字符串中文字符最根本的区别就在于: 1、英文的 ASCII 码,其最高位为 0,占一个字节 注:英文的ASCII码范围是在0到127,二进制为(0000 0000 ~ 0111 1111) 2、中文的 ASCII 码,其最高位为 1。...
  • C++ 笔记——字符串自定义加密处理

    千次阅读 2018-12-31 15:41:23
    根据惯例,先放定义。...但是此篇博客记录的加密算法和上述加密算法无关,主要记录的是按照个人喜好对字符串处理的简单方法。 字符串编码 一段字符串,把所有的a变成c,把c变成d,把d变成a,我们可以把这...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 61,815
精华内容 24,726
热门标签
关键字:

c++语言处理中文字符串

c++ 订阅