字符串常考面试题（大数相加）

已于 2022-03-30 17:50:54 修改
阅读量216 收藏
点赞数
分类专栏： LeetCode 剑指Offer 文章标签： 面试 链表
于 2021-09-03 16:55:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45661125/article/details/120083290
版权

字符串常考面试题

大数相加

https://www.nowcoder.com/practice/11ae12e8c6fe48f883cad618c2e81475?tpId=117&&tqId=37842&&companyId=665&rp=1&ru=/company/home/code/665&qru=/ta/job-code-high/question-ranking

import java.util.*;
public class Solution {
    public String solve (String s, String t) {
        // write code here
        if(s == null || "".equals(s)) {
            return t;
        }
        if(t == null || "".equals(t)) {
            return s;
        }
        int i = s.length() - 1;
        int j = t.length() - 1;
        int carry = 0;
        StringBuffer ret = new StringBuffer();
        while(i >= 0 || j >= 0) {
           int n1 = i >= 0 ? s.charAt(i) - '0' : 0;
           int n2 = j >= 0 ? t.charAt(j) - '0' : 0;
           int sum = n1 + n2 + carry;
            ret.append((char)((sum % 10) + '0'));
            carry = sum / 10;
            i--;
            j--;
            
        }
        if(carry > 0) {
            ret.append('1');
        }
        ret.reverse();
        return ret.toString();
    }
}

大数相乘

https://www.nowcoder.com/practice/c4c488d4d40d4c4e9824c3650f7d5571?tpId=117&&tqId=37843&&companyId=665&rp=1&ru=/company/home/code/665&qru=/ta/job-code-high/question-ranking

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 
     * @param s string字符串 第一个整数
     * @param t string字符串 第二个整数
     * @return string字符串
     */
    public String solve (String s, String t) {
        // write code here
         if(s ==  null || "".equals(s))  {
            return t;
        }
        if(t == null || "".equals(t)) {
            return s;
        }
        int len1 = s.length() - 1;
        int len2 = t.length() - 1;
      
        int[] mul = new int[len1 + len2 + 2];
        
        for(int i = len1; i >= 0; i--) {
            for(int j = len2; j >= 0; j--) {
                int sum = (s.charAt(i)-'0') * (t.charAt(j)-'0');      
                sum += mul[i + j + 1]; // 先加低位判断是否有新的进位

                mul[i + j] += sum / 10;
                mul[i + j + 1] = sum % 10;
            }
        }
        
        StringBuilder ret = new StringBuilder();
        int i = 0;
        // 去掉前导0
        while(i < mul.length-1 && mul[i] == 0)  {
                i++;
        }
        for(; i < mul.length; ++i) {
             ret.append(mul[i]);
        }  
        return ret.toString();
    }
}

两数相加

https://leetcode-cn.com/problems/add-two-numbers/

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        if(l1 == null) {
            return l2;
        }
        if(l2 == null) {
            return l1;
        }
        ListNode head = null;
        ListNode tail = null;
        int carry = 0;
        while(l1 != null || l2 != null) {
            int n1 = l1 != null ? l1.val : 0;
            int n2 = l2 != null ? l2.val : 0;
            int sum = n1 + n2 + carry;
            if(head == null) {
                head = tail = new ListNode(sum % 10);
            }else {
                tail.next = new ListNode(sum % 10);
                tail = tail.next;
            }
            carry = sum / 10;
            if(l1 != null) {
                l1 = l1.next;
            }
            if(l2 != null) {
                l2 = l2.next;
            }
        }
        if(carry > 0) {
            tail.next = new ListNode(carry);
        }
        return head;
    }
}


class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        if(l1 == null) {
            return l2;
        }
        if(l2 == null) {
            return l1;
        }
        ListNode newHead = new ListNode(-1);
        ListNode tmp = newHead;
        int carry = 0;
        while(l1 != null || l2 != null) {
            int n1 = l1 != null ? l1.val : 0;
            int n2 = l2 != null ? l2.val : 0;
            int sum = n1 + n2 + carry;
            carry = sum / 10;
            ListNode node = new ListNode(sum % 10);
            tmp.next = node;
            tmp = node;
            if(l1 != null) {
                l1 = l1.next;
            }
            if(l2 != null) {
                l2 = l2.next;
            }
        }
        if(carry > 0) {
            tmp.next = new ListNode(1);
        }
        return newHead.next;
    }
}

链表相加

添加链接描述

import java.util.*;
public class Solution {
    public ListNode reverse(ListNode head) {
        if(head == null) {
            return null;
        }
        ListNode cur = head;
        ListNode prev = null;
        ListNode curNext = null;
        while(cur != null) {
            curNext = cur.next;https://www.nowcoder.com/practice/c56f6c70fb3f4849bc56e33ff2a50b6b?tpId=117&&tqId=37814&&companyId=665&rp=1&ru=/company/home/code/665&qru=/ta/job-code-high/question-ranking
            cur.next = prev;
            prev = cur;
            cur = curNext;
        }
        return prev;
    }
    public ListNode addInList (ListNode h1, ListNode h2) {
        // write code here
        if(h1 == null) {
            return h2;
        }
        if(h2 == null) {
            return h1;
        }
        ListNode newH1 = reverse(h1);
        ListNode newH2 = reverse(h2);
        ListNode head = null, tail = null;
        int carry = 0;
        while(newH1 != null || newH2 != null) {
            int n1 = newH1 != null ? newH1.val : 0;
            int n2 = newH2 != null ? newH2.val : 0;
            int sum = n1 + n2 + carry;
            if(head == null) {
                head = tail = new ListNode(sum % 10);
            }else {
                tail.next = new ListNode(sum % 10);
                tail = tail.next;
            }
            carry = sum / 10;
            if(newH1 != null) {
                newH1 = newH1.next;
            }
            if(newH2 != null) {
               newH2 = newH2.next;
            }
        }
        if(carry > 0) {
            tail.next = new ListNode(carry);
        }
       ListNode ret = reverse(head);
        return ret;
    }
}

二进制求和

https://leetcode-cn.com/problems/add-binary/

class Solution {
    public String addBinary(String s1, String s2) {
         if(s1 == null || s1.length() == 0) {
            return s2;
        }
        if(s2 == null || s2.length() == 0) {
            return s1;
        }
        StringBuffer ret = new StringBuffer();
        int carry = 0;
        int i = s1.length() - 1;
        int j = s2.length() - 1;
        while(i >= 0 || j >= 0) {
            int n1 = i >= 0 ? s1.charAt(i) - '0' : 0;
            int n2 = j >= 0 ? s2.charAt(j) - '0' : 0;
            int sum = n1 + n2 + carry;
            ret.append(sum % 2);
            carry = sum / 2;
            i--;
            j--;
        }
        if(carry > 0) {
            ret.append('1');
        }
        return ret.reverse().toString();
    }
}

数组中相加和为0的三元组

https://www.nowcoder.com/practice/345e2ed5f81d4017bbb8cc6055b0b711?tpId=117&&tqId=37751&&companyId=898&rp=1&ru=/company/home/code/898&qru=/ta/job-code-high/question-ranking

import java.util.*;
public class Solution {
    public ArrayList<ArrayList<Integer>> threeSum(int[] nums) {
        ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
        if(nums == null || nums.length == 0) {
           return ret;
        }
        int len = nums.length;
        Arrays.sort(nums);
        for(int i = 0; i < len; i++) {
            if(nums[i] > 0) {
                break;
            }
            if(i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            int l = i + 1, r = len - 1;
            while(l < r) {
                int sum = nums[i] + nums[l] + nums[r];
                if(sum == 0) {
                    ArrayList<Integer> tmp = new ArrayList<>();
                    tmp.add(nums[i]);
                    tmp.add(nums[l]);
                    tmp.add(nums[r]);
                    ret.add(tmp);
               
                while(l < r && nums[l] == nums[l + 1]) {
                    l++;
                }
                l++;
                }else if(sum < 0) {
                    l++;
                }else {
                    r--;
                }
            }
        }
        return ret;
    }
}

把字符串转成整数

https://leetcode-cn.com/problems/ba-zi-fu-chuan-zhuan-huan-cheng-zheng-shu-lcof/

class Solution {
    public int strToInt(String str) {
    	//先去空格再判空，不然" "教您做人，血的教训
        str = str.trim();
        if(str.length() == 0){
            return 0;
        }
        //然后我想啊，下面要判断首位了
        //首位合格的无非就'+'或'-'或数字三种情况，其他的一概滚蛋
        //'+''-'肯定是要把它去掉的，这样三种情况就统一了
        //当然了，'-abc'这种有可能出现，不过只看首位它是没毛病的
        //让它进来，反正后面很容易解决
        //既然要去掉正负号，那肯定要出个boolean记一下是不是负数
        boolean isMinus = false;
        char[] ch = str.toCharArray();
        //首位是不是正负号或者数字啊
        if(ch[0] == '+' || ch[0] == '-' || Character.isDigit(ch[0])){
        	//是不是正负号啊
            if(ch[0] == '+' || ch[0] == '-'){
            	//是不是负号啊
                if(ch[0] == '-'){
                    isMinus = true;
                }
                //删除首位
                ch = Arrays.copyOfRange(ch,1,ch.length);
            }
            //首位搞定了就看后面是不是数字了，直到不是数字的地方或者倒底结束
            int index = 0;
            //结果可能超int范围，拿个long接一下
            //'-abc'这种情况返回的也是0，舒服，一箭双雕
            long res = 0;
            //短路与助您远离空指针喔，铁汁们，先后顺序关注一下
            while(index < ch.length && Character.isDigit(ch[index])){
                //一位一位往上算
                res *= 10;
                res += ch[index] - '0';
                //及时止损，一看到res超int范围立马return
                //你要是想着最后一起算，那肯定会有超long范围的测试用例等着你，你就哭去吧
                if(res > Integer.MAX_VALUE){
                    //正负号看是正数负数，返回最大值
                    return isMinus ? Integer.MIN_VALUE : Integer.MAX_VALUE;
                }
                //别忘了往后走一位
                index++;
            }
            //long转int就是这么朴实无华
            return isMinus ? -(int)res : (int)res;
        }
        //兄弟首位都不对想啥呢，回去吧您
        return 0;
    }
}

第一个只出现一次的字符

https://leetcode-cn.com/problems/di-yi-ge-zhi-chu-xian-yi-ci-de-zi-fu-lcof/

 public char firstUniqChar(String s) {
    if(s == null || s.length() == 0) return ' ';
        HashMap<Character, Integer> map = new HashMap<>(); 
        for(int i = 0;i < s.length();i++){
            char c = s.charAt(i);
            if(map.containsKey(c)){
                map.put(c, map.get(c) + 1);
            }
            else
                map.put(c, 1);
        }
        for(int i = 0;i < s.length();i++){
            if(map.get(s.charAt(i)) == 1){
                return s.charAt(i);
            }
        }
        return ' ';
    }

最长公共前缀

https://leetcode-cn.com/problems/longest-common-prefix/

class Solution {
    public String longestCommonPrefix(String[] strs) {
        if(strs == null || strs.length == 0) {
            return "";
        }
        String ret = strs[0];
        for(int i = 0; i < strs[0].length(); i++) {
            for(int j = 1; j < strs.length; j++) {
                if(i == strs[j].length() || strs[0].charAt(i) != strs[j].charAt(i)) {
                    return ret.substring(0, i);
                }
            }
        }
        return ret;
    }
}

反转字符串

class Solution {
    public void reverseString(char[] s) {
         if(s == null || s.length == 0) {
            return ;
        }
        int i = 0, j = s.length - 1;
        while(i < j) {
            char tmp = s[i];
            s[i] = s[j];
            s[j] = tmp;
            i++;
            j--;
        }
        return ;
    }
}

反转字符串II（反转k个）

https://leetcode-cn.com/problems/reverse-string-ii/
在这里插入图片描述

class Solution {
    public String reverseStr(String s, int k) {
        char[] a = s.toCharArray();
        for (int start = 0; start < a.length; start += 2 * k) {
            int i = start, j = Math.min(start + k - 1, a.length - 1);
            while (i < j) {
                char tmp = a[i];
                a[i++] = a[j];
                a[j--] = tmp;
            }
        }
        return new String(a);
    }
}

仅仅反转字母

https://leetcode-cn.com/problems/reverse-only-letters/

class Solution {
   public String reverseOnlyLetters(String S) {
        StringBuilder ret = new StringBuilder();
        int j = S.length() - 1;
        for (int i = 0; i < S.length(); ++i) {
            if (Character.isLetter(S.charAt(i))) {
                while (!Character.isLetter(S.charAt(j)))
                    j--;
                ret.append(S.charAt(j--));
            } else {
                ret.append(S.charAt(i));
            }
        }
        return ret.toString();
    }
}

反转单词（顺序改变）

https://leetcode-cn.com/problems/fan-zhuan-dan-ci-shun-xu-lcof/

class Solution {
    public String reverseWords(String s) {
        int j = s.length() - 1, i = j;
        StringBuffer ret = new StringBuffer();
        while(i >= 0) {
            while(i >= 0 && s.charAt(i) != ' ') {
                i--;
            }
            ret.append(s.substring(i + 1, j + 1) + " ");
            while(i >= 0 && s.charAt(i) == ' ') {
                i--;
            }
            j = i;
        }
        return ret.toString().trim();
    }
}

反转单词（顺序不变）

https://leetcode-cn.com/problems/reverse-words-in-a-string-iii/

class Solution {
    public String reverseWords(String s) {
        String[] strs = s.split(" ");
	    StringBuffer ret = new StringBuffer();
	    for (int i = 0; i < strs.length; i++) {
		    ret.append(new StringBuffer(strs[i]).reverse().toString());
		    ret.append(" ");
	    }
	    return ret.toString().trim();
    }
}

有效括号序列（括号匹配）

import java.util.*;


public class Solution {
    public boolean isValid (String s) {
          if(s == null || s.length() == 0) {
            return false;
        }
        Stack<Character> stk = new Stack<>();
        for(int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            if((ch == '(') || (ch == '[') || (ch == '{')) {
                stk.push(ch);
            }else if((ch == ')') || (ch == ']') || (ch == '}')){
                if(stk.isEmpty()) {
                    return false;
                }else  {
                char top = stk.peek();
                if((top == '(' && ch == ')') || (top == '[' && ch == ']') || (top == '{' && ch == '}')) {
                    stk.pop();
                }else {
                    return false;
                }
            }
         }
        }
        if(stk.isEmpty()) {
            return true;
        }
        return false;
    }
}

大数加法

import java.util.*;


public class Solution {
    public String solve (String s, String t) {
        // write code here
        if(s == null || "".equals(s)) {
            return t;
        }
        if(t == null || "".equals(t)) {
            return s;
        }
        int i = s.length() - 1;
        int j = t.length() - 1;
        StringBuffer ret = new StringBuffer();
        int carry = 0;
        while(i >= 0 || j >= 0) {
            int n1 = i >= 0 ? s.charAt(i) - '0' : 0;
            int n2 = j >= 0 ? t.charAt(j) - '0' : 0;
            int sum = n1 + n2 + carry;
            carry = sum / 10;
            ret.append(sum % 10);
            i--;
            j--;
        }
        if(carry > 0) {
            ret.append('1');
        }
        return ret.reverse().toString();
    }
}

字符串的排列

牛客
import java.util.ArrayList;
import java.util.*;
public class Solution {
    public ArrayList<String> ret = new ArrayList<>();
    public ArrayList<String> Permutation(String s) {
        if(s.length() == 0) {
            return ret;
        }
        int n = s.length();
        char[] str = s.toCharArray();
        Arrays.sort(str);
        StringBuffer path = new StringBuffer();
        boolean[] used = new boolean[n];
        dfs(str, n, 0, used, ret, path);
        return ret;
    }
     public void dfs(char[] str, int len, int depth, boolean[] used, List<String> ret, StringBuffer path ) {
        if(depth == len) {
            ret.add(path.toString());
        }
        for(int i = 0; i < len; i++) {
         if(used[i]) {
             continue;
         }
        
        if(i > 0 && str[i] == str[i - 1] && !used[i - 1]) {
            continue;
        }
        path.append(str[i]);
        used[i] = true;
        dfs(str, len, depth + 1, used, ret, path);
        used[i] = false;
        path.deleteCharAt(path.length() - 1);
         }
    }
}

力扣
class Solution {
    public List<String> ret = new ArrayList<>();
    public String[] permutation(String s) {
        if(s.length() == 0) {
            return new String[0];
        }
        int n = s.length();
        char[] str = s.toCharArray();
        Arrays.sort(str);
        StringBuffer path = new StringBuffer();
        boolean[] used = new boolean[n];
        dfs(str, n, 0, used, ret, path);
        return ret.toArray(new String[0]);
    }
    public void dfs(char[] str, int len, int depth, boolean[] used, List<String> ret, StringBuffer path ) {
        if(depth == len) {
            ret.add(path.toString());
        }
        for(int i = 0; i < len; i++) {
         if(used[i]) {
             continue;
         }
        
        if(i > 0 && str[i] == str[i - 1] && !used[i - 1]) {
            continue;
        }
        path.append(str[i]);
        used[i] = true;
        dfs(str, len, depth + 1, used, ret, path);
        used[i] = false;
        path.deleteCharAt(path.length() - 1);
         }
    }
}

最长回文子串

import java.util.*;


public class Solution {
     public static boolean isHuiWen(String s) {
        if(s == null ||s.length() == 0) {
            return false;
        }
        int i = 0, j = s.length() - 1;
        while(i < j) {
            if(s.charAt(i) != s.charAt(j)) {
                return false;
            }
            i++;
            j--;
        }
        return true;
    }
    public int getLongestPalindrome (String s) {
        int n = s.length();
        int ret = 0;
        for(int i = 0; i < n; i++) {
            for(int j = i + 1; j <= n; j++) {
                if(isHuiWen(s.substring(i, j))) {
                    if(ret < j - i) {
                        ret  = j - i;
                    }
                }
            }
        }
        return ret;
    }
}

最长公共前缀

import java.util.*;


public class Solution {
    public String longestCommonPrefix (String[] strs) {
        // write code here
        if(strs == null || strs.length == 0) {
            return "";
        }
        String ret = strs[0];
        for(int i = 0; i < strs[0].length(); i++) {
            for(int j = 1; j < strs.length; j++) {
                if(i == strs[j].length() || strs[0].charAt(i) != strs[j].charAt(i)) {
                    return ret.substring(0, i);
                }
            }
        }
        return ret;
    }
}

判断字符串是否回文

import java.util.*;
public class Solution {
    public boolean judge (String s) {
        // write code here
         if(s == null ||s.length() == 0) {
            return false;
        }
        int i = 0, j = s.length() - 1;
        while(i < j) {
            if(s.charAt(i) != s.charAt(j)) {
                return false;
            }
            i++;
            j--;
        }
        return true;
    }
}

字符串变形

import java.util.*;

public class Solution {
     // 反转字符串大小写
    public String func(String str){
        StringBuilder ret = new StringBuilder();
        for(int i = 0; i < str.length(); i++){
            if(Character.isUpperCase(str.charAt(i))){
                ret.append(Character.toLowerCase(str.charAt(i)));
            }else{
                ret.append(Character.toUpperCase(str.charAt(i)));
            }
        }
        return ret.toString();
    }
    
    public String trans(String s, int n) {  
        String[] strs = s.split(" ", -1);// 这里，limit设置为-1，模式可以应用无数次
        StringBuilder ret = new StringBuilder();
        for(int i = strs.length - 1; i >= 0; i--){
            ret.append(func(strs[i]));
            if(i != 0){
                ret.append(" ");
            }
        }
        return ret.toString();
    }
}

数字字符串转换成ip地址

在这里插入图片描述

import java.util.*;


public class Solution {
    /**
     * 
     * @param s string字符串 
     * @return string字符串ArrayList
     */
    ArrayList<String> ret = new ArrayList<>();
    ArrayList<String> path = new ArrayList<>();
    public ArrayList<String> restoreIpAddresses (String s) {
        // write code here
        if(s.length() > 12 || s.length() < 4){
            return ret;
        }
        dfs(s, 0, ret, path);
        return ret;
    }
     private void dfs(String s, int depth, List<String> ret, List<String> path){
        int n = s.length();
        int size = path.size();
        if(3 * (4 - size) < n - depth || n - depth < (4 - size)){
            // 剩下的分不完了，剪枝
            return;
        }
        if(size == 4 && depth == n){
            // 正确的情况
            StringBuilder tmp = new StringBuilder();
            boolean first = true;
            for(String str : path){
                if(!first){
                    tmp.append(".");
                }
                first = false;
                tmp.append(str);
            }
            ret.add(tmp.toString());
            return;
        }
        // 如果是0需要特判
        if(s.charAt(depth) == '0'){
            path.add("0");
            dfs(s, depth + 1, ret, path);
            path.remove(path.size() - 1);
        }else{
            // 防止越界
            int right = Math.min(depth + 3, n);
            for(int i = depth; i < right; i++){
                String tmp = s.substring(depth, i + 1);
                if(check(tmp)){
                    path.add(tmp);
                    dfs(s, i + 1, ret, path);
                    path.remove(path.size() - 1);
                }
            }
        }
    }

    private boolean check(String s){
        int num = Integer.valueOf(s);
        return num <= 255 && num >= 0;
    }
}

验证一个字符串是不是ipv4

  public static boolean func(String str) {
        if(str == null || str.length() == 0) {
            return false;
        }
        String[] strs = str.split("\\.");
        if(strs.length != 4) {
            return false;
        }
        for(String s : strs) {
            if(s.length() == 0 || s.length() > 3) {
                return false;
            }
            for(int i = 0; i < s.length(); i++) {
                if(!Character.isDigit(s.charAt(i))) {
                    return false;
                }
            }
            int num = Integer.valueOf(s);
            if(num < 0 || num > 255) {
                return false;
            }
            if(String.valueOf(num).length() < s.length()) {
                return false;
            }
        }
        return true;
    }

验证ip地址

import java.util.*;
public class Solution {
    public String solve (String IP) {
        String ip = IP.toLowerCase();
        //-1的作用，保存空值
        String[] ipv4 = ip.split("\\.",-1);
        //判断它的长度
        if(ipv4.length == 4){
            return checkIPV4(ipv4);
        }
         
        String[] ipv6 = ip.split(":",-1);
        if(ipv6.length == 8){
            return checkIPV6(ipv6);
        }
        return "Neither";
    }
     
    public String checkIPV4(String[] ip){
       for(String s:ip){
           int n = s.length();
           //判断长度
           if(n == 0|| n > 3){
               return "Neither";
           }
           for(int i = 0;i < n; i++){
               if(!Character.isDigit(s.charAt(i))){
                   return "Neither";
               }
           }
           //检查范围,这个的地方可以把前面有0的转化成前面没0
           int num = Integer.valueOf(s);
           if(num < 0 || num > 255){
               return "Neither";
           }
           //检查第一位有没有0
           if(String.valueOf(num).length() < n){
               return "Neither";
           }
            
       }
        return "IPv4";
    }
     
    public String checkIPV6(String[] ip){
        for(String s:ip){
            int n = s.length();
            //判断每位的长度，没有或者大于4位不满足
            if(n == 0|| n > 4){
                return "Neither";
            }
            for(int i = 0; i < n; i++){
                char c = s.charAt(i);
                //判断16进制
                if((c >= '0' && c <= '9') || (c >= 'a'&& c <= 'f')){
                    continue;
                }
                return "Neither";
            }
             
        }
        return "IPv6";
    }
}

把字符串转换为整数

import java.util.*;
public class Solution {
    public int StrToInt (String str) {
        // write code here
        //先去空格再判空，不然" "教您做人，血的教训
        str = str.trim();
        if(str.length() == 0){
            return 0;
        }
        //然后我想啊，下面要判断首位了
        //首位合格的无非就'+'或'-'或数字三种情况，其他的一概滚蛋
        //'+''-'肯定是要把它去掉的，这样三种情况就统一了
        //当然了，'-abc'这种有可能出现，不过只看首位它是没毛病的
        //让它进来，反正后面很容易解决
        //既然要去掉正负号，那肯定要出个boolean记一下是不是负数
        boolean isMinus = false;
        char[] ch = str.toCharArray();
        //首位是不是正负号或者数字啊
        if(ch[0] == '+' || ch[0] == '-' || Character.isDigit(ch[0])){
        	//是不是正负号啊
            if(ch[0] == '+' || ch[0] == '-'){
            	//是不是负号啊
                if(ch[0] == '-'){
                    isMinus = true;
                }
                //删除首位
                ch = Arrays.copyOfRange(ch,1,ch.length);
            }
            //首位搞定了就看后面是不是数字了，直到不是数字的地方或者倒底结束
            int index = 0;
            //结果可能超int范围，拿个long接一下
            //'-abc'这种情况返回的也是0，舒服，一箭双雕
            long res = 0;
            //短路与助您远离空指针喔，铁汁们，先后顺序关注一下
            while(index < ch.length && Character.isDigit(ch[index])){
                //一位一位往上算
                res *= 10;
                res += ch[index] - '0';
                //及时止损，一看到res超int范围立马return
                //你要是想着最后一起算，那肯定会有超long范围的测试用例等着你，你就哭去吧
                if(res > Integer.MAX_VALUE){
                    //正负号看是正数负数，返回最大值
                    return isMinus ? Integer.MIN_VALUE : Integer.MAX_VALUE;
                }
                //别忘了往后走一位
                index++;
            }
            //long转int就是这么朴实无华
            return isMinus ? -(int)res : (int)res;
        }
        //兄弟首位都不对想啥呢，回去吧您
        return 0;
    }
}

编辑距离（二）

import java.util.*;


public class Solution {
     public int min(int a,int b){
        return a<b ? a:b;
    }
    public int minEditCost (String str1, String str2, int ic, int dc, int rc) {
        // write code here
        int[][] dp = new int[str1.length()+1][str2.length()+1];
        //str1为空 ，变成str2 是插入操作
        for(int i=0;i<dp[0].length;i++){
            dp[0][i]=i*ic;
        }
        //str1非空 str2为空 是删除操作
        for(int j=0;j<dp.length;j++){
            dp[j][0]=j*dc;
        }
        for(int i=1;i<dp.length;i++){
            for(int j=1;j<dp[0].length;j++){
                if(str1.charAt(i-1)==str2.charAt(j-1)){//当前元素匹配 
                    dp[i][j]=dp[i-1][j-1];
                }else{//当前元素不匹配
                    //dp[i-1][j-1]+rc  在str1[0，i-1] 与str2[0,j-1]匹配的情况下需要替换，说明str1[i]需要
                    //dp[i-1][j]+dc   str1[0，i-1] 与str2[0,j]匹配的情况下需要删除，说明str1[i]多余了
                    //dp[i][j-1]+ic   str1[0，i] 与str2[0,j-1]匹配的情况下需要增加，说明str[i]之后还得补一个元素。
                    dp[i][j]=min(dp[i-1][j-1]+rc,min(dp[i-1][j]+dc,dp[i][j-1]+ic ));
                }
            }
        }
        return dp[str1.length()][str2.length()];
    }
}

最长括号子串

import java.util.*;
public class Solution {
    public int longestValidParentheses (String s) {
        // write code here
        if (s == null || s.length() < 2) {
            return 0;
        }
        int[] f = new int[s.length()];
        if (s.charAt(0) == '(' && s.charAt(1) == ')') {
            f[1] = 2;
        }
        int ret = Math.max(f[1], 0);
        for (int i = 2; i < s.length(); i++) {
            if (s.charAt(i) == ')') {
                if (s.charAt(i - 1) == '(') {
                    f[i] = 2 + f[i - 2];
                } else {
                    int index = i - f[i - 1] - 1;
                    if (index >= 0 && s.charAt(index) == '(') {
                        f[i] = 2 + f[i - 1];
                        if (index - 1 >= 0) {
                            f[i] += f[index - 1];
                    }
                }
            }
        }
        ret = Math.max(ret, f[i]);
    }
    return ret;
    }
}

表达式求值

import java.util.*;


public class Solution {
    public int solve (String s) {
        // write code here
        if(s == null) return 0;
        Stack<Integer> numStack= new Stack<>();
        Stack<Character> opStack= new Stack<>();
        for(int i=0;i<s.length();i++){
            //处理数字栈
            if(s.charAt(i)>='0'&&s.charAt(i)<='9'){
                if(i==0){
                    numStack.add(s.charAt(i)-'0');
                }else{
                    if(s.charAt(i-1)>='0'&&s.charAt(i)<='9'){
                        int tmp=numStack.pop();
                        int num=tmp*10+(s.charAt(i)-'0');
                        numStack.add(num);
                    }else{
                        numStack.add(s.charAt(i)-'0');
                    }
                }
            }else{
                //处理符号栈
                if(opStack.isEmpty()){
                    opStack.add(s.charAt(i));
                }else{
                    if(s.charAt(i) == '('){
                        opStack.push(s.charAt(i));
                    }else if(s.charAt(i) == ')'){
                        while(opStack.peek() != '('){
                            cal(numStack, opStack.pop());
                        }
                        opStack.pop();
                    }else if(s.charAt(i) == '*'){
                        if(opStack.peek() == '*'){
                             cal(numStack, opStack.pop());
                        }
                        opStack.push(s.charAt(i));
                    }else if(s.charAt(i) == '+' || s.charAt(i) == '-'){
                        if(opStack.peek() != '('){
                            cal(numStack, opStack.pop());
                        }
                        opStack.push(s.charAt(i));
                    }
                }
            }
        }
        while(!opStack.isEmpty()){
            cal(numStack,opStack.pop());
        }
        return numStack.pop();
    }
    public void cal(Stack<Integer> stackInt, char ope){
        int x = stackInt.pop();
        int y = stackInt.pop();
        if(ope == '*'){
            stackInt.push(x * y);
        }else if(ope == '+'){
            stackInt.push(x + y);
        }else if(ope == '-'){
            stackInt.push(y - x);
        }
    }
}

字符串中的topk问题

在这里插入图片描述

https://www.nowcoder.com/practice/fd711bdfa0e840b381d7e1b82183b3ee?tpId=196&&tqId=37142&rp=1&ru=/ta/job-code-total&qru=/ta/job-code-total/question-ranking
map.merge()方法

  • 如果value不为空，进行merge处理。为空直接赋值newValue。实际上就是一个put操作。然后将key对应的oldValue和newValue 根据传来的function进行处理。
  • 2 当处理后的value值为空，map会移除当前key
import java.util.*;
public class Solution {
    public String[][] topKstrings (String[] strings, int k) {
        // write code here
        HashMap<String, Integer> map = new HashMap<>();
        for (String string : strings) {
            map.merge(string, 1, Integer::sum);
        }
        Set<String> set = map.keySet();
        List<String> str = new ArrayList<>(set);
        str.sort((s1, s2) -> map.get(s1).equals(map.get(s2)) ? s1.compareTo(s2) : map.get(s2) - map.get(s1));
        String[][] ret = new String[k][2];
        for (int i = 0; i < k; i++) {
            ret[i] = new String[]{str.get(i), String.valueOf(map.get(str.get(i)))};
        }
        return ret;
    }
}

删除驼峰字符串

给定一个驼峰样式的字符串例如“AaABbBcBbcvQv…”->“bc”，两个一样的字符夹着一个不一样的字符， 处理这个字符串去掉所有的驼峰。

  public static String func(String s){
        StringBuilder ret = new StringBuilder();
        char pre;
        LinkedList<Character> list = new LinkedList<>();
        list.add(s.charAt(0));
        list.add(s.charAt(1));
        int k = 2;
        for(int i = 2; i < s.length(); i++){
            pre = s.charAt(i - 2);
            if(s.charAt(i) != pre){
                list.add(s.charAt(i));
                k++;
            }else{
                if(k > 2){
                    k = 2;
                }
                while(k > 0){
                    list.remove(list.size() - 1);
                    k--;
                }
            }
        }
        for(int i = 0;i < list.size(); i++){
            ret.append(list.get(i));
        }
        return ret.toString();
    }
    public static void main(String args[]){
        String s = "AaABbBcBbcvQvaaaaaaaaaaaaaa";
        System.out.print(func(s));
    }

字符串压缩

https://leetcode-cn.com/problems/compress-string-lcci/

class Solution {
    public String compressString(String S) {
        if(S == null) {
            return "";
        }
        int i = 0;
        int j = 0;
        int n = S.length();
        StringBuilder ret = new StringBuilder();
        while (i < n) {
            while (j < n && S.charAt(i) == S.charAt(j)) {
                j++;
            }
                
            ret.append(S.charAt(i));
            if((j - i) == 1) {
                ret.append(1);
            }else{
                ret.append(j - i);
            }  
            i = j;
        }
        String ans = ret.toString();
        if(ans.length() >= S.length()) {
            return S;
        }else {
            return ans;
        }
    }
}

字符的大小写转换

    public static boolean isUpper(char ch) {
        if(ch >= 'A' && ch <= 'Z') {
            return true;
        }else {
            return false;
        }
    }
    public static boolean isLower(char ch) {
        if(ch >= 'a' && ch <= 'z') {
            return true;
        }else {
            return false;
        }
    }
    public static char toUpper(char ch) {
        return (char) (ch - 32);
    }
    public static char toLower(char ch) {
        return (char) (ch + 32);
    }
赵jc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
面试题： 大数相加
w575822446的专栏
05-23 755
/*思想是新建两个字符串指针分别指向两串字符串的末尾数据，然后开始往前加*/ 直接上程序： /*大数相加*/ #include #include #include void add(char a[],char b[]) { int len_a = strlen(a); int len_b = strlen(b); char* p = a + len_a - 1; char*
大数相加 面试题
FIGHTING!!!
06-14 469
最近在准备面试，所以做了一些公司的面试题，看到一个大数相加的题目，感觉挺有意思，就实现一下： 不说废话，直接看代码： #include #define N 20 using namespace std; void AddBig(char a[],char b[],char c[]); void main() { char a[N] = "90999
算法面试题 大数相加
橘导的博客
10-17 396
大数相加运用了很多运算符的知识 function addBig(a, b){ let temp = 0, res = ''; a = a.split(''); b = b.split(''); while( a.length || b.length || temp){ temp += ~~a.pop() + ~~b.pop();...
面试算法题(2)--两个大数相加
热门推荐
阿杜
07-07 4万+
两大大数相加听说这是个频繁出现的算法题，在某某网站是的排行很靠前。在找工作之前，同事提过一次，我没当回事，恰恰在我第一家面试时就碰到了。两个大数相加。1、是整数；2、两个数无限大，long都装不下；3、不能用BigInteger；4、不能用任何包装类提供的运算方法；5、两个数都是以字符串的方式提供。两个字符串的数字，怎么相加？其实也简单，核心点考的是ASCII码和相加进位的问题。比喻字符类型的'9...
**面试题：两个超大数相加**
java小小白
12-28 891
面试中经常会碰到两个超大数相加 是整数； 两个数无限大，long都装不下； 不能用BigInteger； 不能用任何包装类提供的运算方法； 两个数都是以字符串的方式提供; 不能用任何包装类提供的运算方法； 思路： 1、首先把字符串转换成字符数组 2、两个字符数组分别从后往前逐个字符遍历 3、每次遍历将结果放在一个新建的数组中 4、将数组转成字符串并返回 public static void ...
C语言基础面试题（03-字符串函数）.docx
11-21
以上解答了C语言中涉及字符串处理的一些基础面试题，实际编程中，我们需要考虑到边界条件、效率优化和错误处理等因素，确保代码的健壮性和正确性。在面试中，理解这些基本概念并能灵活运用是至关重要的。
大数相加 java
10-07
2. **反转字符串**：在处理大数相加时，通常先将输入的数字字符串反转，这样可以按照常规的数学运算顺序（从个位开始逐位相加）进行计算。 3. **逐位相加**：遍历两个反转后的数字字符串，对于每一位，执行以下操作...
python面试题245题（附答案）.docx
最新发布
06-12
26. **大数相加**：使用字符串操作或`int()`转换后相加再转换回字符串。 27. **变量作用域**：Python有局部作用域、全局作用域和嵌套作用域。`global`关键字用于声明全局变量。 28. **字符串转数字**：可以使用...
前端大厂最新面试题-bigNumberSum.docx
06-06
这个解决方案巧妙地利用了字符串处理和简单的数学逻辑，有效地解决了大数相加的问题。 在实际面试中，面试官可能还会询问关于其他数据结构（如数组、栈）的解决方案，或者要求优化性能，比如减少内存消耗、提高计算...
中级程序员必备面试题.txt
03-21
### 中级程序员必备面试题解析 #### 如何创建一个有序集合 有序集合通常是通过`TreeSet`或`LinkedHashSet`等类实现。`TreeSet`基于红黑树存储元素，可以保证元素的自然排序；而`LinkedHashSet`则是基于哈希表与...
offer收割机：两个长字符串数字相加求和(经典面试算法题)
Fristm的博客
07-06 612
在面试中,为了缓解面试的尴尬,有些面试会然你写一写简单算法题来缓解气氛比如冒泡啊简单的算法题,今天给大家带了一道我遇到的一道算法题分享给他就,思路都写在对应代码的注释上,不懂可以看一下,有什么写的不对的大家可以指出来上代码 这是主要思路是通过反转来求和...
常考算法面试题：字符串(大数)相加、字符串(大数)相减、字符串(大数)相乘，解题方法总结
Quan的博客
03-20 1556
常考算法面试题：字符串相加、字符串相减、字符串相乘 笔者今年秋招，最近投了一些大厂的实习，某为的手撕代码题目为 字符串相乘，某讯的手撕代码题目为字符串相减。 于是去LeetCode和网上搜索了一下，发现这类题目是面试的常考题。只要会四则运算这道题的思路就很清晰，主要字符串的处理，难点也在于字符串处理。 以下代码本人均在GCC编译器下运行过，没有问题。自己写上主函数、输入、调用算法函数即可编译运行验证，或者去leetCode找到原题直接粘贴上去。 1、字符串相加 LeetCode上的字符串相加题目如下所示：
剑指offer之面试题12 大数相加 实现任意两个整数的加法
Cinderella_hou的博客
06-20 1万+
剑指offer面试题12  打印从1到最大的n位10进制数 。陷阱在于  当输入的n很大时，不管用int 或 long long 都会溢出。这个代码 剑指offer源码上已经给出。于此相关的题目是  定义一个函数，实现任意两个整数的加法，因为没有限定两个数的大小范围，所以也要当做大数问题处理，既用字符串表示。 代码如下：void BigNumberPlus(char * number1,cha
面试常见题目：大数相加的Java实现（考虑负数情况）
yufem的博客
04-09 6328
前言：在做面试题目时，我们经常看到有这样的题目：将两个很大的数相加，超过100位。 网上可以看到很多答案，但是这些答案大部分都是没有考虑负数的情况。 首先我们已经不能直接用log类型进行表示了。一般输入是两个字符串。最后输出也得是一个字符串。思路：对于字符串是无法相加的，那就必须转换成整形数组。然后一位一位的相加。 当然我们得考虑进位的情况。ok,那么负数怎么解决的，这。里想到了计算机组成里面
一道经典面试题--大数相加
田维常
10-31 595
思路：1、取得两个字符串的长度2、把两个的长度做比较，并得出较长的长度，及较短的长度3、把长度较短的加数字符串，在左面补0，使之与较长的字符串一样长4、从最高位，一...
Leetcode 203.移除链表中的元素
qq_45661125的博客
01-01 3158
链表的题我们如果没思路的话画图就完事了。链表中我们需要关注三个主要的位置，头，尾，和中任意位置 下面我们来画图解释一下。 我们可以使用双指针来解决这个问题，cur代表当前节点（从head.next开始），prev代表当前节点的前驱（prev=head），（我们先不考虑第一个节点）我们让cur一直往下走，每走一次判断一下当前cur.val是否等于传参传入的value。如果相等的令prev.next=cur.next;（就相当于删除了这个值相等的节点），然后接着走（cur=cur.next），如果不想的.
手把手带你刷剑指offer
qq_45661125的博客
04-23 855
剑指offer题解二维数组中查找一级目录一级目录一级目录一级目录二级目录三级目录 根据牛客的顺序来刷的，附上链接：https://www.nowcoder.com/ta/coding-interviews 二维数组中查找 核心思路：二分 public class Solution { public boolean Find(int target, int [][] array) { if(array == null || array.length == 0 ) {
数组常见面试题
qq_45661125的博客
09-24 805
数组中数字出现的次数数组中出现次数超过一半的数字数组中有些元素出现两次而其他元素出现一次。找到所有出现两次的元素。数组中两个数字之外，其他数字都出现了两次。请写程序找出这两个只出现一次的数字在一个数组 nums 中除一个数字只出现一次之外，其他数字都出现了三次。请找出那个只出现一次的数字。 数组中出现次数超过一半的数字 https://leetcode-cn.com/problems/shu-zu-zhong-chu-xian-ci-shu-chao-guo-yi-ban-de-shu-zi-lcof/ c
树Tree相关面试题
qq_45661125的博客
04-23 379
Tree二叉树的最大深度平衡二叉树翻转一棵二叉树。二叉树中和为某一指的路径（回溯）重构二叉树一级目录一级目录一级目录一级目录一级目录一级目录二级目录三级目录 二叉树的最大深度 题目：输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。 例如：给定二叉树 **[3,9,20,null,null,15,7]， 示例： 3 / \ 9 20 / \ 15 7 返回它的最大深度 3 代码：
Java面试必备：264道经典就业题解析
6. switch语句不能作用于byte、long，但Java 7以后可以作用于枚举类型，Java 14以后可以作用于字符串(String)。 7. 对于short s1 = 1; s1 = s1 + 1;，会因为int与short相加结果为int，需要强制类型转换。而s1 += 1;...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值