java面试基础编程题
https://blog.csdn.net/zhongqi2513/article/details/79770782
1、编写一个Java程序在屏幕上输出1！+2！+3！+……+10！的和。
public class MJF2 {
public static void main( String args[] ) {
int i,j,mul,sum=0;
for(i=1;i<=10;i++) {
mul=1;
for(j=1;j<=i;j++) {
mul=mul*j;
}
sum=sum+mul;
}
System.out.println(sum);
}
}2、删除以“s”结尾的字符 比如 {“as”，“bs”，“cs”，“d”，“e”，“fs”，}
结果为{d,e}
import java.util.ArrayList;
import java.util.List;
public class mjf {
public static void main(String[] args) {
List list = new ArrayList<>();
List list1 = new ArrayList<>();
list.add("as");
list.add("bs");
list.add("cs");
list.add("d");
list.add("e");
list.add("fs");
for (int i=0;i next.equals("s"));
// System.out.println(list.toString());
}
} 3、计算两个日期之间的天数。
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class MJF1 {
public static void main(String[] args) throws ParseException {
String date1="2019-01-01";
String date2="2019-01-09";
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-mm-dd");
Date d1=sdf.parse(date1);
Date d2=sdf.parse(date2);
long daysBetween=(d2.getTime()-d1.getTime())/(60*60*24*1000);
System.out.println(daysBetween);
}
}
4、计算101到200之前的素数。
import static java.lang.Math.sqrt;
public class M3 {
public static void main(String[] args) {
int count=0;
for (int i=101;i<=200;i++){
boolean b=true;
for (int j=2;j<=sqrt(i);j++){
if (i%j==0){
b=false;
// break;
}
}
if (b){
count++;
System.out.println(i);
}
}
}
}5、求100-999之间水仙花的的个数 153=1的三次方+5的三次方+3的三次方；
public class M2 {
public static void main(String[] args) {
int sum=0;
for (int i=100;i<999;i++){
int a=i%10;//个位
int b=(i/10)%10;//十位
int c=i/100; //百位
if (i==(a*a*a)+(b*b*b)+(c*c*c)){
System.out.println(i);
sum++;
}
}
System.out.println(sum);
}
}6、利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。
import java.util.Scanner;
public class M4 {
public static void main(String[] args) {
String A="A";
String B="B";
String C="C";
Scanner scanner=new Scanner(System.in);
double n=scanner.nextInt();
String b= n>=90?A:(n>=60?B:C);
System.out.println(b);
}
}
7、
题目：将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。
程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：
(1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。
(2)如果n<>k，但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数n,重复执行第一步。
(3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步。
import java.util.Scanner;
public class M2 {
public static void main(String[] args) {
System.out.println("请输入一个数");
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
int k=2;
if(n<=k) System.out.println(n);
else{
for(k=2;k8、题目：利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。
程序分析：(a>b)?a:b这是条件运算符的基本例子。
import java.util.Scanner;
public class mjf {
public static void main(String[] args) {
System.out.println("请输入你的成绩");
Scanner in= new Scanner(System.in);
int input=in.nextInt();//获取输入
//等级判断
String belong=input>=90?"A":(input>=60?"B":"C");
System.out.println(belong);
}
}
9、题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
程序分析：利用辗除法。
*这里有一个知识点要记住的，最大公约数和最小公倍数的求法
*1、先求最大公约数bigDivisor
*2、就可以很方便获得最小公倍数multiple=input1*input2/bigDIvisor
*这里最重要的就是求最大公约数：求法如下
*(1)用大的数对小的数求余
*(2)把小的数赋值给大的数，把求余获得的结果赋值给小的数，
*(3)循环上一步的操作，直到求余的结果为零
*(4)上一步被求余的数就是我们要的最大公约数，不信的话，你可以动手试试
import java.util.Scanner;
public class mjf1 {
public static void main(String[] args) {
int bigDivisor=0; int muliple=0;
System.out.println("请输入两个整数");
Scanner input1=new Scanner(System.in);
Scanner input2=new Scanner(System.in);
int in1=input1.nextInt();
int in2=input2.nextInt();
muliple=in1*in2;//这个值保存，求公约数后，方便求得最小公倍数
int temp=1;
if(in2>in1){
temp=in2;
in2=in1;
in1=temp;
}
while (temp!=0) {
temp = in1 % in2;
in1 = in2;
in2 = temp;
}
bigDivisor=in1;
muliple =muliple/bigDivisor;
System.out.println("最大公约数是："+bigDivisor );
System.out.println("最大公约数是："+muliple );
}
}
10、题目：输入一行字符，分别统计出其英文字母、空格、数字和其它字符的个数。
程序分析：
这里的需要的知识点:
1、获取一行字符串，nextLine（）
2、把字符串的每一个字符赋值到一个数值中
3、对比每一个数值在ASK码的范围，就可以确定它符号的类别
4、char字符ASK码的范围
（1）数字0到9： 48~57
（2）字母A到Z：65到90 a到z：97到122
（3）空格是32
import java.util.Scanner;
public class mjf2 {
public static void main(String[] args) {
int num=0,letter=0,space=0,others=0;
System.out.println("请输入一段字符串");
Scanner in=new Scanner(System.in);
String input=in.nextLine();
//把字符串里面得值赋值给一个字符型数组
char[] arr=input.toCharArray();
for (int i=0;i=48&&arr[i]<=57){
num++;
}else if ((arr[i]>=65&&arr[i]<=90)||(arr[i]>=97&&arr[i]<=122)){
letter++;
}else if (arr[i]==32){
space++;
}else {
others++;
}
}
System.out.println("数字个数是："+num+" 字母个数是:"+letter+" 空格个数为:"+space+" 其他个数为:"+others);
}
}
11、题目：一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1＋2＋3.编程找出1000以内的所有完数。
判断完数的方法：
* 利用for循环判断所有因数的和是否和输入的值是否相等，相等的话输出
* 求因数的方法：
* （1）两个嵌套循环，并用i%j==0,关于i和j的值范围：i从1到1000逐个遍历，j只需不大于i/2+1即可
* 比如：48，最大的因数才24,99最大的因数是33，因数不会大于本身数的一半
* （2）j就是我们所求的因数，把所有的j相加，就可以得到因数总和
* （3）因数总和已经包含1了，因为第一次就保存1了
import java.util.Scanner;
public class mjf4 {
public static void main(String[] args) {
System.out.println("1000内的因素");
for (int i=0;i<=1000;i++){
int sum=0;
for (int j=1;j12、题目：一球从h米高度自由落下，每次落地后反跳回原高度的一半；
再落下，求它在 第n次落地时，共经过多少米？第n次反弹多高？
程序分析：反弹的高度:(1/2)的n次方*h
* 经过的距离：这个可以总结得到：第一次落地经过：h,第二次落地经过：h+(h/2)*2,
* 第三次落地经过：h+(h/2)*2+(h/2/2)*2
* 那么第n次落地经过： h+(h/2)*2+(h/2/2)*2 +...+h/(2的n-1次方)*2
import java.util.Scanner;
public class mjf4 {
public static void main(String[] args) {
System.out.println("请输入小球下落的高度");
Scanner in = new Scanner(System.in);
float input1=in.nextFloat();
System.out.println("请输入小球下落的次数");
float input2=in.nextFloat();
float sum=input1;
input1=input1/2;
for(int i=2;i<=input2;i++){
sum+=input1*2;
input1=input1/2;
}
System.out.println("在"+100+"米,经过"+input2+"次后，能反弹："+input1+"米。经过的距离："+sum);
}
}
13、题目：有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？
程序分析：可填在百位、十位、个位的数字都是1、2、3、4。这里要用3个for循环
用if判断条件是否符合，符合条件的数字打印出来,并计算个数总和
import java.util.Scanner;
public class mjf5 {
public static void main(String[] args) {
int sum=0;
for (int bite=1;bite<5;bite++){
for (int ten=1;ten<5;ten++){
for (int hund=1;hund<5;hund++){
if (bite!=ten&&ten!=hund&&bite!=hund){
System.out.println((hund*100+ten*10+bite)+"");
sum++;
if (sum%10==0){
System.out.println();
}
}
}
}
}
}
}
14、题目：一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？
程序分析：在10万以内判断，
用for循环判断：先将该数加上100后再开方，再将该数加上268后再开方，
如果开方后的结果再平方后分别和i+100,i+268相等，即是结果。
import java.util.Scanner;
public class mjf5 {
public static void main(String[] args) {
for (int i=0;i<10000;i++){
int num1=(int)Math.sqrt(i+100);
int num2=(int)Math.sqrt(i+268);
if ((num1*num1==(i+100)&&(num2*num2==(i+268)))){
System.out.println(i+" ");
}
}
}
}
15、题目：输入某年某月某日，判断这一天是这一年的第几天？
程序分析：以3月5日为例，应该先把前两个月的加起来
，然后再加上5天即本年的第几天，特殊情况，闰年且输入月份大于3时需考虑多加一天。
闰年的条件：year除以400能整除，或者year除以4能整除，但是不能是100的倍数
import java.util.Scanner;
public class mjf6 {
public static void main(String[] args) {
System.out.println("输入某年某月某日，判断这一天是这一年的第几天？");
Scanner in = new Scanner(System.in);
int year = in.nextInt();//获取年份
int month = in.nextInt();//获取month份
int day = in.nextInt();//获取day份
int sum=0;
sum=day;
int[] arr={31,28,31,30,31,30,31,31,30,31,30,31};
for (int i=1;i2){
sum=sum+1;
}
System.out.println(year+"年"+month+"月"+day+"日，是这年的第"+sum+"天");
}
} 16、题目：输入三个整数x,y,z，请把这三个数由小到大输出。
程序分析：我们想办法把最小的数放到x上，先将x与y进行比较，如果x>y则将x与y的值进行交换，然后再用x与z进行比较，如果x>z则将x与z的值进行交换，这样能使x最小。
最后两个数也使z>y就可以了
public class mjf7 {
public static void main(String[] args) {
System.out.println("请输入你的成绩");
Scanner in= new Scanner(System.in);
int x=in.nextInt();//获取输入x
int y=in.nextInt();//获取输入y
int z=in.nextInt();//获取输入z
int tem=0;
if (x>y){
tem=x;
x=y;
y=tem;
}
if (x>z){
tem=x;
x=z;
z=tem;
}
if (y>z){
tem=y;
y=z;
z=tem;
}
System.out.println("这三个数从小到大排列："+x+" "+y+" "+z);
}
}17、题目：输出9*9口诀。
程序分析：分行与列考虑，共9行9列，i控制行，jC列。
表达式： i+"*"+j+"="+i*j，这里要用两个for循环控制输出和换行
public class mjf7 {
public static void main(String[] args) {
for (int i=1;i<10;i++){
for (int j=1;j<=i;j++){
System.out.print(i+"*"+j+"="+i*j+" ");//输出结果
}
System.out.println();//换行
}
}
}18、题目：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。
程序分析：采取逆向思维的方法，从后往前推断。
天 数 1 2 3 4 5 。。。10
桃子数 1 4 10 22 46 ？
* 所以桃子数计算方法：前一天桃子数*2+2
public class mjf8 {
public static void main(String[] args) {
int sum=1;
for (int i=2;i<=10;i++){
sum=sum*2+2;
}
System.out.println(sum);
}
}
19、题目：两个乒乓球队进行比赛，各出三人。甲队为a,b,c三人，乙队为x,y,z三人。已抽签决定比赛名单。有人向队员打听比赛的名单。a说他不和x比，c说他不和x,z比，请编程序找出三队赛手的名单。
程序分析：？？？感觉不能下手！
* 这道题目使用的是构造方法，还有arrayList的知识！标准答案的答案！
* 但是，还是被我用for循环给解决了
* 这里重要的是使用赋值，还有充分使用给出的条件，还有一个就是互不冲突的常识，比如第一个if的使用！
public class mjf9 {
public static void main(String[] args) {
String a=null,b=null,c=null;
String[] racer={"x","y","z"};
for (int i=0;i<3;i++){
for (int j=0;j<3;j++){
for (int k=0;k<3;k++){
if (i!=j&&i!=k&&j!=k){
a=racer[i];b=racer[j];c=racer[k];
if (!a.equals("x")&&!c.equals("z")&&!c.equals("x")){
if(a.equals(racer[i])&&b.equals(racer[j])&&c.equals(racer[k])){
System.out.println("a的对手是："+racer[i]+"，b的对手是："+racer[j] +"，c的对手是："+racer[k] );
}
}
}
}
}
}
}
}
20、题目：取一个整数a从右端开始的4～7位。
public class mjf11 {
public static void main(String[] args) {
System.out.println("请输入一个整数");
Scanner in= new Scanner(System.in);
long num=in.nextLong();
String str=Long.toString(num);//把数字转换成String
char[] ch=str.toCharArray();
int n=ch.length;
System.out.println(ch[n-7]+ch[n-6]+ch[n-5]+ch[n-4]);
}
}21、给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]用暴力算法。
class Solution {
public static int[] twoSum(int[] nums, int target) {
int[] result={-1,-1};
for(int i=0;i哈希表
关于哈希的使用 https://www.cnblogs.com/jiuhaoyun/p/8985643.html
class Solution {
// sums={2,7,9,11}; target=9
public static int[] twoSum(int[] nums, int target) {
Map map = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
// 第一步 当i=0,下面的if条件不成立（因为此时map里面是空的），所以跳出来if循环 执行第二步
//第三步 当i=1,时候，if成立。 9-7=2,执行return 执行第四步
if (map.containsKey(target - nums[i])) {
//第四步 int[]{map.get(target - nums[i]),i}，其中 map.get(2)的结果是下标0
//所以 int[]{0,i} 此时i=1 int[]{0,1} 返回 0，1 结束！
return new int[]{map.get(target - nums[i]),i};
}
// 第二步 将key value 保存到map里面 （2，0）这个键值对是在sums数组里找到的.执行第三步
map.put(nums[i], i);
}
return new int[]{0,0};
}
} 22、给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例：
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807答案参考：http://m.nowcoder.com/discuss/196944?type=0&pos=10
/*
* @lc app=leetcode.cn id=2 lang=java
*
* [2] 两数相加
*/
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
//创建结果链表的头节点，默认该节点中的value为-1
ListNode dummy = new ListNode(-1);
ListNode pre=dummy;
//进位标识carry ，默认 0
int carry=0;
while(l1!=null||l2!=null){
int d1 = (l1 == null) ? 0 : l1.val ;
int d2 = (l2 == null) ? 0 : l2.val ;
// 对节点求和，注意 求和是考虑进位的。
int sum = d1 + d2 + carry ;
// 更新进位标志
carry = (sum >= 10) ? 1 : 0 ;
//sum%10 标识求和的个位数，将其保存到结果链表中，
pre.next = new ListNode(sum%10);
pre = pre.next ;
if( l1 != null ) l1 = l1.next;
if( l2 != null ) l2 = l2.next;
}
// 重点，这是一个特殊情况，当两个链表计算完后，
//还需要判断进位标识符是否是1，如果是1，如23+81=104，需要创建一个结点保存最高位
if(carry==1)
pre.next = new ListNode(1);
return dummy.next;
}
}
官方答案：
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode dummyHead = new ListNode(0);
ListNode p = l1, q = l2, curr = dummyHead;
int carry = 0;
while (p != null || q != null) {
int x = (p != null) ? p.val : 0;
int y = (q != null) ? q.val : 0;
int sum = carry + x + y;
carry = sum / 10;
curr.next = new ListNode(sum % 10);
curr = curr.next;
if (p != null) p = p.next;
if (q != null) q = q.next;
}
if (carry > 0) {
curr.next = new ListNode(carry);
}
return dummyHead.next;
}23、
给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。示例 2:
输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。示例 3:
输入: "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。解析：http://m.nowcoder.com/discuss/196946
/*
* @lc app=leetcode.cn id=3 lang=java
*
* [3] 无重复字符的最长子串
*/
class Solution {
public int lengthOfLongestSubstring(String s) {
int res = 0;
if(s.length()==0){
return res;
}
//创建HashMap，用来保存 字符 和 位置 的对应关系
HashMap< Character , Integer > hashMap = new HashMap<>();
//初始化左右指针，并遍历字符串
for( int left = 0 , right = 0 ; right < s.length() ; right++ ){
//判断右指针指向的字符串有没有出现过
if(hashMap.containsKey(s.charAt(right))){
//确定左指针的位置
left = Math.max(left, hashMap.get(s.charAt(right))+1);
}
//对于第一次出现的字符，保存该字符的位置
hashMap.put(s.charAt(right), right);
//更新窗口的大小，保存最大的窗口大小
res = Math.max(res, right-left+1);
}
return res;
}
}24、
给定两个大小为 m 和 n 的有序数组 nums1和 nums2。
请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。
你可以假设 nums1 和 nums2 不会同时为空。
示例 1:
nums1 = [1, 3]
nums2 = [2]
则中位数是 2.0示例 2:
nums1 = [1, 2]
nums2 = [3, 4]
则中位数是 (2 + 3)/2 = 2.5
class Solution {
public double findMedianSortedArrays(int[] nums1, int[] nums2) {
if(nums1==null||nums1.length==0){
return nums2.length % 2==0? (double)(nums2[((nums2.length+1)/2-1)] +
nums2[(nums2.length+1)/2])/2:
(double)(nums2[(nums2.length+1)/2 - 1]);
}
if(nums2==null||nums2.length==0){
return nums1.length%2==0?
(double)(nums1[(nums1.length+1)/2 - 1] + nums1[(nums1.length+1)/2])/2
:(double)(nums1[(nums1.length+1)/2 - 1]);
}
int[] news = new int[nums1.length+nums2.length];
int index1=0,index2=0,newsindex=0;
while(index1
25、给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。
说明:
- 初始化 nums1 和 nums2 的元素数量分别为 m 和 n。
- 你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。
示例:
输入:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6], n = 3
输出: [1,2,2,3,5,6]class Solution {
public void merge(int[] nums1, int m, int[] nums2, int n) {
int index = m + n - 1;
int index1 = m - 1;
int index2 = n - 1;
while (index1 >= 0 && index2 >=0) {
if (nums1[index1] > nums2[index2]) {
nums1[index--] = nums1[index1--];
} else
{
nums1[index--] = nums2[index2--];
}
}
while (index1 >= 0) {nums1[index--] = nums1[index1--];}
while (index2 >= 0) {nums1[index--] = nums2[index2--];}
}
}26、
给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
示例 1：
输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。示例 2：
输入: "cbbd"
输出: "bb"
class Solution {
int start = 0 , maxLen = 0 ;
public String longestPalindrome(String s) {
if( s.length() == 0 ){
return s ;
}
for(int i=0 ; i=0 && right 27、给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
示例1：
输入: 123
输出: 321示例2：
输入: -123
输出: -321示例3：
输入: 120
输出: 21注意:
假设我们的环境只能存储得下32位的有符号整数，则其数值范围为[−2^31, 2^31 − 1]。请根据这个假设，如果反转后整数溢出那么就返回0。
class Solution {
public int reverse(int x) {
long res = 0 ;
while(x!=0){
//获取最低位
res =res*10 + x%10;
//在原数上移除地位
x=x/10;
//判断是否溢出
if(res>Integer.MAX_VALUE||res27、判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
示例 1:
输入: 121
输出: true示例 2:
输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。示例 3:
输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。class Solution {
public boolean isPalindrome(int x) {
if(x>=0&&x<=9){
return true;
}
if(x<0){
return false;
}
int sum=0;
int num=x;
while(num!=0){
sum = sum*10 + num%10;
num = num /10 ;
}
if(sum == x ){
return true;
}else{
return false;
}
}
}
28、
罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。
字符 数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。
通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
I可以放在V(5) 和X(10) 的左边，来表示 4 和 9。X可以放在L(50) 和C(100) 的左边，来表示 40 和 90。C可以放在D(500) 和M(1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。
示例 1:
输入: "III"
输出: 3示例 2:
输入: "IV"
输出: 4示例 3:
输入: "IX"
输出: 9示例 4:
输入: "LVIII"
输出: 58
解释: L = 50, V= 5, III = 3.示例 5:
输入: "MCMXCIV"
输出: 1994
解释: M = 1000, CM = 900, XC = 90, class Solution {
public int romanToInt(String s) {
//判断字符串是否为空
if(s==null||s.length()==0){
return -1;
}
//把罗马数字一一对应到整数 放在HashMap中
HashMap map= new HashMap();
map.put('I', 1);
map.put('V', 5);
map.put('X', 10);
map.put('L', 50);
map.put('C', 100);
map.put('D', 500);
map.put('M', 1000);
int len = s.length();
//个位另外计算，
int result = map.get(s.charAt(len-1));
//最后一位，往前一步一步加。遇到特殊情况减
for(int i = len-2 ;i>=0 ; i--){
//
if(map.get(s.charAt(i))>=map.get(s.charAt(i+1))){
result=result+map.get(s.charAt(i));
}else{
////当前一个数值小于后一个，进行减法。
result=result-map.get(s.charAt(i));
}
}
return result;
}
} 29、
罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。
字符 数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。
通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
I可以放在V(5) 和X(10) 的左边，来表示 4 和 9。X可以放在L(50) 和C(100) 的左边，来表示 40 和 90。C可以放在D(500) 和M(1000) 的左边，来表示 400 和 900。
给定一个整数，将其转为罗马数字。输入确保在 1 到 3999 的范围内。
示例 1:
输入: 3
输出: "III"示例 2:
输入: 4
输出: "IV"示例 3:
输入: 9
输出: "IX"示例 4:
输入: 58
输出: "LVIII"
解释: L = 50, V = 5, III = 3.示例 5:
输入: 1994
输出: "MCMXCIV"
解释: M = 1000, CM = 900, XC = 90, IV = 4.class Solution {
public String intToRoman(int num) {
// StringBuffer 是一个容器，长度可变，可以直接操作字符串
StringBuffer ans = new StringBuffer();
int[] vals = {1000,900,500,400,100,90,50,40,10,9,5,4,1};
String[] romans = {"M", "CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"};
for(int i = 0 ; i < vals.length ; i++ ){
while(num >= vals[i]){
//append(); //将指定数据加在容器末尾,返回值也是StringBuffer
ans.append(romans[i]);
num=num-vals[i];
}
}
//用toString方法变为字符串
return ans.toString();
}
}30、
给定 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
说明：你不能倾斜容器，且 n 的值至少为 2。
图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
示例:
输入: [1,8,6,2,5,4,8,3,7]
输出: 49class Solution {
public int maxArea(int[] height) {
int maxArea = 0 , l = 0 , r = height.length - 1 ;
while(l31、
给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。
例如，给定数组 nums = [-1，2，1，-4], 和 target = 1.
与 target 最接近的三个数的和为 2. (-1 + 2 + 1 = 2).
class Solution {
public int threeSumClosest(int[] nums, int target) {
Arrays.sort(nums);
int ans = nums[0] + nums[1] + nums[2] ;
for(int i = 0 ; i < nums.length ; i++){
int start = i + 1 , end = nums.length - 1 ;
while(start < end){
int sum = nums[start] +nums[i] +nums[end];
if(Math.abs(target-sum) < Math.abs(target-ans)){
ans = sum;
}
if(sum > target){
end--;
}else if(sum
32、
给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
注意：
答案中不可以包含重复的四元组。
示例：
给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。
满足要求的四元组集合为：
[
[-1, 0, 0, 1],
[-2, -1, 1, 2],
[-2, 0, 0, 2]
]
class Solution {
public List> fourSum(int[] nums, int target) {
//用来存放数组的数组。里面的小数组是 [-1, 0, 0, 1]， List>存放许多这样的小数组
List> result = new ArrayList<>();
//进行排序，这是必须的第一步
Arrays.sort(nums);
for(int i = 0 ; i < nums.length ; i++){
// 去除指针i可能的重复情况
if(i != 0 && nums[i]==nums[i-1]){
continue;
}
for(int j = i+1 ; j < nums.length ; j++){
// 去除指针i可能的重复情况
if(j != i+1 && nums[j]==nums[j-1]){
continue;
}
int left = j+1 ;
int right = nums.length - 1 ;
while(left < right){
// 不满足条件或者重复的，继续遍历
if(left != j+1 && nums[left] == nums[left-1] || nums[i] + nums[j] + nums[left] + nums[right] < target){
left++;
} else if ((right != nums.length -1 && nums[right] == nums[right + 1]) || nums[i] + nums[j] + nums[left] + nums[right] > target) {
right --;
}else {
//小数组存放在list
List list = new ArrayList<>();
list.add(nums[i]);
list.add(nums[j]);
list.add(nums[left]);
list.add(nums[right]);
result.add(list);
//
left++;
right--;
}
}
}
}
return result;
}
}
33、
将一个给定字符串根据给定的行数，以从上往下、从左到右进行 Z 字形排列。
比如输入字符串为 "LEETCODEISHIRING" 行数为 3 时，排列如下：
L C I R
E T O E S I I G
E D H N之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如："LCIRETOESIIGEDHN"。
请你实现这个将字符串进行指定行数变换的函数：
string convert(string s, int numRows);示例 1:
输入: s = "LEETCODEISHIRING", numRows = 3
输出: "LCIRETOESIIGEDHN"示例 2:
输入: s = "LEETCODEISHIRING", numRows = 4
输出: "LDREOEIIECIHNTSG"
解释:
L D R
E O E I I
E C I H N
T S G
参考：https://www.cnblogs.com/springfor/p/3889414.htmlif(s == null || s.length()==0 || nRows <=0)
3 return "";
4 if(nRows == 1)
5 return s;
6
7 StringBuilder res = new StringBuilder();
8 int size = 2*nRows-2;
9 for(int i=0;i34、
将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例：
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4
class Solution {
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
if(l1==null){
return l2 ;
}
if(l2==null){
return l1 ;
}
if(l1.val35、
给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
示例 1:
给定数组 nums = [1,1,2],
函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。
你不需要考虑数组中超出新长度后面的元素。示例 2:
给定 nums = [0,0,1,1,1,2,2,3,3,4],
函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。
你不需要考虑数组中超出新长度后面的元素。说明:
为什么返回数值是整数，但输出的答案是数组呢?
请注意，输入数组是以“引用”方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}思路：
需要做两件事：
统计数组中不同数字数量k；
修改数组前k个元素为这些不同数字。
由于数组已经完成排序，因此设定第一个指针i，遍历数组，每遇到nums[i] != nums[i - 1],就说明遇到了新的不同数字，记录之；
设定第二个指针k，有两个用途：
记录不同数字的数量；
每遇到新的不同数字，作为修改数组元素的index。
最终，返回k即可。
class Solution {
public int removeDuplicates(int[] nums) {
if(nums.length==0){
return 0 ;
}
int k = 1 ;
for(int i = 1 ; i < nums.length ; i++){
if(nums[i] != nums[i-1]){
nums[k]=nums[i];
k++;
}
}
return k ;
}
}36、
给定一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例 1:
给定 nums = [3,2,2,3], val = 3,
函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。
你不需要考虑数组中超出新长度后面的元素。示例 2:
给定 nums = [0,1,2,2,3,0,4,2], val = 2,
函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。
注意这五个元素可为任意顺序。
你不需要考虑数组中超出新长度后面的元素。说明:
为什么返回数值是整数，但输出的答案是数组呢?
请注意，输入数组是以“引用”方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}思路
既然问题要求我们就地删除给定值的所有元素，我们就必须用 O(1)O(1) 的额外空间来处理它。如何解决？我们可以保留两个指针 ii 和 jj，其中 ii 是慢指针，jj 是快指针。
算法
当 nums[j]nums[j] 与给定的值相等时，递增 jj 以跳过该元素。只要 nums[j] \neq valnums[j]
=val，我们就复制 nums[j]nums[j] 到 nums[i]nums[i] 并同时递增两个索引。重复这一过程，直到 jj 到达数组的末尾，该数组的新长度为 ii。
该解法与 删除排序数组中的重复项 的解法十分相似。
class Solution {
public int removeElement(int[] nums, int val) {
int i = 0 ;
for(int j = 0 ; j < nums.length; j++){
if(nums[j]!=val){
//把不重复的记录下来
nums[i]=nums[j];
i++;
}
}
return i ;
}
}35、实现 strStr() 函数。
给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。
示例 1:
输入: haystack = "hello", needle = "ll"
输出: 2示例 2:
输入: haystack = "aaaaa", needle = "bba"
输出: -1说明:
当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。
对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与C语言的 strstr() 以及 Java的 indexOf() 定义相符。
思路：
设置两个指针i和j，分别用于指向主串(haystack)和模式串(needle)
从左到右开始一个个字符匹配
如果主串和模式串的两字符相等，则i和j同时后移比较下一个字符
如果主串和模式串的两字符不相等，就跳回去，即模式串向右移动，同时模式串指针归零(i = 1; j = 0)
所有字符匹配结束后，如果模式串指针指到串尾(j = needle.length)，说明完全匹配，此时模式串出现的第一个第一个位置为：i - j
链接：https://leetcode-cn.com/problems/two-sum/solution/kmpsuan-fa-shi-xian-by-phantom_eve/
class Solution {
public int strStr(String haystack, String needle) {
char[] hayArr = haystack.toCharArray();
char[] needArr = needle.toCharArray();
int i = 0; //主串(haystack)的位置
int j = 0; //模式串(needle)的位置
while (i < hayArr.length && j < needArr.length) {
if (hayArr[i] == needArr[j]) { // 当两个字符相等则比较下一个
i++;
j++;
} else {
i = i - j + 1; // 一旦不匹配，i后退
j = 0; // j归零
}
}
if (j == needArr.length) { //说明完全匹配
return i - j;
} else {
return -1;
}
}
}36、
给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。
'.' 匹配任意单个字符
'*' 匹配零个或多个前面的那一个元素所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。
说明:
s可能为空，且只包含从a-z的小写字母。p可能为空，且只包含从a-z的小写字母，以及字符.和*。
示例 1:
输入:
s = "aa"
p = "a"
输出: false
解释: "a" 无法匹配 "aa" 整个字符串。示例 2:
输入:
s = "aa"
p = "a*"
输出: true
解释: 因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此，字符串 "aa" 可被视为 'a' 重复了一次。示例 3:
输入:
s = "ab"
p = ".*"
输出: true
解释: ".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。示例 4:
输入:
s = "aab"
p = "c*a*b"
输出: true
解释: 因为 '*' 表示零个或多个，这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。示例 5:
输入:
s = "mississippi"
p = "mis*is*p*."
输出: falseclass Solution {
public boolean isMatch(String s, String p) {
return s.matches(p);
}
}
37、给出 n 代表生成括号的对数，请你写出一个函数，使其能够生成所有可能的并且有效的括号组合。
例如，给出 n = 3，生成结果为：
[
"((()))",
"(()())",
"(())()",
"()(())",
"()()()"
]1、删除一个字符串中出现最少的那个字符及其空格，例如aaddddd ccccccccccccc 结果dddddccccccccccccc
package com.company;
import java.util.*;
public class Main1 {
public static void main(String[] args) {
// write your code here
Scanner scanner=new Scanner(System.in);
while(true) {
String a = scanner.nextLine();
findmin(a);
System.out.println();
}
}
public static void findmin(String str){
Map map = new HashMap<>();
for(int i=0 ; i> mapSet = map.entrySet();
Iterator> iter = mapSet.iterator();
int min=str.length();
List listMin = new ArrayList<>();
while (iter.hasNext()){
Map.Entry entry = iter.next();
if(entry.getValue() < min) {
min = entry.getValue();
}
}
for(Map.Entry entry : mapSet){
if(entry.getValue().equals(min)){
listMin.add(entry.getKey());
}
}
System.out.println(min);
System.out.println(listMin);
for(int j=0;j 2 例如：120=2*2*3*3*5 返回5 ，分解成质数的数目
package com.company;
public class ZhiShu {
static int count = 1;
public static void main(String[] args){
fenJieZhiShu(120);
System.out.println(count);
}
private static void fenJieZhiShu(int a){
for(int i = 2; i<=a; i++){
if(a%i==0){
a/= i;
count++;
}
}
}
}
3、一个字符串中出现最多字符的字串的数目输出。例如：ada 2
package com.company;
import java.util.*;
public class Main {
public static void main(String[] args) {
// write your code here
Scanner scanner=new Scanner(System.in);
String a= scanner.next();
System.out.println(findmax(a));
}
public static int findmax(String str){
Map map = new HashMap<>();
for(int i=0 ; i> mapSet = map.entrySet();
// Iterator> iter = mapSet.iterator();
// int max=0;
// while (iter.hasNext()){
// Map.Entry entry = iter.next();
// if(entry.getValue()>max){
// max=entry.getValue();
// }
// }
return max;
}
}