哔哩哔哩笔试题目

0 有效的括号

class Solution {
    public boolean isValid(String s){
        Stack<Character> stack = new Stack<Character>();
        for(char c : s.toCharArray()){
            if(c == '(')
                stack.push(')');
            else if(c == '[')
                stack.push(']');
            else if(c == '{')
                stack.push('}');
            else if(stack.isEmpty() || c != stack.pop())
                return false;
        }
        return stack.isEmpty();
    }
}

1 两个扭蛋机

import java.util.Scanner;

/*思路：正向向上加到 N，比较难办到；但是倒着想，就好办多了；

首先肯定是优先3号机，N减小得快；*/
public class Main {
	static void help(int n, StringBuffer buffer) {
		if (n<=0) {
			return;
		}
		if (n%2==0) {
			buffer.append('3');
			help((n-2)/2, buffer);
		}else {
			buffer.append('2');
			help((n-1)/2, buffer);
		}
	}
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		StringBuffer buffer = new StringBuffer();
		int n;
		n = scanner.nextInt();
		help(n, buffer);
		System.out.println(new String(buffer.reverse()));
	}
}

2 求第k个仅出现一次的字符

#include <iostream>
#include <string>
#include <list>
#include <unordered_map>
using namespace std;

int main(){
    int k;
    string s;
    while(scanf("%d", &k) != EOF){
        int count = 0;
        string s;
        getchar();
        getline(cin, s);
        unordered_map<char, int> hash;
        list<char> ch;
        for(int i = 0; i < s.size(); i++){
            hash[s[i]]++;
            ch.push_back(s[i]);
        }
        //去掉重复元素（从后向左）
        ch.unique();
        for(auto it = ch.begin(); it != ch.end(); it++){
            if(hash[*it] == 1)
                count++;
            if(count == k){
                cout<<"["<<*it<<"]"<<endl;
                break;
            }
        }
        if(count != k)
            cout<<"Myon~"<<endl;
    }
    return 0;
}

3 基本计算器II（leetcod227、772）

实现一个基本的计算器来计算一个简单的字符串表达式的值。字符串表达式仅包含非负整数，+， - ，*，/ 四种运算符和空格 。 整数除法仅保留整数部分。

import java.util.LinkedList;
import java.util.Stack;

 public class Solution{
 public int calculate(String exp) {
		return calRst(backTempExp(exp));
	}
// 计算后缀表达式
	public static LinkedList<String> backTempExp(String exp) {

		Stack<String> stkEles = new Stack<String>();
		LinkedList<String> tempBackExp = new LinkedList<String>();
		for (int i = 0; i < exp.length(); i++) {
			// 1.遇到了数字
			if (Character.isDigit(exp.charAt(i))) {
				// 注意多位数的获取
				int k = i + 1;
				for (; k < exp.length() && Character.isDigit(exp.charAt(k)); k++) {

				}
				tempBackExp.add(exp.substring(i, k));
				i = k - 1;// 更新 i
				continue;
			}
			// 2.遇到了乘除运算符
			if (exp.charAt(i) == '/' || exp.charAt(i) == '*') {

				while (!stkEles.isEmpty() && (stkEles.lastElement().equals("/") || stkEles.lastElement().equals("*"))) {
					tempBackExp.add(stkEles.pop()); // 弹出优先级相同或以上的栈内运算符
				}
				stkEles.add(String.valueOf(exp.charAt(i))); // 运算符入栈
				continue;
			}
			// 3.遇到了加减运算符
			if (exp.charAt(i) == '+' || exp.charAt(i) == '-') {
				while (!stkEles.isEmpty() && !isNumeric(stkEles.lastElement())) {
					tempBackExp.add(stkEles.pop()); // 弹出优先级相同或以上的栈内运算符
				}
				stkEles.add(String.valueOf(exp.charAt(i))); // 运算符入栈
				continue;
			}
		}
		// 4.最后弹出栈内所有元素到表达式
		while (stkEles.size() > 0) {
			tempBackExp.add(stkEles.pop());
		}
		return tempBackExp;
	}

	// 计算最终的结果
	public static int calRst(LinkedList<String> tempBackExp) {
		Stack<Integer> calStk = new Stack<Integer>();
		for (String c : tempBackExp) {
			// 1.数字，入栈
			if (isNumeric(c)) {
				calStk.push(Integer.valueOf(c)); // string to int
				continue;
			}
			// 2.非数字，则为符号，出栈两个元素计算出结果然后再入栈该计算值
			else {
				int a = calStk.pop();
				int b = calStk.pop();
				switch (c.toCharArray()[0]) {
				// 注意减法和除法时，注意出栈的顺序与原表达式是相反的

				case '+':
					calStk.push(b + a);
					continue;
				case '-':
					calStk.push(b - a);
					continue;
				case '*':
					calStk.push(b * a);
					continue;
				case '/':
					calStk.push(b / a);
					continue;
				}
			}
		}
		return calStk.pop();
	}

	public static boolean isNumeric(String str) {
		for (int i = 0; i < str.length(); i++) {
			if (!Character.isDigit(str.charAt(i))) {
				return false;
			}
		}
		return true;
	}
	
}

另一种：只有+-*三种运算符

#include <iostream>
#include <vector>
using namespace std;

int main(){
    
    string s;
    cin>>s;
    while(s != "END"){
        // 存每个数
        vector<string> numbers;
        // 存操作符
        vector<char> operate;
        // 先解决乘除法
        for(int i = 0; i < s.size(); i++){
            // 是数字
            if(s[i] >= '0' && s[i] <= '9'){
                // 存储一个数字
                string nowN;
                nowN += s[i];
                i++;
                for(; i < s.size(); i++){
                    if(s[i] >= '0' && s[i] <= '9')
                        nowN += s[i];
                    else{
                        i--;
                        break;
                    }
                }
                numbers.push_back(nowN);
            }
            // 乘号
            else if(s[i] == '*'){
                // 找到下一个数
                string nowN;
                i++;
                for(; i < s.size(); i++){
                    if(s[i] >= '0' && s[i] <= '9')
                        nowN += s[i];
                    else{
                        i--;
                        break;
                    }
                }
                // 转换为整数
                int nowInt = std::stoi(nowN);
                int lastInt = std::stoi(numbers[numbers.size() - 1]);
                numbers.pop_back();
                numbers.push_back(to_string(nowInt * lastInt));
            }
            // 加减号
            else{
                operate.push_back(s[i]);
            }
        }
        // 最后处理
        int ans = std::stoi(numbers[0]);
        // 删除第一个
        numbers.erase(numbers.begin());
        for(int i = 0; i < operate.size(); i++){
            if(operate[i] == '+'){
                ans += std::stoi(numbers[0]);
                // 删除第一个
                numbers.erase(numbers.begin());
            }
            else if(operate[i] == '-'){
                ans -= std::stoi(numbers[0]);
                // 删除第一个
                numbers.erase(numbers.begin());
            }
        }
        printf("%d
", ans);
        cin>>s;
    }
    return 0;
}

4 基本计算器（leetcode224）

class Solution {
public:
    // 可测试3-(4+5)+6
    int calculate(string s) {
        stack<int> st;
        int res = 0;
        int n = s.size(); 
        // 默认表示+
        int sign = 1;
        for(int i = 0; i < n; i++) {
            int num = 0;
            if(s[i] >= '0') {
                while(i < n && s[i] >= '0') {
                    num = num * 10 + (s[i] - '0');
                    i++;
                }
                i--;
                res += sign * num;
            }
            else if(s[i] == '+') sign = 1;
            else if(s[i] == '-') sign = -1;
            else if(s[i] == '(') {
                st.push(res);
                st.push(sign);
                res = 0;
                sign = 1;
            }
            else if(s[i] == ')') {
                res *= st.top(); 
                st.pop();
                res += st.top(); 
                st.pop();
            }
        }
        return res;
    }
};

5 新认识的人（深度优先搜索DFS）

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 8;
vector<int> G[maxn];
int res = 0;

//深度遍历 找到一个集合的人
void dfs(int ai, vector<bool> &v) {
	for (int i = 0; i < G[ai].size(); ++i) {
		if (!v[G[ai][i]]) {
            v[G[ai][i]] = true;
			res++;
			dfs(G[ai][i], v);
		}	
	}
}

int main() {
	int n, ai, m;
	cin >> n >> ai >> m;
    //构建邻接表
	while (m--) {
		int p1, p2;
		char chs;
		cin >> p1 >> chs >> p2;
		G[p1].push_back(p2);
		G[p2].push_back(p1);
	}
	vector<bool> visited(n + 1, false);
    //除去本来就认识的人和自己
	int already = G[ai].size() + 1;
	dfs(ai,visited);

	cout << res - already << endl;

	return 0;
}

6 数组中3数之和为某个数

#include <bits/stdc++.h>
using namespace std;

int main(){
    int n,x;
    vector<int> v;
    while(cin>>x){
        v.push_back(x);
        if(getchar()==',')
            break;
    }
    cin>>n;
    sort(v.begin(), v.end());
    int m = v.size(), l, r;
    for(int i = 1;i <= m - 2; i++){
        l = 0;
        r = m - 1;
        while(l < i && r > i){
            if(v[l]+v[r]+v[i] == n){
                cout<<"True"<<endl;
                return 0;
            }else if(v[l]+v[r]+v[i] < n)
                l++;
            else
                r--;
        }
    }
    cout<<"False"<<endl;
    return 0;
}

7 酒杯

#include <bits/stdc++.h>
using namespace std;

int main(){
    int n, k;
    scanf("%d", &n);
    vector<int> ans(n, 0);
    for(int i = 0 ; i < n; i++)
        scanf("%d", &ans[i]);
    scanf("%d", &k);
    sort(ans.begin(), ans.end());
    int left = 0;
    int right = n - 1;
    bool flag = true;
    while(left < right){
        if(ans[left] + ans[right] == k){
            cout<<ans[left]<<" "<<ans[right]<<endl;
            left++;
            //right--;
            flag = false;
        }
        else if(ans[left] + ans[right] > k)
            right--;
        else
            left++;
    }
    if(flag)
        printf("NO
");
    return 0;
}

8 LeetCode【1004】最大连续1的个数 III

public static int longestOnes(int[] A, int K) {
	int left = 0, right = 0;
    int max = 0;
    int zero = 0;
    while (right != A.length) {
    	if (A[right++] == 0) {
        	zero++;
        }
        //判定条件，0的个数大于K
        while (zero > K) {
            if (A[left++] == 0) {
                --zero;
            }
        }
        int count = right - left;
        max = max > count ? max : count;
    }
    return max;
}