刷刷笔试题~~[字符串类编程]

1.单词接龙

拉姆刚开始学习英文单词，对单词排序很感兴趣。

如果给拉姆一组单词，他能够迅速确定是否可以将这些单词排列在一个列表中，使得该列表中任何单词的首字母与前一单词的为字母相同。

你能编写一个程序来帮助拉姆进行判断吗？
输入描述:

输入包含多组测试数据。

对于每组测试数据，第一行为一个正整数n，代表有n个单词。

然后有n个字符串，代表n个单词。

保证：

2<=n<=200,每个单词长度大于1且小于等于10,且所有单词都是由小写字母组成。
输出描述:

对于每组数据，输出"Yes"或"No"
输入例子:

3
abc
cdefg
ghijkl
4
abc
cdef
fghijk
xyz

输出例子:

Yes
No

中间有用到：

Integer.valueOf(String)的功能是获取给定的字符串所代表的整数

charAt()功能类似于数组，可以把字符串看作是char类型的数组，

它是把字符串拆分获取其中的某个字符；返回指定位置的字符。

charAt(i)，i为int类型，i从0开始。

例如：

String str01 = "hello123";

char c = str01.charAt(1);  //返回位置为1的字符

output：c=e

解析：类似于String [] str01 = {'h','e','l','l','o','1','2','3'};

2.字符串最后一个单词的长度

计算字符串最后一个单词的长度，单词以空格隔开。
输入描述:

一行字符串，非空，长度小于5000。
输出描述:

整数N，最后一个单词的长度。
输入例子:

hello world

输出例子:

5

解析：比较基础的关于字符串的题

数组的长度：a.length

字符串的长度：a.length()

分割字符串：split     

import java.util.Scanner;
public class Main{
public static int lengthOfLast(String str){
String temp[]=str.split(" ");
int lastStr=temp[temp.length-1].length();
return lastStr;
}
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
while(sc.hasNext()){
String str=sc.nextLine();
System.out.println(lengthOfLast(str));
}
}
}

用Scanner实现字符串的输入有两种方法

一种是next（），一种nextLine()

如，你输入的一行：abc cde efg

注意，其中abc和cde之间有空格，cde和efg之间也有空格

这样，next()返回的是abc，

而nexLine()返回的是整行：abc cde efg

首先，next（）一定要读取到有效字符后才可以结束输入，对输入有效字符之前遇到的空格键、Tab键或Enter键等结束符，next（）方法会自动将其去掉，只有在输入有效字符之后，next（）方法才将其后输入的空格键、Tab键或Enter键等视为分隔符或结束符。

简单地说，next（）查找并返回来自此扫描器的下一个完整标记。完整标记的前后是与分隔模式匹配的输入信息，所以next方法不能得到带空格的字符串

而nextLine（）方法的结束符只是Enter键

即nextLine（）方法返回的是Enter键之前的所有字符，它是可以得到带空格的字符串的。

3.计算字符个数

写出一个程序，接受一个有字母和数字以及空格组成的字符串，和一个字符，然后输出输入字符串中含有该字符的个数。不区分大小写。
输入描述:

输入一个有字母和数字以及空格组成的字符串，和一个字符。
输出描述:

输出输入字符串中含有该字符的个数。
输入例子:

ABCDEF
A

输出例子:

1

解析：

*charAt()方法返回指定索引位置的char值。

*String.valueOf() 方法的使用

^由 基本数据型态转换成 String 
^String 类别中已经提供了将基本数据型态转换成 String 的 static 方法 
^String.valueOf(char c) : 将 char 变量 c 转换成字符串 

*比较字符串

区别大小写比较equals( )

不区别大小写比较equalsIgnoreCase( )
 

import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
String str=sc.nextLine();
String c=sc.next();
int num=0;
for(int i=0;i<str.length();i++){
if(c.equalsIgnoreCase(String.valueOf(str.charAt(i))))//要将str.charAt(i)返回的char转换成String
num++;
}
System.out.println(num);
}
}

4.字符逆序

将一个字符串str的内容颠倒过来，并输出。str的长度不超过100个字符。 如：输入“I am a student”，输出“tneduts a ma I”。

输入参数：

inputString：输入的字符串

 

返回值：

输出转换好的逆序字符串
输入描述:

输入一个字符串，可以有空格
输出描述:

输出逆序的字符串
输入例子:

I am a student

输出例子:

tneduts a ma I

解析：

charAt是返回指定索引位置的字符的，包含空格

直接i=str.length-1就能倒着输出了

import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
String str=sc.nextLine();
for(int i=str.length()-1;i>=0;i--){
System.out.print(str.charAt(i));
}
}
}

5.算法基础-字符移位

小Q最近遇到了一个难题：把一个字符串的大写字母放到字符串的后面，各个字符的相对位置不变，且不能申请额外的空间。

你能帮帮小Q吗？
输入描述:

输入数据有多组，每组包含一个字符串s，且保证:1<=s.length<=1000.

输出描述:

对于每组数据，输出移位后的字符串。
输入例子:

AkleBiCeilD

输出例子:

kleieilABCD

解析：

三种方法：

1.先输出所有的小写字母，再输出所有的大写字母

2.找到大写字母，想冒泡一样挪到后面去，比较长度减1，再循环

3.用StringBuffer结合上面两种

1.本来直接大小写分别输出就好，但是现实测试用例不通过，我就又把字母存进了一个char类ArrayList里了，

也不通过，，好像是因为申请额外空间了

import java.util.Scanner;
import java.util.ArrayList;
import java.util.List;
public class StringShift{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
String s=sc.next();
List<Character> list=new ArrayList<Character>();
for(int i=0;i<s.length();i++){
if(s.charAt(i)>='a'&&s.charAt(i)<='z')
list.add(s.charAt(i));
}
for(int i=0;i<s.length();i++){
if(s.charAt(i)>='A'&&s.charAt(i)<='Z')
list.add(s.charAt(i));

}
for(int i=0;i<list.size();i++){
System.out.print(list.get(i));
}

}
}

2.这个依旧申请了额外空间，String类不能改变，要用StringBuffer？

import java.util.Scanner;
public class StringShift1{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
String s=sc.nextLine();
char ch[]=s.toCharArray();
int n=ch.length;
int p=n;
for(int i=0;i<p;i++){
if(ch[i]>='A'&&ch[i]<='Z'){
char t=ch[i];
int j=i;
for(;j<n-1;j++){
ch[j]=ch[j+1];
}
ch[j]=t;
i--;
p--;
}
}
for(int i=0;i<ch.length;i++){
System.out.print(ch[i]);
}
}
}

3.好吧，，这次我用了StringBuffer还是不行，，但自己运行这三个都可以

import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
StringBuffer s=new StringBuffer(sc.nextLine());
int n=s.length();
int p=n;
for(int i=0;i<p;i++){
if(s.charAt(i)>='A'&&s.charAt(i)<='Z'){
String t=String.valueOf(s.charAt(i));//charAt返回char类型，要想加到String里还要变成String类型
s.deleteCharAt(i);//删除自定位置的字符
s.append(t);//添到末尾
i--;//因为发现大写字母后要删除再加到末尾，所以i要记得减1
p--;
}

}
System.out.print(s);
}
}

6.编写代码把16进制表示的串转换为3进制表示的串。例如x=”5”，则返回：”12”；又例如：x=”F”，则返回”120”。

package String;
/*
* 编写代码把16进制表示的串转换为3进制表示的串
*/
public class Convert {
public  static int  getRealValue(char x){
if(x>='0'&&x<='9')
return x-'0';
if(x>='a'&&x<='f')
return x-'a'+10;
if(x>='A'&&x<='F')
return x-'A'+10;
return 0;
}
public static  String jinzhi_16_3(String x){
int n=0;//累加真值
for(int i=0;i<x.length();i++){
n=n+getRealValue(x.charAt(i));
}
String t="";
for(;;){
if(n==0)
break;
t=(n%3)+t;
n=n/3;
}
return t;
}
}

7.给定字符串（ASCII码0-255）数组，请在不开辟额外空间的情况下删除开始和结尾处的空格，并将中间的多个连续的空格合并成一个。例如："   i    am a      little boy.    "，变成"i am a little boy",

public String FormatString1(String str){//运用正则表达式
str=str.trim();//去掉两边多余的空格，包括制表符
str=str.replaceAll("\\s{1,}", " ");// \s是空格字符(空格键, tab, 换行, 换页, 回车),{1,}表示至少匹配一个
return str;
}

好像replaceAll()

8.把字符串转换成整数

将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0 
输入描述:

输入一个字符串,包括数字字母符号,可以为空

输出描述:

如果是合法的数值表达则返回该数字，否则返回0

输入例子:

+2147483647
1a33

输出例子:

2147483647
0

解析：

一、按题意的解法：

把String字符串换成char[] c数组

判断c[0]是否为'-'，是的话用记录sign下来，之后算完数的时候要和它相乘，否则默认为正的

然后循环判断里面的每一个字符

先判断c[0]是否为'-'或'+'，如果是的话，从c[1]开始循环

判断c[i]在'0'-'9'之间，否则直接return 0

然后想一下怎么按照每位的数字算出最终的数字

每位数字：c[i]-'0'

比如1234

初始化sum=0，开始循环：sum=0*10+1=1，sum=1*10+2=12，sum=12*10+3=123，sum=123*10+4=1234

所以：sum=sum*10+c[i]-'0'

最后循环结束，返回sum*sign

public class Solution {
public int StrToInt(String str) {
if(str==""||str.length()==0){
return 0;
}
char[] c=str.toCharArray();
int sign=1;
if(c[0]=='-')
sign=-1;
int sum=0;
for(int i=(c[0]=='-'||c[0]=='+')?1:0;i<c.length;i++){
if(!(c[i]>='0'&&c[i]<='9'))
return 0;
sum=sum*10+c[i]-'0';
}
return sum*sign;
}
}

8.表示数值的字符串

请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100","5e2","-123","3.1416"和"-1E-16"都表示数值。 但是"12e","1a3.14","1.2.3","+-5"和"12e+4.3"都不是。

解析：

一开始在分析各种各样的情况，最后发现用正则表达式最方便

正则表达式：

(1)+、-这两个中只能出现1次或0次：[\\+-]?

(2)无论是在e前面还是在+-后面，还是在小数点前面，都要有数字：[0-9]+

(3)小数点和后面的数字，可能出现一次，或者不出现：(\\.[0-9]+)?

(4)带e的部分是一个整体，可能出现一次，或者不出现：([eE][\\+-]?[0-9]+)?

最后：[\\+-]?[0-9]+(\\.[0-9]+)?([eE][\\+-]?[0-9]+)?

public class Solution {
public boolean isNumeric(char[] str) {
String s=String.valueOf(str);
return s.matches("[\\+-]?[0-9]+(\\.[0-9]+)?([eE][\\+-]?[0-9]+)?");
}
}

9.

字符流中第一个不重复的字符

请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。 
输出描述:

如果当前字符流没有存在出现一次的字符，返回#字符。

解析：

类似这种判断出现一次两次的问题都可以用hashmap来解决，这里可以用int数组来模拟一下

每个字符占8位，所有字符一共有2^8=256个，所以一个256大的int数组hashtable就够了

Insert的时候，因为插入的是char类型字符

在全局最外面声明一个StringBuffer的对象，每次插入字符，都s.append(ch)【好神奇可以append一个char类型的！！】

然后hashtable[ch]++

只要按原来字符的顺序寻找，看hashtable的值，第一个hashtable[i]=1的字符就是！！

public class Solution {
int[] hashtable=new int[256];
StringBuffer sb=new StringBuffer();
//Insert one char from stringstream
public void Insert(char ch)
{
sb.append(ch);
hashtable[ch]++;
}
//return the first appearence once char in current stringstream
public char FirstAppearingOnce()
{
char[] c=sb.toString().toCharArray();//要记得先转换成String类型，在变成char数组
for(char t:c){
if(hashtable[t]==1)
return t;
}
return '#';

}
}

10.[编程题]01排序

给定一个01串（仅由‘ 0’或‘1’组成的字符串），现在想把这个数字串排序成“非递减”有序序列，请问至少需要多少次交换（任意两个位置交换）？ 
输入描述:

输入数据第一行是一个正整数T(T<=100),表示有T组测试数据；
接下来的T行，每行给出01串。
数据保证——
50%的字符串长度在[1,100 ]
95%的字符串长度在[1,10000]
100%的字符串长度在[1,1000000]

输出描述:

对于每组测试数据，请输出排成“非递减有序序列”的最小交换次数。
每组输出占一行。

输入例子:

3
01
10
110

输出例子:

0
1
1

解析：

其实就是一次快排的过程，指针从两边走，左边是0是时候继续向前走，右边是1的时候向左走，遇到不是的时候，交换次数+1，然后继续向前走

import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
for(int i=0;i<t;i++){
String s=sc.next();
char[] c=s.toCharArray();
System.out.println(Num(c));
}
}
public static int Num(char[] c){
int i=0;
int j=c.length-1;
int count=0;
while(i<j){
while(i<j&&c[i]=='0')
i++;
while(i<j&&c[j]=='1')
j--;
if(i<j){
count++;
i++;
j--;
}
}
return count;
}

}