java算法题2
java算法题2
1.【15分】 标题：字符逆序 | 时间限制：1秒 | 内存限制：32768K
将一个字符串str的内容颠倒过来，并输出。str的长度不超过100个字符。 如：输入“I am a student”，输出“tneduts a ma I”。
输入参数：
inputString：输入的字符串
返回值：
输出转换好的逆序字符串
输入描述:
输入一个字符串，可以有空格
输出描述:
输出逆序的字符串
示例1
输入
I am a student
输出
tneduts a ma I
/**
* 反转字符串
* @param str string字符串
* @return string字符串
*/
public String solve (String str) {
char[] a = str.toCharArray();
for (int i = 0, j = str.length()-1; j >= i; j--, i++ ) {
char c = a[i];
a[i] = a[j];
a[j] = c;
}
//return ""+ new StringBuffer(str).reverse();
return String.valueOf(a);
}
/**
*翻转数字-321 -》 -123
* @param x int整型
* @return int整型
*/
public int reverse (int x) {
String bb = new StringBuffer(Math.abs(x)+"").reverse().toString();
try{
return x>0? Integer.parseInt(bb): 0-Integer.parseInt(bb);
}catch(Exception o){
return 0;
}
}
public static void main(String[] args) throws IOException{
BufferedReader b= new BufferedReader(new InputStreamReader(System.in));
String br =null;
while((br = b.readLine()) != null){
//System.out.println(new StringBuffer(br).reverse().toString()); //8ms
char[] ss =br.toCharArray();
StringBuffer sb= new StringBuffer();
for(int i= ss.length-1;i>=0;i--){
sb.append(ss[i]);
}
System.out.println(sb.toString());//9ms
}
}
2.【15分】 标题：字符串替换 | 时间限制：3秒 | 内存限制：32768K
请你实现一个简单的字符串替换函数。原串中需要替换的占位符为"%s",请按照参数列表的顺序一一替换占位符。若参数列表的字符数大于占位符个数。则将剩下的参数字符添加到字符串的结尾。
给定一个字符串A，同时给定它的长度n及参数字符数组arg，请返回替换后的字符串。保证参数个数大于等于占位符个数。保证原串由大小写英文字母组成，同时长度小于等于500。
测试样例：
"A%sC%sE",7,['B','D','F']
返回："ABCDEF"
public String formatString(String A, int n, char[] arg, int m) {
char[] s0 = A.toCharArray();
//if( A.length()> 500 || s0.length < m+1) return ""+s0.length;
StringBuilder sb = new StringBuilder();
int c=0;
for(int i=0;i<s0.length;i++){
if((i+1)< s0.length && s0[i] == '%' && s0[i+1] == 's'){
sb.append(arg[c]);
c++;
++i;
}else sb.append(s0[i]);
}
for(;c<arg.length;c++){
sb.append(arg[c]);
}
return sb.toString();
}
【15分】 标题：删除公共字符 | 时间限制：1秒 | 内存限制：32768K
输入两个字符串，从第一字符串中删除第二个字符串中所有的字符。例如，输入”They are students.”和”aeiou”，则删除之后的第一个字符串变成”Thy r stdnts.”
输入描述:
每个测试输入包含2个字符串
输出描述:
输出删除后的字符串
示例1
输入
They are students.
aeiou
输出
Thy r stdnts.
public static void main(String[] args) throws IOException{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String s = null;
while((s = br.readLine()) != null){
//char[] s0= br.readLine().toCharArray();
String s0= br.readLine();
char[] s1 =s.toCharArray();
//StringBuilder sb =new StringBuilder();
for(int i=0;i<s1.length;i++){
if(!s0.contains(String.valueOf(s1[i]))){
System.out.print(s1[i]);
}
}
System.out.println();
}
}
6.【15分】 标题：字符串的旋转 | 时间限制：3秒 | 内存限制：32768K
对于一个字符串，和字符串中的某一位置，请设计一个算法，将包括i位置在内的左侧部分移动到右边，将右侧部分移动到左边。
给定字符串A和它的长度n以及特定位置p，请返回旋转后的结果。
测试样例：
"ABCDEFGH",8,4
返回："FGHABCDE"
import java.util.*;
public class StringRotation {
public String rotateString(String A, int n, int p) {
if(p==n-1){
return A;
}else{
return A.substring(p+1,n)+A.substring(0,p+1);
}
}
}
7.【15分】 标题：字符集合 | 时间限制：1秒 | 内存限制：32768K
输入一个字符串，求出该字符串包含的字符集合
输入描述:
每组数据输入一个字符串，字符串最大长度为100，且只包含字母，不可能为空串，区分大小写。
输出描述:
每组数据一行，按字符串原有的字符顺序，输出字符集合，即重复出现并靠后的字母不输出。
示例1
输入
abcqweracb
输出
abcqwer
public static String singleChar(String string){
int[] chars = new int[256];
StringBuffer stringBuffer = new StringBuffer();
for (int i = 0; i < string.length(); i++){
if (chars[string.charAt(i)] == 0){
stringBuffer.append(string.charAt(i));
}
chars[string.charAt(i)]++;
}
return stringBuffer.toString();
}
【返回最长回文子串的长度】
import java.io.*;
public class Main{
public static void main(String[] args)throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = br.readLine();
// while((str = br.readLine()) != null){
int max = 0;
int len = str.length();
for(int i = 0; i < len; i++){
int l = i - 1;
int r = i;
while(l >= 0 && r < len && str.charAt(l) == str.charAt(r)){
if(r - l + 1 > max){
max = r - l + 1;
}
l--;
r++;
}
l = i - 1;
r = i + 1;
while(l >= 0 && r < len && str.charAt(l) == str.charAt(r)){
if(r - l + 1 > max){
max = r - l + 1;
}
l--;
r++;
}
}
System.out.println(max);
// }
}
}
#### 【给定两个只包含小写字母的字符串，计算两个字符串的最大公共子串的长度。
注：子串的定义指一个字符串删掉其部分前缀和后缀（也可以不删）后形成的字符串。】
```java
import java.io.*;
public class Main{
public static void main(String[] args)throws Exception{
BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
String str1 = "";
String str2 = "";
while((str1 = bf.readLine())!= null && (str2 = bf.readLine())!= null){
int max = 0;
char[] cha1 = str1.toCharArray();
char[] cha2 = str2.toCharArray();
for(int i = 0; i < str1.length(); i++){
for(int j = 0; j < str2.length(); j++){
int t1 = i;
int t2 = j;
int count = 0;
while(cha1[t1] == cha2[t2]){
t1++;
t2++;
count++;
max = Math.max(count,max);
if(t1 == cha1.length || t2 == cha2.length) break;
}
}
}
System.out.println(max);
}
}
}
8.【15分】 标题：字符串变形 | 时间限制：1秒 | 内存限制：32768K
对于一个给定的字符串，我们需要在线性(也就是O(n))的时间里对它做一些变形。首先这个字符串中包含着一些空格，就像"Hello World"一样，然后我们要做的是把着个字符串中由空格隔开的单词反序，同时反转每个字符的大小写。比如"Hello World"变形后就变成了"wORLD hELLO"。
输入描述:
给定一个字符串s以及它的长度n(1≤n≤500)
输出描述:
请返回变形后的字符串。题目保证给定的字符串均由大小写字母和空格构成。
示例1
输入
"This is a sample",16
输出
"SAMPLE A IS tHIS"
public String trans(String s, int n) {
//if(s.equals(" ")||s.isEmpty()|| s.isBlank() ) return s;
char[] arr = s.toCharArray();
StringBuffer sb=new StringBuffer();
int pos=0;
for(int i=0;i < arr.length;i++){
char temp= arr[i];
if(Character.isLowerCase(temp)) {
sb.insert(pos,Character.toUpperCase(temp));
pos++;
}else if(Character.isUpperCase(temp)) {
sb.insert(pos,Character.toLowerCase(temp));
pos++;
}else if(Character.isWhitespace(temp)){
pos=0;
sb.insert(pos,temp);
};
}
return sb.toString();
}
9.【15分】 标题：寻找第K大 | 时间限制：3秒 | 内存限制：32768K
有一个整数数组，请你根据快速排序的思路，找出数组中第K大的数。
给定一个整数数组a,同时给定它的大小n和要找的K(K在1到n之间)，请返回第K大的数，保证答案存在。
测试样例：
[1,3,5,2,2],5,3
返回：2
public class Solution {
public int findKth(int[] a, int n, int K) {
//....
}
}
10.【15分】 标题：统计大写字母个数 | 时间限制：1秒 | 内存限制：32768K
找出给定字符串中大写字符(即'A'-'Z')的个数
接口说明
原型：int CalcCapital(String str);
返回值：int
注意：测试数据需要考虑循环输入
输入描述:
输入一个String数据
输出描述:
输出string中大写字母的个数
示例1
输入
add123#$%#%#O
输出
1
public static void main(String[] args) throws IOException {
BufferedReader b = new BufferedReader(new InputStreamReader(System.in));
String br=null;
while((br=b.readLine()) != null){
//System.out.println(br.replaceAll("[^A-Z]+","").length()); 13ms
char[] ss=br.toCharArray();
int count=0;
for(int i=0;i<ss.length;i++){
//if(ss[i]>= 'A' && ss[i]<= 'Z') count++; //13ms
if(Character.isUpperCase(ss[i])) count++; //9ms
}
System.out.println(count);
}
}
//一个字符串，为不同字母出现次数的降序表示。若出现次数相同，则按ASCII码的升序输出。【字符统计】
public static void main(String[] args) throws IOException{
BufferedReader b = new BufferedReader(new InputStreamReader(System.in));
String ss=null;
while((ss=b.readLine()) !=null){
char[] s= ss.toCharArray();
int[] asc= new int[123];
for(int i=0;i<s.length;i++){
asc[s[i]]++;
}
int max =0;
for(int j=0;j<asc.length;j++){
if(max < asc[j]) max = asc[j];
}
StringBuffer sb = new StringBuffer();
while(max != 0){
for(int k=0;k<asc.length;k++){
if(max == asc[k]) sb.append((char)k);
}
max--;
}
System.out.println(sb.toString());
}
}
【字符分割 [123456789 -> 12345678,900000000]】
public static void main(String[] args)throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s = null;
while((s= br.readLine()) != null){
int count = s.length();
StringBuilder sb=new StringBuilder();
int pos=0;
while(count >= 8){
//sb.append(s.substring(pos,pos+8)+"\n");
System.out.println(s.substring(pos,pos+8));
count -= 8;
pos += 8;
}
if(count >0 ) {
//sb.append(s.substring(pos));
//sb.append((Math.round(Math.pow(10,8-count))+"").substring(1));
System.out.print(s.substring(pos));
System.out.println((Math.round(Math.pow(10,8-count))+"").substring(1));
}
}
}
11.【15分】 标题：查找输入整数二进制中1的个数 | 时间限制：1秒 | 内存限制：32768K
请实现如下接口
public static int findNumberOf1( int num)
{
/* 请实现 */
return 0;
} 譬如：输入5 ，5的二进制为101，输出2
涉及知识点：
输入描述:
输入一个整数
输出描述:
计算整数二进制中1的个数
示例1
输入
5
输出
2
public class Solution {
public int NumberOf1(int n) {
int res = 0;
while(n!=0){
res += n&1;
n >>>= 1;
}
return res;
}
public static void main(String[] args) throws IOException{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String b = null;
while((b=br.readLine()) != null){
int count=0,max=0;
int n=Integer.parseInt(b);
while(n != 0){
if((n&1)> 0){
count++;
}else {
max = max < count ?count : max;
count=0;
}
n >>>=1;
}
//count=Integer.toBinaryString(Integer.parseInt(b)).replaceAll("0","").length();
System.out.println(max < count ?count : max);
}
}
}
12.【15分】 标题：字符串中找出连续最长的数字串 | 时间限制：1秒 | 内存限制：32768K
读入一个字符串str，输出字符串str中的连续最长的数字串
输入描述:
个测试输入包含1个测试用例，一个字符串str，长度不超过255。
输出描述:
在一行内输出str中里连续最长的数字串。
示例1
输入
abcd12345ed125ss123456789
输出
123456789
public static void main(String[] args) throws IOException{
BufferedReader b = new BufferedReader(new InputStreamReader(System.in));
String ss=null;
while((ss=b.readLine()) !=null){
String[] s = ss.split("[^0-9]+");
int max = 0;
for(int i=0;i<s.length;i++){
if(s[i].length() ==0 ) continue;
if(max < s[i].length()) max = s[i].length();
}
StringBuilder sb=new StringBuilder();
for(int i=0;i<s.length;i++){
if(max == s[i].length()) sb.append(s[i]);
}
System.out.println(sb +","+ max);
}
}
13.【15分】 标题：找出字符串中第一个只出现一次的字符(题面已经更新) | 时间限制：1秒 | 内存限制：32768K
找出字符串中第一个只出现一次的字符
输入描述:
输入几个非空字符串
输出描述:
输出第一个只出现一次的字符，如果不存在输出-1
示例1
输入
asdfasdfo
aabb
输出
o
-1
public int FirstNotRepeatingChar(String str) {
if(str.length()==1){
return 0;
}
for(int i=0;i<str.length();i++){
if(str.indexOf(str.charAt(i))== str.lastIndexOf(str.charAt(i))){
return i;
}
}
return -1;
}
#### 【找出字符串中第一个只出现一次的字符】
public static void main(String[] args)throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = null;
while ((str = br.readLine()) != null) {
char[] s0 =str.toCharArray();
for(int i=0;i<s0.length;i++){
char c= s0[i];
if(str.indexOf(c)==str.lastIndexOf(c)){
System.out.println(c);
break;
}
if(i == (s0.length-1)) System.out.println(-1);
}
}
}
【数组中只出现一次的数（其它数出现k次）】
public class Solution {
/**排序
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
* @param arr int一维数组
* @param k int
* @return int
*/
public int foundOnceNumber (int[] arr, int k) {
// 每个二进制位求和，如果某个二进制位不能被k整除，那么只出现一次的那个数字在这个二进制位上为1。
int[] binarySum = new int[32];
for(int i = 0; i< 32; i++){//求每个二进制位的和
int sum = 0;
for(int num : arr){
sum += (num >>i & 1);//依次右移num，同1相与，计算每一位上1的个数
}
binarySum[i] = sum;
}
int res = 0;
for (int i = 0; i< 32; i++){
if(binarySum[i]%k!=0){
res += 1<<i;//左移恢复
}
}
return res;
}
}
//位运算
public int foundOnceNumber (int[] arr, int k) {
// 每个二进制位求和，如果某个二进制位不能被k整除，那么只出现一次的那个数字在这个二进制位上为1。
int[] binarySum = new int[32];
for(int i = 0; i< 32; i++){//求每个二进制位的和
int sum = 0;
for(int num : arr){
sum += (num >>i & 1);//依次右移num，同1相与，计算每一位上1的个数
}
binarySum[i] = sum;
}
int res = 0;
for (int i = 0; i< 32; i++){
if(binarySum[i]%k!=0){
res += 1<<i;//左移恢复
}
}
return res;
}
//hashmap
public int foundOnceNumber (int[] arr, int k) {
// write code here
HashMap<Integer, Boolean> map = new HashMap<>();//key存数字，value表示是否出现过
for(int num: arr){
if(map.containsKey(num)){
map.put(num, true);
}else{
map.put(num, false);
}
}
Set<Integer> set = map.keySet();
for(int num : set){
if(map.get(num) == false){
return num;
}
}
return 0;
}
public int foundOnceNumber (int[] arr, int k) {
// write code here
HashMap<Integer, Integer> map = new HashMap<>();//key存数字，value表示是否出现过
for(int num: arr){
if(map.containsKey(num)){
map.put(num, map.get(num)+1);
}else{
map.put(num, 1);
}
}
Set<Integer> set = map.keySet();
for(int num : set){
if(map.get(num) == 1){
return num;
}
}
return 0;
}
14.对于一个字符串，请设计一个高效算法，计算其中最长回文子串的长度。
给定字符串A以及它的长度n，请返回最长回文子串的长度。
输入
"abc1234321ab",12
返回值
7
public int getLongestPalindrome(String A, int n) {
char[] ch = A.toCharArray();
int res = 0;
for(int i = 0; i < n; i++){
int l = i, r = i, sameR = i;
//定位左右两边,避免abba和aba
while(l - 1 >= 0 && ch[l - 1] == ch[i]) l--;
while(r + 1 < n && ch[r + 1] == ch[i]) r++;
sameR = r;
while(l - 1 >= 0 && r + 1 < n && ch[l - 1] == ch[r + 1]){
l--;
r++;
}
res = Math.max(res, r - l + 1);
//优化
i = sameR;
}
return res;
}
15.给定一个数组arr，返回arr的最长无的重复子串的长度(无重复指的是所有数字都不相同)。
示例1
输入
[2,3,4,5]
返回值
4
/**
* @param arr int整型一维数组 the array
* @return int整型
*/
public int maxLength (int[] arr) {
// write code here
//int[] lastPos = new int[100000];
int len = arr.length;
int[] lastPos = new int[len];
int start = 0;
int res = 0;
for(int i =0;i<len;i++){
int now = arr[i];
start = Math.max(start,lastPos[now]);
res = Math.max(res,i-start+1);
lastPos[now] = i+1;
}
return res;
}
16.大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。
public int Fibonacci(int n) {
if(n==0){
return 0;
}else if(n==1 || n==2){
return 1;
}else if(n==3){
return 2;
}
int f2 =1,sum=2;
while(n>3){
int temp=sum;
sum =f2 + sum;
f2=temp;
n--;
}
return sum;
}
17.请实现有重复数字的升序数组的二分查找
给定一个 元素有序的（升序）整型数组 nums 和一个目标值 target ，
写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1
[1,2,4,4,5],4
返回值
2
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
* 如果目标值存在返回下标，否则返回 -1
* @param nums int整型一维数组
* @param target int整型
* @return int整型
*/
public int search (int[] nums, int target) {
if(nums==null||nums.length==0) return -1;
int first = 0;
int last = nums.length-1;
while(first<last){
int middle = (first +last)/2;
if(nums[middle]>target){
last = middle-1;
}else if(nums[middle]<target){
first=middle+1;
}else{
last=middle;
}
}
if(nums[first]==target) return first;
return -1;
}
18.数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。
由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
示例1
输入
[1,2,3,2,2,2,5,4,2]
返回值
2
public int MoreThanHalfNum_Solution(int [] array) {
int len=array.length;
if(len==0) return 0;
int ret=0,res=array[0],count=1;
for(int i=1;i<len;i++){
if(count==0){
res=array[i];
count++;
continue;
}
if(array[i]!=res){
count--;
}else count++;
}
for(int num:array){
if(num==res) ret++;
}
return ret>(len>>1)?res:0;
}
19.用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
public class Solution {
Stack<Integer> stack1 = new Stack<Integer>();
Stack<Integer> stack2 = new Stack<Integer>();
public void push(int node) {
stack1.push(node);
}
public int pop(){
if(stack2.empty()){
while(!stack1.empty()){
stack2.push(stack1.pop());
}
return stack2.pop();
}else{
return stack2.pop();
}
}
}
20.【ACM编程题】标题：组队竞赛|时间限制：1秒|内存限制：32768K
示例1:
输入
2
5 2 8 5 1 5
输入的第一行为一个正整数n(1≤n≤10^5)
第二行包括3*n个整数a_i(1≤a_i≤10^9),表示每个参赛选手的水平值.
输入描述：
输出一个整数表示所有队伍的水平值总和最大值.
null
输出描述：
10
public static void main(String[] args){
Scanner scanner =new Scanner(System.in);
int n = scanner.nextInt();
int len = 3 * n;
int[] as= new int[len];
for(int j=0;j<len;j++){
as[j] = scanner.nextInt();
}
Arrays.sort(as);// 1 2 5 5 5 8
long sum=0;
//1:从数组递减的形式递减统计
for(int j = len - 2;j >= n;j -= 2){
sum += as[j];
}
//2：从队列数递增的形式统计
for(int j=0;j < n;j ++){
sum += as[len - 2*(j+1)];
}
System.out.println(sum);
}
