1.题目描述
•连续输入字符串，请按长度为8拆分每个字符串后输出到新的字符串数组；
•长度不是8整数倍的字符串请在后面补数字0，空字符串不处理
示例1
输入
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.题目描述
实现删除字符串中出现次数最少的字符，若多个字符出现次数一样，则都删除。输出删除这些单词后的字符串，字符串中其它字符保持原来的顺序。
示例1
输入
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个字符串，请对n个字符串按照字典序排列。
输入描述:
输入第一行为一个正整数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，最后一个单词的长度。
示例1
输入
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
字符串:length()
集合:size()
5.题目描述
编写一个函数，计算字符串中含有的不同字符的个数。字符在ACSII码范围内(0~127)。不在范围内的不作统计
输入描述:
输入N个字符，字符在ACSII码范围内。
输出描述:
输出范围在(0~127)字符的个数。
示例1
输入
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.题目描述
写出一个程序，接受一个有字母和数字以及空格组成的字符串，和一个字符，然后输出输入字符串中含有该字符的个数。不区分大小写。
输入描述:
输入一个有字母和数字以及空格组成的字符串，和一个字符。
输出描述:
输出输入字符串中含有该字符的个数。
示例1
输入
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 输入要删除的结点的值
输出描述:
输出删除结点后的序列
示例1
输入
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
思路：将字符串toCharArray（）转成字符数组，从数组的的第一个字符开始，获取该字符在字符串中的第一个索引位置和最后一个索引位置，如果相等，那么这个字符就是第一个只出现一次的字符。
代码实现：
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);
}
代码实现：
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);
}
6657
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
