1.题目描述
•连续输入字符串,请按长度为8拆分每个字符串后输出到新的字符串数组;
•长度不是8整数倍的字符串请在后面补数字0,空字符串不处理
输入
abc 123456789
输出
abc00000 12345678 90000000
基本思路:将字符串个数对8整除,得到的余数如果为零,说明字符串刚好是8的整数(即刚好按长度为8拆分),如果不为零,可以通过补零,将剩下的不足8为的余数添加到8位。
代码实现:
import java.util.Scanner;
public class Test
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
while(sc.hasNext())
{
String s = new String(sc.nextLine());
StringBuffer str = new StringBuffer(s);
if(s.length()%8!=0)
{
for(int i=0;i<8-s.length()%8;i++)
{
str.append("0");
}
}
while(str.length()>=8)
{
System.out.println(str.substring(0, 8));
str = str.delete(0, 8);
}
}
}
}
更优的方案:
思路:先判断字符串的长度是否是8的倍数,如果是8的倍数,那么就每个8个字符打印输出,如果不是8的倍数,即每隔8个字符输出后,还剩余(0-7)个字符,此时先在字符串后面添加8个0,然后每隔8个字符输出,直到剩余的字符小于8为止。
Scanner sc = new Scanner(System.in);
while(sc.hasNext())
{
String s = new String(sc.nextLine());
if(s.length()%8!=0)
s = s + "00000000";
System.out.println(s);
while(s.length()>=8)
{
System.out.println(s.substring(0, 8));
s = s.substring(8);
System.out.println("s: "+s);
}
}
小结:几个字符串的常用函数:
1)String和StringBuffer都有求子串的函数
2)StringBuffer独有的方法
2.题目描述
实现删除字符串中出现次数最少的字符,若多个字符出现次数一样,则都删除。输出删除这些单词后的字符串,字符串中其它字符保持原来的顺序。
输入
abcdd
输出
dd
基本思路:记住每个字符出现的次数,打印输出时,忽略出现次数最小的字符,将别的字符输出。这边比较好的数据结构是Map,因为它可以存放键值对,但是注意题中有要求,要保持原来顺序输出,而常用的HashMap和TreeMap都不能保证按照输入顺序输出,所以这边采用的是LinkedHashMap,它能保证按照输入顺序输出。
代码实现:
import java.util.Scanner;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Collections;
import java.util.Collection;
public class Main
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
while(in.hasNext())
{
String str = in.next();
char[] ch = str.toCharArray();
Map<Character,Integer> map = new LinkedHashMap<Character,Integer>();
for(int i=0;i<ch.length;i++)
{
if(!map.containsKey(ch[i]))
{
map.put(ch[i], 1);
}
else
{
map.put(ch[i], map.get(ch[i])+1); //判断如果已经存在,就将数目加一
}
}
Collection<Integer> al = map.values();
int index = Collections.min(al); //找出出现次数最少的字符
for(char c:ch)
{
if(map.get(c)!=index)
System.out.print(c);
}
System.out.println();
}
}
}
说明:这边注意几个函数的使用:
Collection<Integer> al = map.values();
Collections.min(al);
3.题目描述
输入描述:
输入第一行为一个正整数n(1≤n≤1000),下面n行为n个字符串(字符串长度≤100),字符串中只含有大小写字母。
输出描述:
数据输出n行,输出结果为按照字典序排列的字符串。
思路:将元素放入到数组或者列表中(set不行,因为可能出现重复的字符串),然后调用函数排序,在使用for each输出。
代码实现:
链接:https://www.nowcoder.com/questionTerminal/5af18ba2eb45443aa91a11e848aa6723
来源:牛客网
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
String [] ss = new String[num];
for (int i = 0; i < num; i++) {
ss[i]=sc.next();
}
Arrays.sort(ss);
for (int i = 0; i < ss.length; i++) {
System.out.println(ss[i]);
}
}
}
说明:将ss[i] = sc.next()改为ss[i] = sc.nextLine(),就会少一行,网友给出的解释:因为int num = sc.nextInt()仅仅是把第一行的整数值读取了,在管道缓存中,还有换行符(enter),当在下面的nextLine()首先是读取第一行的换行符前面的数据,就是null,所以读取的数据就会少一行
4.题目描述
计算字符串最后一个单词的长度,单词以空格隔开。
输入描述:
一行字符串,非空,长度小于5000。
输出描述:
整数N,最后一个单词的长度。
输入
hello world
输出
5
import java.util.*;
public class Main
{
public static void main(String[] args)
{
Scanner scanner = new Scanner(System.in);
String s1 = scanner.nextLine();
String[] s2 = s1.split(" ");
System.out.println(s2[s2.length-1].length());
}
}
字符串:length()
集合:size()
5.题目描述
编写一个函数,计算字符串中含有的不同字符的个数。字符在ACSII码范围内(0~127)。不在范围内的不作统计
输入描述:
输入N个字符,字符在ACSII码范围内。
输出描述:
输出范围在(0~127)字符的个数。
输入
abc
输出
3
思路:只计算不同的字符,这里想到将这些字符存入set集合中,因为set集合会自动覆盖重复的对象,最后再计算set集合中字符的个数.
代码实现:
import java.util.*;
public class Main
{
public static void main(String[] args)
{
Scanner scanner = new Scanner(System.in);
String s = scanner.next();
Set<Character> set = new TreeSet<>(); //char的包装类Character
for(int i=0;i<s.length();i++) //字符串的获取长度s.length(),数组的获取长度s.length
{
char ch = s.charAt(i);
if(ch>0&&ch<127)
{
set.add(ch); //根据索引获取字符串的某个字符
}
}
System.out.println(set.size()); //大小
}
}
6.题目描述
写出一个程序,接受一个有字母和数字以及空格组成的字符串,和一个字符,然后输出输入字符串中含有该字符的个数。不区分大小写。
输入描述:
输入一个有字母和数字以及空格组成的字符串,和一个字符。
输出描述:
输出输入字符串中含有该字符的个数。
输入
ABCDEF A
输出
1
import java.util.*;
public class Main
{
public static void main(String[] args)
{
Scanner scanner = new Scanner(System.in);
String string = scanner.nextLine().toUpperCase();//输入字符串转成大写
String c = scanner.nextLine().toUpperCase(); //输入字符转成大写
int count = 0;
for(int i=0;i<string.length();i++)
{
if(string.charAt(i)==c.charAt(0)) //逐个比较字符串的每个字符是否与输入字符相等
count++;
}
System.out.println(count);
}
}
说明:上面是通过索引的方式,获取字符串的每个字符,也可以将获取到的字符串直接转成字符数组、
String string = scanner.nextLine().toUpperCase();
char[] ch = string.toCharArray();
同时也可以,将字符串中的每个字符都作为一个字符串通过equalsIgnoreCase()方法比较,这样不用都转成大写,总之方法很多。
7.题目描述
输入一行字符,分别统计出包含英文字母、空格、数字和其它字符的个数。
输入描述:
输入一行字符串,可以有空格
输出描述:
统计其中英文字符,空格字符,数字字符,其他字符的个数
思路:将字符串转成字符数组,设定计数变量,每个字符单独比较。
代码实现:
链接:https://www.nowcoder.com/questionTerminal/539054b4c33b4776bc350155f7abd8f5
来源:牛客网
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while(scanner.hasNext()){
String line = scanner.nextLine();
System.out.println(getEnglishCharCount(line));
System.out.println(getBlankCharCount(line));
System.out.println(getNumberCharCount(line));
System.out.println(getOtherCharCount(line));
}
scanner.close();
}
public static int getEnglishCharCount(String str) {
char[] ch = str.toCharArray();
int count =0;
for(int i=0;i<ch.length;i++){
if((ch[i]>='a'&&ch[i]<='z')||(ch[i]>='A'&&ch[i]<='Z')){
count++;
}
}
return count;
}
public static int getNumberCharCount(String str){
char[] ch = str.toCharArray();
int count =0;
for(int i=0;i<ch.length;i++){
if(ch[i]>='0'&&ch[i]<='9'){
count++;
}
}
return count;
}
public static int getBlankCharCount(String str){
char[] ch = str.toCharArray();
int count =0;
for(int i=0;i<ch.length;i++){
if(ch[i]==' '){
count++;
}
}
return count;
}
public static int getOtherCharCount(String str) {
int count =0;
for(int i=0;i<str.length();i++){
if(getBlankCharCount(""+str.charAt(i))==0&&getEnglishCharCount(""+str.charAt(i))==0&&getNumberCharCount(""+str.charAt(i))==0){
count++;
}
}
return count;
}
}
8.
题目描述
输入一个单向链表和一个节点的值,从单向链表中删除等于该值的节点,删除后如果链表中无节点则返回空指针。
输入描述:
1 输入链表结点个数 2 输入头结点的值 3 按照格式插入各个结点 4 输入要删除的结点的值
输出描述:
输出删除结点后的序列
输入
5 2 3 2 4 3 5 2 1 4 3
输出
2 1 4 5
思路:这里可以使用LinkedList集合,因为LinkedList有indexOf(Object)方法,可以返回列表中首次出现指定元素的索引,同时add(int index,E elemt)方法可以在列表中插入指定的元素,因为LinkedList的底层是链表实现的,所以相比与数组实现的ArrayList更适合插入和删除元素。
代码实现:
Scanner in = new Scanner(System.in);
while(in.hasNext())
{
int n = in.nextInt();
int firstNode = in.nextInt();
LinkedList<Integer> list = new LinkedList<>();
list.add(firstNode);
for(int i=0;i<n-1;i++)
{
int Node1 = in.nextInt();
int Node2 = in.nextInt();
if(list.contains(Node1)==false)
{
int index = list.indexOf(Node2);
list.add(index+1,Node1);
}
}
Integer deleteNode = in.nextInt();
list.remove(deleteNode);
for(int i=0;i<list.size()-1;i++)
{
System.out.print(list.get(i)+" ");
}
System.out.println(list.get(list.size()-1)+" ");
}
第二种方法:使用链表实现
import java.util.Scanner;
import java.util.HashSet;
import java.util.Set;
import java.util.LinkedList;
class ListNode
{
int data;
ListNode next;
}
public class Main
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
while(in.hasNext())
{
int n = in.nextInt();
int headNumber = in.nextInt();
ListNode head = new ListNode();
head.data = headNumber;
head.next = null;
Set<Integer> set = new HashSet<>();
set.add(headNumber);
for(int i=0;i<n-1;i++)
{
int listNumber = in.nextInt();
int number = in.nextInt();
ListNode p;
if(set.contains(listNumber)==false)
{
set.add(listNumber);
ListNode s = new ListNode();
s.data = listNumber;
s.next = null;
p = head;
while(p.next!=null&&p.data!=number)
{
p = p.next;
}
s.next = p.next;
p.next = s;
}
}
ListNode q = new ListNode();
q.data = in.nextInt();
q.next = null;
head = deleteListNode(head,q);
printListNode(head);
}
}
public static ListNode deleteListNode(ListNode head,ListNode q )
{
ListNode p;
p = head;
if(p.data==q.data)
{
head = head.next;
return head;
}
while(p.next.data!=q.data)
{
p = p.next;
}
p.next = p.next.next;
return head;
}
public static void printListNode(ListNode head)
{
ListNode p;
p = head;
while(p!=null)
{
System.out.print(p.data+" ");
p = p.next;
}
System.out.println();
}
}
9.
题目描述
找出字符串中第一个只出现一次的字符
输入描述:
输入一个非空字符串
输出描述:
输出第一个只出现一次的字符,如果不存在输出-1
Scanner in = new Scanner(System.in);
while(in.hasNext())
{
String str = in.next();
char[] a = str.toCharArray();
int flag = 0;
for(int i=0;i<str.length();i++)
{
if(str.indexOf(a[i])==str.lastIndexOf(a[i]))
{
System.out.println(a[i]);
flag = 1;
break;
}
}
if(flag==0)
System.out.println(-1);
}
第二种方法:将字符串转成字符数组,从第一个字符开始,将字符存入LinkedHasdMap集合中,键为字符,值为字符出现的次数,在LinkedHashMap集合中按照原先顺序遍历集合,如果集合的键对应的值为1,那么这个键就是要找的字符。
Scanner in = new Scanner(System.in);
while(in.hasNext())
{
String str = in.next();
char[] ch = str.toCharArray();
Map<Character,Integer> map = new LinkedHashMap<>();
for(int i=0;i<ch.length;i++)
{
if(!map.containsKey(ch[i]))
{
map.put(ch[i],1);
}
else
{
map.put(ch[i],map.get(ch[i])+1);
}
}
int flag = 0;
for(char i:map.keySet())
{
if(map.get(i)==1)
{
System.out.println(i);
flag = 1;
break;
}
}
if(flag==0) //如果不存子啊出现一次的字符
System.out.println(-1);
}