笔试题-字符串

已于 2024-03-20 14:10:01 修改
阅读量711 收藏 15
点赞数 14
分类专栏： 算法 文章标签： 算法
于 2024-03-19 23:08:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dyj12780/article/details/136821519
版权
本文介绍了如何在不分配额外空间的情况下反转字符串，包括两种不同的实现方法。同时讨论了字符串旋转、查找重复子串和KMP算法的应用。
摘要由CSDN通过智能技术生成

反转字符串

  1. 反转字符串
    编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
    不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
    示例 1：
    输入：s = [“h”,“e”,“l”,“l”,“o”]
    输出：[“o”,“l”,“l”,“e”,“h”]
    示例 2：
    输入：s = [“H”,“a”,“n”,“n”,“a”,“h”]
    输出：[“h”,“a”,“n”,“n”,“a”,“H”]

提示：
1 <= s.length <= 105
s[i] 都是 ASCII 码表中的可打印字符

自写:

class Solution {
    public void reverseString(char[] s) {
        int j = s.length - 1;
        for(int i = 0; i < s.length/2; i ++){
            char temp = s[i];
            s[i] = s[j];
            s[j] = temp;
            j--;
        }
    }
}

参考:

class Solution {
    public void reverseString(char[] s) {
        int l = 0;
        int r = s.length - 1;
        while (l < r) {
            s[l] ^= s[r];  //构造 a ^ b 的结果，并放在 a 中
            s[r] ^= s[l];  //将 a ^ b 这一结果再 ^ b ，存入b中，此时 b = a, a = a ^ b
            s[l] ^= s[r];  //a ^ b 的结果再 ^ a ，存入 a 中，此时 b = a, a = b 完成交换
            l++;
            r--;
        }
    }
}

// 第二种方法用temp来交换数值更多人容易理解些
class Solution {
    public void reverseString(char[] s) {
        int l = 0;
        int r = s.length - 1;
        while(l < r){
            char temp = s[l];
            s[l] = s[r];
            s[r] = temp;
            l++;
            r--;
        }
    }
}

分区域反转字符串 *

外面现在在放烟花诶~

  1. 反转字符串 II

给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。
如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

示例 1：
输入：s = “abcdefg”, k = 2
输出：“bacdfeg”
示例 2：
输入：s = “abcd”, k = 2
输出：“bacd”
提示：
1 <= s.length <= 104
s 仅由小写英文组成
1 <= k <= 104

class Solution {
    public String reverseStr(String s, int k) {
        char[] ch = s.toCharArray();
        for(int i = 0;i < ch.length;i += 2 * k){
            int start = i;
            // 判断尾数够不够k个来取决end指针的位置
            int end = Math.min(ch.length - 1,start + k - 1);
            while(start < end){
                
                char temp = ch[start];
                ch[start] = ch[end];
                ch[end] = temp;

                start++;
                end--;
            }
        }
        return new String(ch);
    }
}

替换数字

  1. 替换数字
    题目描述
    给定一个字符串 s，它包含小写字母和数字字符，请编写一个函数，将字符串中的字母字符保持不变，而将每个数字字符替换为number。 例如，对于输入字符串 “a1b2c3”，函数应该将其转换为 “anumberbnumbercnumber”。

输入描述
输入一个字符串 s,s 仅包含小写字母和数字字符。
输出描述
打印一个新的字符串，其中每个数字字符都被替换为了number
输入示例
a1b2c3
输出示例
anumberbnumbercnumber
提示信息
数据范围：
1 <= s.length < 10000。

class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.nextLine();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            if (Character.isDigit(s.charAt(i))) {
                sb.append("number");
            }else sb.append(s.charAt(i));
        }
        System.out.println(sb);
    }
}

反转字符串中的单词 *)

  1. 反转字符串中的单词

给你一个字符串 s ，请你反转字符串中 单词 的顺序。
单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。
返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。
注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。

示例 1：
输入：s = “the sky is blue”
输出：“blue is sky the”
示例 2：
输入：s = " hello world "
输出：“world hello”
解释：反转后的字符串中不能存在前导空格和尾随空格。
示例 3：
输入：s = “a good example”
输出：“example good a”
解释：如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。

// 自写
class Solution {
    public String reverseWords(String s) {
        String[] arr = s.split(" ");
        String sb = "";
        if(s.isBlank()){
            return s;
        }
        for(String each : arr){
            if(!each.isBlank()){
            StringBuilder now = new StringBuilder(each.trim());
            sb = now.append(" ").append(sb).toString().trim();
            }
        }
        return sb;
    }
}


// 参考

class Solution {
   /**
     * 不使用Java内置方法实现
     * <p>
     * 1.去除首尾以及中间多余空格
     * 2.反转整个字符串
     * 3.反转各个单词
     */
    public String reverseWords(String s) {
        // System.out.println("ReverseWords.reverseWords2() called with: s = [" + s + "]");
        // 1.去除首尾以及中间多余空格
        StringBuilder sb = removeSpace(s);
        // 2.反转整个字符串
        reverseString(sb, 0, sb.length() - 1);
        // 3.反转各个单词
        reverseEachWord(sb);
        return sb.toString();
    }

    private StringBuilder removeSpace(String s) {
        // System.out.println("ReverseWords.removeSpace() called with: s = [" + s + "]");
        int start = 0;
        int end = s.length() - 1;
        while (s.charAt(start) == ' ') start++;
        while (s.charAt(end) == ' ') end--;
        StringBuilder sb = new StringBuilder();
        while (start <= end) {
            char c = s.charAt(start);
            if (c != ' ' || sb.charAt(sb.length() - 1) != ' ') {
                sb.append(c);
            }
            start++;
        }
        // System.out.println("ReverseWords.removeSpace returned: sb = [" + sb + "]");
        return sb;
    }

    /**
     * 反转字符串指定区间[start, end]的字符
     */
    public void reverseString(StringBuilder sb, int start, int end) {
        // System.out.println("ReverseWords.reverseString() called with: sb = [" + sb + "], start = [" + start + "], end = [" + end + "]");
        while (start < end) {
            char temp = sb.charAt(start);
            sb.setCharAt(start, sb.charAt(end));
            sb.setCharAt(end, temp);
            start++;
            end--;
        }
        // System.out.println("ReverseWords.reverseString returned: sb = [" + sb + "]");
    }

    private void reverseEachWord(StringBuilder sb) {
        int start = 0;
        int end = 1;
        int n = sb.length();
        while (start < n) {
            while (end < n && sb.charAt(end) != ' ') {
                end++;
            }
            reverseString(sb, start, end - 1);
            start = end + 1;
            end = start + 1;
        }
    }
}

右旋字符串 *

  1. 右旋字符串
    题目描述
    字符串的右旋转操作是把字符串尾部的若干个字符转移到字符串的前面。给定一个字符串 s 和一个正整数 k，请编写一个函数，将字符串中的后面 k 个字符移到字符串的前面，实现字符串的右旋转操作。
    例如，对于输入字符串 “abcdefg” 和整数 2，函数应该将其转换为 “fgabcde”。

输入描述
输入共包含两行，第一行为一个正整数 k，代表右旋转的位数。第二行为字符串 s，代表需要旋转的字符串。
输出描述
输出共一行，为进行了右旋转操作后的字符串。
输入示例
2
abcdefg
输出示例
fgabcde


public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = Integer.parseInt(in.nextLine());
        String s = in.nextLine();

        int len = s.length();  //获取字符串长度
        char[] chars = s.toCharArray();
        reverseString(chars, 0, len - 1);  //反转整个字符串
        reverseString(chars, 0, n - 1);  //反转前一段字符串，此时的字符串首尾尾是0,n - 1
        reverseString(chars, n, len - 1);  //反转后一段字符串，此时的字符串首尾尾是n,len - 1

        System.out.println(chars);

    }

    public static void reverseString(char[] ch, int start, int end) {
        //异或法反转字符串，参照题目 344.反转字符串的解释
        while (start < end) {
            ch[start] ^= ch[end];
            ch[end] ^= ch[start];
            ch[start] ^= ch[end];
            start++;
            end--;
        }
    }
}

找出字符串中第一个匹配项的下标 * KMP

  1. 找出字符串中第一个匹配项的下标
    给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。

示例 1：
输入：haystack = “sadbutsad”, needle = “sad”
输出：0
解释：“sad” 在下标 0 和 6 处匹配。
第一个匹配项的下标是 0 ，所以返回 0 。
示例 2：
输入：haystack = “leetcode”, needle = “leeto”
输出：-1
解释：“leeto” 没有在 “leetcode” 中出现，所以返回 -1 。

提示：
1 <= haystack.length, needle.length <= 104
haystack 和 needle 仅由小写英文字符组成

class Solution {
    public int strStr(String haystack, String needle) {
        String longStr = haystack;
        String model = needle;
        if(model.length() == 0){
            return 0;
        }

        int[] next = new int[model.length()];
        getNext(next, model);

        int j = 0;
        for(int i = 0; i<longStr.length(); i++){
            
            while(j>0 && model.charAt(j) != longStr.charAt(i)){
                j = next[j-1];
            }
            if(model.charAt(j) == longStr.charAt(i)){
                j++;
            }
            if(j == model.length()){
                return i-model.length()+1;
            }
        }
        return -1;
    }

    private void getNext(int[] next, String s){
        int start = 0;
        next[0] = 0;
        for(int i = 1; i < s.length(); i ++){
            
            while(start > 0 && s.charAt(i) != s.charAt(start)){
                start = next[start-1];
            }
            if(s.charAt(start) == s.charAt(i)){
                start ++;
            }
            next[i] = start;
        }
    }

}

重复的子字符串 **

  1. 重复的子字符串
    给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。

示例 1:
输入: s = “abab”
输出: true
解释: 可由子串 “ab” 重复两次构成。
示例 2:
输入: s = “aba”
输出: false
示例 3:
输入: s = “abcabcabcabc”
输出: true
解释: 可由子串 “abc” 重复四次构成。 (或子串 “abcabc” 重复两次构成。)

class Solution {
    public boolean repeatedSubstringPattern(String s) {
        if (s.equals("")) return false;

        int len = s.length();
        // 原串加个空格(哨兵)，使下标从1开始，这样j从0开始，也不用初始化了
        s = " " + s;
        char[] chars = s.toCharArray();
        int[] next = new int[len + 1];

        // 构造 next 数组过程，j从0开始(空格)，i从2开始
        for (int i = 2, j = 0; i <= len; i++) {
            // 匹配不成功，j回到前一位置 next 数组所对应的值
            while (j > 0 && chars[i] != chars[j + 1]) j = next[j];
            // 匹配成功，j往后移
            if (chars[i] == chars[j + 1]) j++;
            // 更新 next 数组的值
            next[i] = j;
        }

        // 最后判断是否是重复的子字符串，这里 next[len] 即代表next数组末尾的值
        if (next[len] > 0 && len % (len - next[len]) == 0) {
            return true;
        }
        return false;
    }
}
黔, 匍匐前进的潜
关注
专栏目录
2019广联达校招笔试题-字符串替换
hustanding
08-31 2294
题目描述 将给定的数转换为字符串，原则如下：1对应a，2对应b，…，26对应z。 示例 输入 12258 输出 “abbeh”,”aveh”,”abyh”,”lbeh”,”lyh” 编写函数给出可以转换的字符串的个数。 题目思路 题目仅仅要求给出种类的数，那么我们可以具体的来分析 1. 当字符串为空串，返回0 2. 当字符串长度为1，返回1...
金山笔试题-字符串中的字符’*‘移到串的前部分
liyf__88的博客
05-18 688
/* 2005 年11 月金山笔试题。 函数将字符串中的字符’‘移到串的前部分，前面的非’‘字符后移，但不能改变非’*’字符的先后顺序， 函数返回串中字符’*’的数量。如原始串为：abcde*12，处理后为*abcde12，函数并返回值为1。（要求使用尽量少的时间和辅助空间）。 */includeusing namespace std;int strMove(char* str) {
笔试题—字符串常见的算法题集锦
2401_84149694的博客
05-08 935
@param c@return*/private static int[] getNextVal(String c) {int[] nextVal = new int[c.length() + 1];int front = 0;int behind = 1;nextVal[1] = 0;/***/while (behind < c.length()) {if (front == 0 || c.charAt(front - 1) == c.charAt(behind - 1)) {++front;++behi
海康笔试题--字符串分割
Silence的博客
10-11 2828
一、题目要求是对输入的字符串以及分隔符按照分隔符来分割，当时是在替别人做题，由于误导以及时间的紧迫并没有完全读懂题。 题目给的样例是： 输入：abc,sjd,sdjhsj,sjfas,sjhd, , 输出：abc sjd sdjhsj sjfas sjhd 输出格式是一个小字符串占用一
202205014java算法笔试题----String(字符串)
qq_42847719的博客
05-15 767
7.如何求相对路径 6.如何截取包含中文的字符串
3.26美团笔试--字符串重排
sandy_star
03-27 969
第一题：字符串重排 题目描述 给你一个只包含小写字符的字符串s，你可以按任意顺序重排这个字符串，请问重排过后的字符串中，最多能有多少个 ‘acbcca’ 子串？ 例如：字符串 ‘dacbccab’中含 1 个 ‘acbcca’子串，按其他方式重排后最多也只能包含 1 个 ‘ acbcca’ 子串。字符串 ‘acbccaacccb’中含1个‘acbcca’子串，但是重排成 ‘acbccacbcca’后包含了 2个 ‘acbcca’子串。 样例输入1： dacbccab 样例输出： 1 样例输入2：
笔试题-字符串模式匹配模式串中‘？’可以匹配目标串中的任何字符，模式串中的 ’*’可以匹配目标串中的任何长度的串java实现
WukongGo的博客
03-28 1118
题目描述 给出两个字符串，分别是模式串P和目标串T，判断模式串和目标串是否匹配，匹配输出 1，不匹配输出 0。模式串中‘？’可以匹配目标串中的任何字符，模式串中的 ’*’可以匹配目标串中的任何长度的串，模式串的其它字符必须和目标串的字符匹配。例如P=a?b，T=acb，则P 和 T 匹配。 输入描述: 输入第一行包含一个字符串p，(1 ≤ |p| ≤ 20). 输入第二行...
笔试编程 -- 字符串的查找替换
lyy07210的博客
09-04 887
笔试编程题~ 正则表达式~
CVTE笔试题---字符串的全排列
John的博客
03-18 971
今天笔了cvte的实习生在线笔试题，一个感觉，基础很重要，如果没有扎实的基础，全是不定项的选择题，真的都是致命伤；下面我就编程题–字符串的全排列进行总结；当然，这道题在剑指offer上就有，面试经常出，我以前也做过，但是时间长了，不太熟了，做的时候挺吃力，就在这里总结一下吧！题目： 输入一个字符串，打印该字符串中字符的所有排列，例如输入abc，则打印出abc,acb,bac,bca,cab,cba。
C/C++ 笔试题汇总---字符串类
NoRegret
10-16 833
没有经过重新排序，都是一些摘抄，可能看起来比较碎。1 .已知strcpy的函数原型：char *strcpy(char *strDest, const char *strSrc)其中strDest 是目的字符串，strSrc 是源字符串。不调用C++/C 的字符串库函数，请编写函数 strcpy。#include <stdlib.h> #include<stdio.h> #include <ass
腾讯在线笔试题-字符串反转，以及把整个字符串逆序
07-18
首先，字符串反转是编程中常见的问题，常常用于各类笔试和面试中。而字符串逆序则是在反转的基础上，进一步处理，让整个字符串的顺序完全颠倒。 在本知识点中，将详细介绍以下内容： 1. 字符串反转的原理和方法 2. ...
java关于字符串拼接的笔试题-practice:实践
06-17
关于java习惯的笔试题# Algos ## 数组和字符串 * 滑动窗口问题 * ID：通常需要在较长的字符串中找到最短或最长的某个部分 * 有时从前面和后面开始（陷阱水），其他时候从前面和一英寸开始* 运行最大问题和线性 dp * ...
Code_笔试题_字符串压缩_
09-29
标题中的“Code_笔试题_字符串压缩_”指的是一个与编程相关的笔试题目，重点在于实现字符串的压缩功能。这类问题通常出现在技术面试或招聘过程的笔试试题中，旨在考察应聘者的编程能力和对数据结构的理解。 描述中...
java关于字符串拼接的笔试题-frontend-interview:努力学习前端（WIP）
06-17
关于java习惯的笔试题前端面试 传奇： :check_mark_button: ： 完全的 :man_running_light_skin_tone:：还需要努力 :construction: : 还没开始 Javascript :check_mark_button: 解释new String(1)和String(1)之间的...
java字符串和数组笔试题-Android-Interview-Questions:安卓面试题
06-17
java字符串和数组笔试题安卓面试题 这个存储库包含高级 Android 开发人员职位的技术面试问题，这些问题是我或我通常从其他候选人那里问到的。 随意贡献和改进它。 目录 一般的问题 你最近的 3 个申请是什么？ 哪个是...
算法基础-链表
August的专栏
11-05 205
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
100种算法【Python版】第51篇——希尔排序
最新发布
AnFany
11-06 223
100种算法【Python版】第51篇——希尔排序
字符串-06-整数与ip地址之间的转换
qq_45480682的博客
11-04 306
华为od算法——HJ33
【LeetCode】【算法】160.相交链表
passer__jw767的博客
11-05 276
Leetcode 160. 相交链表
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值