精华内容
下载资源
问答
  • 声明两个字符数组,分别存放原始字符串与处理后的字符串,编写函数strcopy(),以指针作为形参,在主函数调用该函数,以数组名作为实参传入,实现字符串的复制。 代码: #include<stdio.h> #include&...

    题目:

    编写程序:输入一个字符串,包含n个字符。编写一函数,将此字符串中从第m个字符开始的k个字符复制成为另外一个字符串。

    编程思路:

    声明两个字符数组,分别存放原始字符串与处理后的字符串,编写函数strcopy(),以指针作为形参,在主函数中调用该函数,以数组名作为实参传入,实现字符串的复制。

    代码:

    #include<stdio.h>
    #include<stdlib.h>
    void strcopy(char *p2,char *p1,int m,int k)
    {
        int i,j;
        for(i=m-1,j=0;j<k;i++,j++)
        {
            *(p2+j)=*(p1+i);
        }
    }
    int main()
    {
        int M,K;
        char s[1001],ss[1001]={"\0"};
        scanf("%s%d%d",s,&M,&K);
        strcopy(ss,s,M,K);
        printf("%s",ss);
        return 0;
    }
    
    展开全文
  • 1545. 找出第 N 二进制字符串中的第 K 位 LeetCode周赛 传送门 传送门 结题思路 // 思路1:首先,Sn的长度为2的(n-1)次-1,其前半段的字符串为Sn-1,中间一为“1”,后半段的为Sn-1取反后反转。最后找到的结果...

    1545. 找出第 N 个二进制字符串中的第 K 位 LeetCode周赛

    传送门

    传送门

    结题思路

    思路1:首先,Sn的长度为2的(n-1)次-1,其前半段的字符串为Sn-1,中间一个为“1”,后半段的为Sn-1取反后反转。最后找到的结果要么是中间的"1",要么是从“0”变来的。

    
    // 递归条件判断
    class Solution {
        public char char_not(char a)
        {
            if(a == '1')
            {
                return '0';
            }
            else 
            {
                return '1';
            }
        }
        public char findKthBit(int n, int k) {
            if(n == 1)
            {
                return '0';
            }
            int midPos = (1<<n-1);
            if(k == midPos)
            {
                return '1';
            }
            else if(k < midPos)
            {
                return findKthBit(n-1, k);
            }
            return char_not(findKthBit(n-1, 2*midPos -k));
        }
    }
    
    展开全文
  • 1.实现一个函数,可以左旋字符串中的k个字符。  ABCD左旋一个字符得到BCDA  ABCD左旋两个字符得到CDAB  #define _CRT_SECURE_NO_WARNINGS 0 #include #include #include //方法一:先把一位保存起来,...

    1.实现一个函数,可以左旋字符串中的k个字符。 

    ABCD左旋一个字符得到BCDA 

    ABCD左旋两个字符得到CDAB 

    #define _CRT_SECURE_NO_WARNINGS 0
    #include <stdio.h>
    #include <windows.h>
    #include <assert.h>
    //方法一:先把第一位保存起来,然后后一位依次放进前一位(从第二位开始),最后把第一位放到最后一位(空),
    //然后做一个while(左旋--)循环,左旋几次就循环几次。
    static void leftMoveCore(char *str, int len)
    {
    	int tmp = *str; //先把首字符存起来
    	int i = 0;
    	for (i = 0; i < len - 1;i++) 
    	{
    		str[i] = str[i + 1];
    	}
    	str[i] = tmp; //最后str[i]里存的是空,把首字符再放进str[i]里
    }
    void leftMove1(char *str, int len, int count)
    {
    	assert(str);
    	assert(len > 0);
    	assert(count > 0);
    	count %= len; //取有效的左旋次数
    	while (count--)
    	{
    		leftMoveCore(str, len);
    	}
    }
    //方法一
    
    //方法二:把str分为两段,先局部逆置,再整体逆置
    static void reverse(char *start, char *end)
    {
    	while (start < end)
    	{
    		*start ^= *end;
    		*end ^= *start;
    		*start ^= *end;
    		start++, end--;
    	}
    }
    void leftMove2(char *str, int len, int count)
    {
    	assert(str);
    	assert(len > 0);
    	assert(count > 0);
    	count %= len; //取有效的左旋次数
    	reverse(str, str + count - 1);
    	reverse(str +count, str + len - 1);
    	reverse(str, str + len - 1);
    	//或者
    	//reverse(str, (char*)&count - 1);
    	//reverse((char*)&count, (char*)&len - 1);
    	//reverse(str, (char*)&len - 1);
    }
    //方法二
    
    //方法三:把原有字符串再复制一份放到mem里,再进行拼接,左旋几次就把从第几位开始的后面几次个拷贝到前面的部分
    void leftMove3(char *str, int len, int count)
    {
    	assert(str);
    	assert(len > 0);
    	assert(count > 0);
    	count %= len; //取有效的左旋次数
    	int newSize = 2 * len + 1; //2*len+/0
    	char *mem = (char*)malloc(sizeof(char)*newSize);
    
    	strcpy(mem, str);
    	strcat(mem, str);
    	strncpy(str, mem + count, len);
    
    	free(mem);
    
    }
    //方法三
    
    int main()
    {
    	char str[] = "abcde12345";
    	int input = 0;
    	printf("输入左旋次数:\n");
    	scanf("%d", &input);
    	printf("前:%s\n", str);
    //	leftMove1(str, sizeof(str) / sizeof(str[0]) - 1, input); //必须把下标0开始考虑进去	
    //	leftMove2(str, sizeof(str) / sizeof(str[0]) - 1, input);
    	leftMove3(str, sizeof(str) / sizeof(str[0]) - 1, input);
    	printf("后:%s\n", str);
    	system("pause");
    	return 0;
    }
    
    
    

    2.判断一个字符串是否为另外一个字符串旋转之后的字符串。 

    例如:给定s1 = AABCD和s2 = BCDAA,返回1,给定s1=abcd和s2=ACBD,返回0. 、

    AABCD左旋一个字符得到ABCDA 

    AABCD左旋两个字符得到BCDAA 

    AABCD右旋一个字符得到DAABC 

    #define _CRT_SECURE_NO_WARNINGS 0
    #include <stdio.h>
    #include <windows.h>
    #include <assert.h>
    
    //方法一:先把第一位保存起来,然后后一位依次放进前一位(从第二位开始),最后把第一位放到最后一位(空),
    //然后做一个循环,循环字符串长度次。
    int findLeftMove1(char str1[], char str2[])
    {
    	assert(str1);
    	assert(str2);
    	int i = 0;
    	int j = 0;
    	int len = strlen(str1);
    	for (j = 1; j <= len; j++)
    	{
    		{
    			int tem = str1[0]; //先把首字符存起来
    			for (i = 0; i < len - 1; i++)
    			{
    				str1[i] = str1[i + 1];
    			}
    			str1[i] = tem; //最后str[i]里存的是空,把首字符再放进str[i]里
    		}
    
    		if (0 == strcmp(str1, str2))
    		{
    			return 1;
    		}
    	}
    	return -1;
    }
    //方法一
    
    
    //方法二:寻找str1是不是在str2里面。str1是不是str2的子串(把字符串弄成双倍字符串,与原有字符串相比判断)
    int findLeftMove2(char *str1, char *str2)
    { 
    	assert(str1);
    	assert(str2);
    	int strLen = strlen(str1);
    	int subStrLen = strlen(str2);
    	if (strLen != subStrLen)
    	{
    		return -1;
    	}
    	int newSize = 2 * strLen + 1; //2*strLen+/0
    	char *mem = (char*)malloc(sizeof(char)*newSize);
    
    	strcpy(mem, str1);
    	strcat(mem, str1);
    	if (strstr(mem, str2))
    	{
    		return 1;
    	}
    	free(mem);
    	return -1;
    }
    //方法二
    
    int main()
    {
    	char str1[] = "3412";
    	char str2[] = "1234";
    	int ret1 = findLeftMove1(str1, str2);
    	int ret2 = findLeftMove2("12as", "as12");
    	printf("ret1:%d\n", ret1);
    	printf("ret2:%d\n", ret2);
    	system("pause");
    	return 0;
    }


    展开全文
  • K 次操作转变字符串给你两个字符串 s 和 t ,你目标是在 k 次操作以内把字符串 s 转变成 t 。在 i 次操作时(1 <= i <= k),你可以选择进行如下操作:选择字符串 s 满足 1 <= j <= s.length 且...

    leetcode1540. K 次操作转变字符串

    给你两个字符串 st ,你的目标是在 k 次操作以内把字符串 s 转变成 t

    在第 i 次操作时(1 <= i <= k),你可以选择进行如下操作:

    • 选择字符串 s 中满足 1 <= j <= s.length 且之前未被选过的任意下标 j (下标从 1 开始),并将此位置的字符切换 i 次。
    • 不进行任何操作。

    切换 1 次字符的意思是用字母表中该字母的下一个字母替换它(字母表环状接起来,所以 'z' 切换后会变成 'a')。

    请记住任意一个下标 j 最多只能被操作 1 次。

    如果在不超过 k 次操作内可以把字符串 s 转变成 t ,那么请你返回 true ,否则请你返回 false

    示例 1:

    输入:s = "input", t = "ouput", k = 9
    输出:true
    解释:第 6 次操作时,我们将 'i' 切换 6 次得到 'o' 。第 7 次操作时,我们将 'n' 切换 7 次得到 'u' 。

    示例 2:

    输入:s = "abc", t = "bcd", k = 10
    输出:false
    解释:我们需要将每个字符切换 1 次才能得到 t 。我们可以在第 1 次操作时将 'a' 切换成 'b' ,但另外 2 个字母在剩余操作中无法再转变为 t 中对应字母。

    示例 3:

    输入:s = "aab", t = "bbb", k = 27
    输出:true
    解释:第 1 次操作时,我们将第一个 'a' 切换 1 次得到 'b' 。在第 27 次操作时,我们将第二个字母 'a' 切换 27 次得到 'b' 。

    提示:

    • 1 <= s.length, t.length <= 10^5
    • 0 <= k <= 10^9
    • st 只包含小写英文字母。

    方法:计数

    思路:

    本题使用计数的方法完成。对于每个需要改变的字符,它应该切换几次到达目标字符,取决于t[i]和s[i]之间的差,

    • 如果t[i]对应字符在s[i]字符的后面,那么它需要的切换次数即为ord(t[i])-ord(s[i])
    • 否则,需要切换的次数为ord(t[i])-ord(s[i])+26

    因此,每个字符需要切换的次数均为0-25,因此我们使用一个长度为26的数组nums,保存需要切换i次的字符的个数。

    因为我们只能在第i次操作的时候,切换i次,因此,如果nums[1] = 3,即有3个字符需要切换1次,那么我们只能在第1次操作、第27次操作和第53次操作将它们解决,即26*(nums[i]-1)+i。

    因此我们对nums中的所有数进行遍历,根据上面公式,找到最大的值,跟k进行比较,返回。

    还要注意的是,最开始如果s和t的长度不一样,直接返回False。

    代码:

    Python3:

    class Solution:
        def canConvertString(self, s: str, t: str, k: int) -> bool:
            # 如果长度不一样,直接False
            n = len(s)
            m = len(t)
            if n != m:
                return False
            # 初始化nums
            nums = [0]*26
            # 遍历填写nums
            for i in range(n):
                delta = ord(t[i])-ord(s[i])
                if delta >= 0:
                    nums[delta] += 1
                else:
                    nums[delta+26] += 1
            # 初始化need,需要的次数
            need = 0
            # 开始更新need
            for i in range(1,26):
                temp = max(0,26*(nums[i]-1)+i)
                need = max(need,temp)
            return need <= k

    cpp:

    class Solution {
    public:
        bool canConvertString(string s, string t, int k) {
             // 如果长度不一样,直接False
            int n = s.size();
            int m = t.size();
            if (n != m)
                return false;
            // 初始化nums
            vector<int>nums(26,0);
            // 遍历填写nums
            for (int i = 0; i < n; ++i){
                int delta = t[i]- s[i];
                if (delta >= 0)
                    nums[delta] ++;
                else
                    nums[delta+26] ++;
            }
    
            // 初始化need,需要的次数
            int need = 0;
            // 开始更新need
            for (int i = 1; i < 26; ++i){
                int temp = max(0,26*(nums[i]-1)+i);
                need = max(need,temp);
            }            
            return need <= k;
        }
    };
    

    结果:

    7960ac4dba0ee67bd2885c4e2ca5b894.png

    14d92309d969321151052fe4dd1b6915.png
    展开全文
  • 题目描述: 一 「开心字符串」定义为: 仅包含小写字母 [‘a’, ‘b’, ‘c’]. 对所有在 1 到 s.length - 1 之间的 i ,满足 s[i] != s[i + 1] (字符串的下标 1...请你返回排序后的第 k 开心字符串,如果长度为
  • 因为如果用双指针法进行反转字符串代码量会比较大,所以,我们采用stl库中的reserve函数 它的功能是反转字符串,具体是reserve(开始位置,结束位置) int n=s.size(); for(int i=0;i<n;i+=2*k) { //如果剩余...
  • 题目描述: 一 「开心字符串」定义为: 仅包含小写字母 [‘a’, ‘b’, ‘c’]. 对所有在 1 到 s.length - 1 之间的 i ,满足 s[i] != s[i + 1] (字符串的下标 1...请你返回排序后的第 k 开心字符串,如果长度为
  • 「开心字符串」定义为: ...= s[i + 1](字符串的下标 1 开始)。 比方说,字符串"abc","ac","b" 和"abcbabcbcb"都是开心字符串,但是"aa","baa"和"ababbc"都不是开心字符串。 给你两整数 n和 ...
  • 题目: 一 「开心字符串」定义为: 仅包含小写字母['a', 'b', 'c']. 对所有在1到s.length - 1之间的i,满足s[i] != s[i + 1](字符串的下标 1 开始)。...请你返回排序后的第 k 开心字符串,如果...
  • 「开心字符串」定义为: 仅包含小写字母 ['a', 'b', 'c']. 对所有在 1 到 s.length - 1 之间的 i ,满足 s[i] != s[i + 1] (字符串的下标 1 开始)。...请你返回排序后的第 k 开心字符串,如果长度为 n
  • 题目描述 一 「开心字符串」定义为: ...= s[i + 1](字符串的下标 1 开始)。 比方说,字符串"abc","ac","b"和"abcbabcbcb"都是开心字符串,但是"aa","baa"和"ababbc"都不是开心字符串。 给你两整...
  • 实现一个函数,可以左旋字符串中的k个字符。 eg: ABCD左旋一个字符得到BCDA ABCD左旋两个字符得到CDAB 问题分析: 1、输入一个数,这个数代表要从第几个数字开始左旋,存入 n ; 2、以 n 为界,分为前半部分和...
  • 「开心字符串」定义为: ...= s[i + 1](字符串的下标 1 开始)。 比方说,字符串"abc","ac","b"和"abcbabcbcb"都是开心字符串,但是"aa","baa"和"ababbc"都不是开心字符串。 给你两整数n和...
  • = s[i + 1] (字符串的下标 1 开始)。 比方说,字符串 “abc”,“ac”,“b” 和 “abcbabcbcb” 都是开心字符串,但是 “aa”,“baa” 和 “ababbc” 都不是开心字符串。 给你两整数 n 和 k...
  • 个字符串中找出不重复字符: 输入,“saskdfw234sad2t356sadfg”; 输出k; 输入,“sasdf23sad2t3sadf”; 输出t; 输入,“saskdfwfgwk23sad23sadfg”; 输出NULL; 面试时候碰到,当时没做做...
  • =10000,全部由字母组成)找到只出现一次的字符,并返回它位置, 如果没有则返回 -1(需要区分大小写).(0开始计数) 1、用字典k,v计数 # -*- coding:utf-8 -*- class Solution: def ...
  • #include<stdio.h> void d(char s[],int i... int j,k,length=0; while(s[length])length++; i--;j=i; if (i<length) { k=i+n; if(i+n<=length) while (k<length)s[j++]=s[k++]; s[j]=s[k]; }.
  • 实现一个函数,可以左旋字符串中的k个字符。 示例: ABCD左旋一个字符得到BCDA ABCD左旋两个字符得到CDAB 思绪一: 反转前k个字符串 反转剩下的字符串 再整体反转(这样就是左旋k个字符串) 思绪二: ...
  • #include <...//统计字符串出现次数 int main() { char str1[100],str2[100],*p1=str1,*p2=str2; int k=0; scanf("%s",str1); scanf("%s",str2); k=countString(str1,str2); if(k==0) printf("N
  • 牛牛有一个字符串s,并且允许你s中移除最多k个字符,你目标是让得到的字符串的价值最小。 输入描述: 输入包括两行,一行一个字符串s,字符串s长度length(1 ≤ length ≤ 50),其中只包含小写字母('a'-'z
  • 假设我们有一个字符串s,我们必须对s字符串进行查询。对于每查询查询[i],它分为三部分[left,right,k],我们可以重新排列子字符串s [left],...,s [right],然后最多选择k个子字符串替换为任何小写英文...
  • 题目: 给定一串数字,这串数字有可能大于long的最长... 采用贪心算法的思想,从字符串组成的数字中的高位开始比较。 例如:k = 6,即需要删除字符串192837465中6数 分析过程如下: 一次:9>2, 删除9...
  • 题目 A,B,C 是3个字符串。把A包含所有B都替换为C,如果替换以后还有B就继续替换,直到A不包含B为止。 请编写程序实现以上功能,... //判断A从第k个元素起始是否与B相同 bool replace_B(string A, int k, int len
  • b.Java,一类要实现clone功能,必须实现 Cloneable接口,则就要引入该包 c.字符序列接口,实现此接口非抽象类有String, StringBuffer, StringBuilder。结果来讲, 该接口主要作用就是使.
  • #include <stdio.h> #include <string.h> #include <stdlib.h> void select(char*a){ int i,flag=0; for(i=0;... if(a[i]=='k'&... printf("%d到%d元素是key\n",i,i+2); }
  • 周赛201场20200809 ...请你将字符串整理好,每次你都可以从字符串中选出满足上述条件相邻 字符并删除,直到字符串整理好为止。 请返回整理好 字符串 。题目保证在给出约束条件下,测试样例对
  • 例如,当从字符只读出前两个字符"go"时,一个只出现一次字符是"g"。当从该字符流读出前六个字符“google"时,一个只出现一次字符是"l"。 输出描述: 如果当前字符流没有存在出现一次字符,返回#字符...
  • 例如,当从字符只读出前两个字符”go”时,一个只出现一次字符是”g”。当从该字符流读出前六个字符“google”时,一个只出现一次字符是”l”。 输出描述: 如果当前字符流没有存在出现一次字符,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,042
精华内容 416
关键字:

从字符串中的第k个字符