一.
计算字符串最后一个单词的长度，单词以空格隔开。
输入：一行字符串，非空，长度小于5000。
输出：整数N，最后一个单词的长度。
import java.util.Scanner;
public class test{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String string= input.nextLine();
String[] arr=string.split(" ");
System.out.println(arr[arr.length-1].length());
input.close();
}
}nextLine的输入以enter键结束，而next的输入空格不计入。
split分隔符，返回一个数组（注意：特别的标识符如“\\." "\\|")。
二.
写出一个程序，接受一个有字母和数字以及空格组成的字符串，和一个字符，然后输出输入字符串中含有该字符的个数。不区分大小写。
import java.util.Scanner;
public class test{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String str = input.nextLine().toUpperCase();
//target里面存放string里的第一个字符（因为string里面只有一个字符)。
char target=input.nextLine().toUpperCase().toCharArray()[0];
int count=0;
for(int i=0;i<str.length();i++) {
if(str.charAt(i)==target) {
count++;
}
}
input.close();
System.out.println(count);
}
}toUpperCase()转换成大写；toCharArray()[0]存放字符串里的第一个字符。
str.CharAt()返回指定索引处的char值。
三.
明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤1000），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。
Input Param
n 输入随机数的个数
inputArray n个随机整数组成的数组
Return Value
OutputArray 输出处理后的随机整数
注：测试用例保证输入参数的正确性，答题者无需验证。测试用例不止一组。
package test;
import java.util.Scanner;
import java.util.Arrays;
public class test
{
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while(in.hasNext()) {
int n=in.nextInt();
int[] array=new int[n];
for(int i=0;i<n;i++) {
array[i]=in.nextInt();
}
Arrays.sort(array);//对数组进行排序
//对排好序的数组中重复的数组进行选择输出
System.out.println(array[0]);
for(int i=1;i<n;i++) {
if(array[i] !=array[i-1])
System.out.println(array[i]);
}
}
}
}注意：测试用例不止一组，用while(in.hasNext)。
四.
正整数A和正整数B 的最小公倍数是指 能被A和B整除的最小的正整数值，设计一个算法，求输入A和B的最小公倍数。
import java.util.Scanner;
public class test
{
public static void main(String[] args) {
//两数的最小公倍数等于两数相乘除以最大公约数。
Scanner in = new Scanner(System.in);
while(in.hasNext()) {
int A=in.nextInt();
int B=in.nextInt();
int result=A*B;
result=result/getGong(A,B);
System.out.println(result);
}
}
public static int getGong(int m, int n) {
int i=m;
while((m%i!=0)||(n%i!=0)) {
i--;
}
return i;
}
}两数的最小公倍数等于两数相乘除以两数的最大公约数。
掌握两数最大公约数的算法。
五.
在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
public class Solution {
public boolean Find(int target, int [][] array) {
int rows = array.length;
int cols = array[0].length;
int i=rows-1,j=0;
while(i>=0 && j<cols){
if(target<array[i][j])
i--;
else if(target>array[i][j])
j++;
else
return true;
}
return false;
}
}六.
请实现一个函数，将一个字符串中的空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
public class Solution {
public String replaceSpace(StringBuffer str) {
String sti = str.toString();
char[] strChar = sti.toCharArray();
StringBuffer stb = new StringBuffer();
for(int i=0;i<strChar.length;i++){
if(strChar[i]==' '){
stb.append("%20");
}else{
stb.append(strChar[i]);
}
}
return stb.toString();
}
}七
package test720;
import java.util.Scanner;
public class test720 {
public static int fuction(int n) {
if(n==1)
return 0;
if(n==2)
return 1;
return n/3 + fuction(n%3+n/3); //n/3是直接能换到的汽水数，n%3+n/3是新换到的汽水瓶子和上次换剩下的
}
public static void main(String[] args) {
Scanner scan= new Scanner(System.in);
while(scan.hasNext()) {
int blank=scan.nextInt();
if(blank!=0) {
System.out.println(fuction(blank));
}
}
scan.close();
}
}八
package test720;
import java.util.Scanner;
public class test720_2 {
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
while(scan.hasNextLine()) {
String str=scan.next();
String substr=str.substring(2);
int result=Integer.parseInt(substr,16);
System.out.println(result);
}
}
}
substring(x)是从字符串的的第x个字符截取
substring(x,y）是从x到y前的位置停止
Integer.parseInt(str,dex), Integer.parseInt(String)就是将String字符类型数据转换为Integer整型数据。
九
package test;
import java.util.Scanner;
import java.util.TreeMap;
public class test {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
int count=in.nextInt();
TreeMap<Integer, Integer> map=new TreeMap<Integer,Integer>();
while(in.hasNext()) {
int key=in.nextInt();
int value=in.nextInt();
if(map.containsKey(key)) {
map.put(key, value+map.get(key));
}
else {
map.put(key, value);
}
}
for(int key:map.keySet()) {
System.out.println(key+" "+map.get(key));
}
}
}TreeMap基于红黑树（Red-Black tree）实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。
TreeMap的基本操作 containsKey、get、put 和 remove 的时间复杂度是 log(n) 。
另外，TreeMap是非同步的。 它的iterator 方法返回的迭代器是fail-fastl的。
十 删数
有一个数组a[N]顺序存放0~N-1，要求每隔两个数删掉一个数，到末尾时循环至开头继续进行，求最后一个被删掉的数的原始下标位置。以8个数(N=7)为例:｛0，1，2，3，4，5，6，7｝，0->1->2(删除)->3->4->5(删除)->6->7->0(删除),如此循环直到最后一个数被删除。
输入：每组数据为一行一个整数n(小于等于1000)，为数组成员数,如果大于1000，则对a[999]进行计算。
输出：一行输出最后一个被删掉的数的原始下标位置。
package train;
import java.util.*;
public class test803 {
public static void main(String args[]) {
Scanner scan = new Scanner(System.in);
while(scan.hasNext()) {
int num=scan.nextInt();
if(num>1000)
num=999;
ArrayList<Integer> list = new ArrayList<Integer>();
for(int i=0;i<num;i++) {
list.add(i);
}
int i=0;
while(list.size()>1) {
i=(i+2)%list.size();
list.remove(i);
}
System.out.println(list.get(0));
}
}
}ArrayList类是一个动态数组类型，也就是说，ArrayList对象既有数组的特征，也有链表的特征。可以随时从链表中添加或删除一个元素。ArrayList实现了List接口。
大家知道，数组是静态的，数组被初始化之后，数组长度就不能再改变了。ArrayList是可以动态改变大小的。那么，什么时候使用Array（数组），什么时候使用ArrayList?答案是：当我们不知道到底有多少个数据元素的时候，就可使用ArrayList；如果知道数据集合有多少个元素，就用数组。
1.创建一个空的数组链表，用来存放String类型的对象，那么你可以像下面这样做：
ArrayList<String> list = new ArrayList<String>();
2.如果你需要创建一个指定初始容量的数组链表，你可以像下面这样做：
ArrayList<Integer> list = new ArrayList<Integer>(7);
注意：ArrayList类只支持对象类型，不支持 基础数据类型。就是说ArrayList对象只能存放对象，不能存放基础数据类型的数据。
解法思路：
取余操作，实现循环删数。
二
输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
Stack<ListNode> stack = new Stack<ListNode>();
ArrayList<Integer> list=new ArrayList<Integer>();
ListNode current=listNode;
while(current!=null){
stack.push(current);
current=current.next;
}
while(!stack.isEmpty()){
list.add(new Integer(stack.pop().val));
}
return list;
}
}利用栈的输出顺序。