一些值得回看的小算法。
最长的连续子数组
子数组数字不重复
int [] arr={1,2,3,4,7}; //输出4
int [] arr1={1,2,3,4,1,2,3,4,5,1}; //输出5
package RecursiveAndDynamic;
/**
* Created by zdmein on 2017/9/2.
* 最长的连续子数组（子数组数字不重复）
* int [] arr={1,2,3,4,7}; 输出4
* int [] arr1={1,2,3,4,1,2,3,4,5,1}; 输出5
*/
public class longestSubArr1 {
public static void main(String [] args){
int [] arr={1,2,3,4,7};
int [] arr1={1,2,3,4,1,2,3,4,5,1};
longestSubArr(arr1);
}
public static void longestSubArr(int [] arr){
if(arr==null||arr.length==0){
return;
}
int len=1;
int maxlen=1;
for(int i=1;i<arr.length;i++){
if(arr[i]==arr[i-1]+1){
len++;
maxlen=Math.max(len,maxlen);
}else {
len=1;
}
}
System.out.println(maxlen);
}
}
删除链表中的元素
样例
给出链表 1->2->3->3->4->5->3, 和 val = 3, 你需要返回删除3之后的链表：1->2->4->5。
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
public class Solution {
/**
* @param head a ListNode
* @param val an integer
* @return a ListNode
*/
public ListNode removeElements(ListNode head, int val) {
// Write your code here
if(head==null) return head;
ListNode p=head,q=head.next;
while(q!=null){
if(q.val==val){
p.next=q.next;
q=q.next;
}else{
p=p.next;
q=q.next;
}
}
if(head.val==val) head=head.next;
return head;
}
}
求n的阶乘结果后有几个零
//结果后的零是由n中的5组成的，多少个5就有多少个0，所以只需要统计有多少5就可以了
public class Solution {
public int trailingZeroes(int n) {
int rs=0;
while(n!=0){
rs+=n/5;
n/=5;
}
return rs;
}
}
统计小于n的素数个数
我写的用 n/2;
改进为 Math.sqrt(n)；
复杂度还是高了点；
public class Solution {
public int countPrimes(int n) {
boolean [] notPrimes = new boolean[n];
int count =0;
for(int i=2;i<n;i++){
if(notPrimes[i]==false){
count++;
for(int j=2;i*j<n;j++){
notPrimes[i*j]=true;
}
}
}
return count;
}
}
这个算法降低了复杂度，值得学习！！
同构字符串
Given "egg", "add", return true.
Given "foo", "bar", return false.
Given "paper", "title", return true.
即结构相同
我的
public class Solution {
public boolean isIsomorphic(String s, String t) {
int [] count=new int [s.length()];
for(int i=0;i<s.length();i++){
count[i]=s.charAt(i)-t.charAt(i);
for(int j=0;j<i;j++){
if(s.charAt(i)==s.charAt(j)){
if(count[i]!=count[j]){
return false;
}
}
if(t.charAt(i)==t.charAt(j)){
if(count[i]!=count[j]){
return false;
}
}
}
}
return true;
}
}
降低复杂度,用数组装字符，很重要的思想！
public class Solution {
public boolean isIsomorphic(String s, String t) {
int [] m=new int [256];
int [] n=new int [256];
for(int i=0;i<s.length();i++){
if(m[s.charAt(i)]!=n[t.charAt(i)]){
return false;
}
m[s.charAt(i)]=i+1; //关键部分，通过i，实现错位
n[t.charAt(i)]=i+1; //不同位置加的值不同
}
return true;
}
}
组合成最大的数
given [3, 30, 34, 5, 9], the largest formed number is 9534330.
[0,0]，输出0.
public class Solution {
public String largestNumber(int[] nums) {
String [] rs=new String[nums.length];
String sb=new String();
for(int i=0;i<nums.length;i++){
rs[i]=String.valueOf(nums[i]);
}
for(int j=0;j<nums.length-1;j++){
for(int i=0;i<nums.length-j-1;i++){
String s1=rs[i]+rs[i+1];
String s2=rs[i+1]+rs[i];
if(s2.compareTo(s1)>0){
String temp=rs[i];
rs[i]=rs[i+1];
rs[i+1]=temp;
}
}
}
for(int i=0;i<nums.length;i++){
sb+=rs[i];
}
if(sb.charAt(0) == '0')
return "0";
return sb;
}
}
判断n是不是2的幂
只需要将n转化为二进制，然后计算二进制位里面有多少个1，如果计数为1，那么n是2的幂
快乐数
写一个算法来判断一个数是不是"快乐数"。
一个数是不是快乐是这么定义的：对于一个正整数，每一次将该数替换为他每个位置上的数字的平方和，然后重复这个过程直到这个数变为1，或是无限循环但始终变不到1。如果可以变为1，那么这个数就是快乐数。
您在真实的面试中是否遇到过这个题？ Yes
样例
19 就是一个快乐数。
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1
public class Solution {
/**
* @param n an integer
* @return true if this is a happy number or false
*/
public boolean isHappy(int n) {
// Write your code here
Set<Integer> inLoop = new HashSet<Integer>();
int squareSum,remain;
while (inLoop.add(n)) {
squareSum = 0;
while (n > 0) {
remain = n%10;
squareSum += remain*remain;
n /= 10;
}
if (squareSum == 1)
return true;
else
n = squareSum;
}
return false;
}
}
Add Binary
Given two binary strings, return their sum (also a binary string).
For example,
a = "11"
b = "1"
Return "100".
package leetCode;
public class Temp
{
public static void main(String [] args)
{
String a="11";
String b="1";
System.out.print(addBinary(a,b));
}
public static String addBinary(String a, String b) {
if(a == null || a.isEmpty())
return b;
if(b == null || b.isEmpty())
return a;
StringBuilder stb = new StringBuilder();
int i = a.length() - 1;
int j = b.length() - 1;
int aBit;
int bBit;
int carry = 0;
int result;
while(i >= 0 || j >= 0 || carry == 1) {
aBit = (i >= 0) ? Character.getNumericValue(a.charAt(i--)) : 0;
bBit = (j >= 0) ? Character.getNumericValue(b.charAt(j--)) : 0;
result = aBit ^ bBit ^ carry;
carry = ((aBit + bBit + carry) >= 2) ? 1 : 0;
stb.append(result);
}
return stb.reverse().toString();
}
}
徒手开平方
·牛顿法-直线逼近原理
package leetCode;
public class Temp
{
public static void main(String [] args)
{
int a=7;
System.out.print(mySqrt(a));
}
public static int mySqrt(int x) {
long rs=x;
while(rs*rs>x){
rs=(rs+x/rs)/2;
}
return (int)rs;
}
}
# 数学之美 —— 0x5f375a86
float InvSqrt(float x)
{
float xhalf = 0.5fx;
int i = (int)&x; // get bits for floating VALUE
i = 0x5f375a86- (i>>1); // gives initial guess y0
x = (float)&i; // convert bits BACK to float
x = x(1.5f-xhalfxx); // Newton step, repeating increases accuracy
return x;
}
# 两数字字符串相加
Given two non-negative integers num1 and num2 represented as string, return the sum of num1 and num2.
Note:
The length of both num1 and num2 is < 5100.
Both num1 and num2 contains only digits 0-9.
Both num1 and num2 does not contain any leading zero.
You must not use any built-in BigInteger library or convert the inputs to integer directly.
package leetCode;
public class Temp
{
public static void main(String [] args)
{
String a="1001";
String b="1341";
System.out.print(addStrings(a,b));
}
public static String addStrings(String num1, String num2) {
StringBuilder sb=new StringBuilder();
int carry=0;
for(int i=num1.length()-1,j=num2.length()-1;i>=0||j>=0||carry==1;i--,j--){
int x=i<0?0:num1.charAt(i)-'0';
int y=j<0?0:num2.charAt(j)-'0';
sb.append((x+y+carry)%10);
carry=(x+y+carry)/10;
}
return sb.reverse().toString();
}
}
# 字符串中出现多少字母
存一下有多少个非0次出现的
int nonZero = 0;
for (int i = 0; i < lenb; ++i)
if (++num[b[i] – ‘a’] == 1) ++nonZero;
``
12.单词翻转
``
翻转句子中全部的单词，单词内容不变
例如I’m a student. 变为student. a I’m
in-place翻转 字符串第i位到第j位
while (i < j) swap(s[i++], s[j--]);
有什么用？
翻转整个句子 ： .tneduts a m’I
每个单词单独翻转： student. a I’m
难点？ 如何区分单词？找空格，split
# HashSet
public static int[] intersection(int[] nums1, int [] nums2){
Set set= new HashSet<>();
Set interset=new HashSet<>();
for(int i=0;i<nums1.length;i++){
set.add(nums1[i]); //存入不重复的值
}
for(int i=0;i<nums2.length;i++){
if(set.contains(nums2[i])){ //如果重复上个set数组里的值
interset.add(nums2[i]); //添加上个数组里有的值
}
}
int [] res=new int [interset.size()];
int i=0;
for(Integer num:interset){
res[i++]=num;
}
return res;
}
}
# 350. Intersection of Two Arrays II
Given two arrays, write a function to compute their intersection.
Example:
Given nums1 = [1, 2, 2, 1], nums2 = [2, 2], return [2, 2].
Note:
Each element in the result should appear as many times as it shows in both arrays.
The result can be in any order.
先排序，一个一个对比，相等的才存，不等就小的数组指针加1。
public static int[] intersection(int[] nums1, int [] nums2){
Arrays.sort(nums1);
Arrays.sort(nums2);
int p1=0;
int p2=0;
ArrayList myList= new ArrayList ();
while((p1<nums1.length)&&(p2<nums2.length)){
if(nums1[p1]<nums2[p2]){
p1++;
}else{
if(nums1[p1]>nums2[p2]){
p2++;
}else{
myList.add(nums1[p1]);
p1++;
p2++;
}
}
}
int[] res= new int [myList.size()];
for(int i=0;i<res.length;i++){
res[i]=myList.get(i); //ArrayList取值方法
}
return res; //转化成正常数组输出
}
# 将字符数组转化为字符串
public static String reverseString(String s) {
char [] rs= new char[s.length()];
for(int i=0;i<s.length();i++){
rs[i]=s.charAt(i);
}
for(int i=0;i<s.length()/2;i++){
char temp=rs[i];
rs[i]=rs[s.length()-i-1];
rs[s.length()-i-1]=temp;
}
return new String(rs); //转化
}
# 不用加号实现两数相加
public int getSum(int a, int b) {
return b == 0 ? a : getSum(a ^ b, (a & b) << 1);
}
合并排序数组
合并两个排序的整数数组A和B变成一个新的数组。
给出A=[1,2,3,4]，B=[2,4,5,6]，返回** [1,2,2,3,4,4,5,6]**
public class Solution {
/*
* @param A: sorted integer array A
* @param B: sorted integer array B
* @return: A new sorted integer array
*/
public int[] mergeSortedArray(int[] A, int[] B) {
// write your code here
int indexA=0;
int indexB=0;
int []C =new int [A.length+B.length];
int indexC=0;
while(indexA!=A.length && indexB!=B.length) {
if (A[indexA] < B[indexB]) {
C[indexC++]=A[indexA++];
}else if (A[indexA] > B[indexB]) {
C[indexC++]=B[indexB++];
}else {
C[indexC++]=A[indexA++];
C[indexC++]=B[indexB++];
}
}
if(indexA==A.length && indexB!=B.length){
for(int i=indexB;i<B.length;i++){
C[indexC++]=B[i];
}
}
if(indexA!=A.length && indexB==B.length){
for(int i=indexA;i<A.length;i++){
C[indexC++]=A[i];
}
}
return C;
}
}
- 写代码：多线程实现从A,B,C三个文件中读取文件放到D文件中，优化：如何同步实现。
写一个单例模式，什么时候用到
在某些情况下，有些对象只需要一个就可以了，即每个类只需要一个实例。
单例模式的作用就是保证在整个应用程序的生命周期中，任何一个时刻，单例类的实例都只存在一个。
实现一个单例模式：
public class Test{
private Test(){}
private static Test uniqueInstance = new Test();
public static Test getInstence(){
return uniqueInstance;
}
}
由于在使用前就创建好了对象，因此，可以在多线程环境下使用这种方法。
装饰者模式是什么，举例
装饰者模式通过组合的方式扩展对象的特性，这种方式允许我们在任何时候对对象的功能
进行扩展，甚至是运行时扩展，而若我们用继承来完成对类的扩展，则只能在编译阶段实现
，所以在某些时候装饰者模式比继承更灵活。
特征：
- 装饰者和被装饰者的对象有着共同的超类
- 我们可以用多个装饰者修饰一个对象
- 可以用修饰过的对象替代代码中的原对象
- 一个对象在任何时候都可以被装饰，甚至是运行时
应用场景：
一家奶茶店，一杯奶茶是10元；
如果加糖+2、加奶+3、加葡萄+5元...
如果写类去继承，会要写n多个
如果用装饰就直接在类里加价钱
return mTea.getPrice()+2;
return mTea.getPrice()+15;
return mTea.getPrice()+20;
-----
mTea = new SimpleTea();
mTea = new SugarDecorator(mTea);
mTea = new MilkDecorator(mTea);
int price1 = mTea.getPrice();
System.out.println("price1="+price1);
写代码：找出字符数组中第一次只出现三次的字符
package Array;
/**
* Created by zdmein on 2017/9/6.
* 找出字符数组中第一次只出现三次的字符
思路：
1、统计各字符出现次数
2、遍历字符串，如果出现字符次数为3则输出该字符并跳出循环；否则如果不存在则输出" . "
*/
public class ThreeChar1 {
public static void main(String [] args){
String str="abesabjdwsjibuhfrsadfesdsferewh";
char [] chars=str.toCharArray();
ThreeChar(chars);
}
public static void ThreeChar(char [] chars){
if(chars==null||chars.length==0){
System.out.println(".");
}
int [] res=new int[256];
for(int i=0;i<chars.length;i++){
res[chars[i]]++;
}
for(int i=0;i<chars.length;i++){
if(res[chars[i]]==3){
System.out.println(chars[i]);
break;
}
}
}
}
验证身份证是否正确
身份证号码验证
1、号码的结构
公民身份号码是特征组合码，由十七位数字本体码和一位校验码组成。排列顺序从左至右依次为：六位数字地址码，
八位数字出生日期码，三位数字顺序码和一位数字校验码。
2、地址码(前六位数）
表示编码对象常住户口所在县(市、旗、区)的行政区划代码，按GB/T2260的规定执行。
3、出生日期码（第七位至十四位）
表示编码对象出生的年、月、日，按GB/T7408的规定执行，年、月、日代码之间不用分隔符。
4、顺序码（第十五位至十七位）
表示在同一地址码所标识的区域范围内，对同年、同月、同日出生的人编定的顺序号，
顺序码的奇数分配给男性，偶数分配给女性。
5、校验码（第十八位数）
（1）十七位数字本体码加权求和公式 S = Sum(Ai * Wi), i = 0, , 16 ，先对前17位数字的权求和
Ai:表示第i位置上的身份证号码数字值 Wi:表示第i位置上的加权因子 Wi: 7 9 10 5 8 4 2 1 6 3 7 9 10 5 8 4
2 （2）计算模 Y = mod(S, 11) （3）通过模得到对应的校验码 Y: 0 1 2 3 4 5 6 7 8 9 10 校验码: 1 0
X 9 8 7 6 5 4 3 2
功能：身份证的有效验证
网易笔试：一个合法的括号匹配
给一个合法的括号匹配序列s，找到同样长的所有的括号匹配序列t，
1.t和s不同，但是长度相同
2.t也合法
3.LCS（s,t） 是满足上面两个条件的t中最大的。
eg:
s="(())()"
匹配的有： "()(())"、"((()))"、"()()()"、"(()())"
其中 LCS（"(())()","()(())"）为4，其余都是5，所以输出3
package ProgrammingWritten;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Scanner;
/**
* Created by zdmein on 2017/9/10.
*/
public class NetEase1 {
public static int cnt;
public static HashMap<String,Integer> map = new HashMap<>();
public static void main(String[] args) {
HashMap<Integer,Integer> map2 = new HashMap<>();
Scanner input = new Scanner(System.in);
String str1 = input.nextLine();
// int n = Integer.parseInt(str);
int n2 = str1.length();
int n = (int) n2 / 2;
// StringBuffer bf = new StringBuffer("");
// String str1 = bf.append(str).reverse().toString();
// n += Integer.parseInt(str1);
// System.out.println(n);
ArrayList<String> list = getBracketsOfN(n);
for (String str2 : list) {
if (str1.equals(str2)) {
continue;
}else {
int[][] re = longestCommonSubsequence(str1, str2);
cnt=0;
print(re, str1, str2, str1.length(), str2.length());
map.put(str2, cnt);
}
}
for (Entry<String, Integer> entry : map.entrySet()) {
if (map2.containsKey(entry.getValue())) {
int count=map2.get(entry.getValue());
map2.put(entry.getValue(), ++count);
}
else {
map2.put(entry.getValue(), 1);
}
}
int result = 0;
int max= 0;
for(Entry<Integer, Integer> entry : map2.entrySet()) {
if (max<entry.getKey()) {
result = entry.getValue();
}
}
System.out.println(result);
}
/**
* Given the number N, return all of the correct brackets.
*
* @param n
* @return
*/
@SuppressWarnings("unchecked")
public static ArrayList<String> getBracketsOfN(int n) {
@SuppressWarnings("rawtypes")
ArrayList[] dp = new ArrayList[n + 1];
for (int i = 0; i < dp.length; i++)
dp[i] = new ArrayList<String>();
dp[0].add("");
dp[1].add("()");
if (n == 0)
return dp[0];
if (n == 1)
return dp[1];
int count = 2;
while (count < n + 1) {
ArrayList<String> lcount = dp[count];
for (int i = 0; i < count; i++) {
ArrayList<String> l1 = dp[i];
ArrayList<String> l2 = dp[count - i - 1];
for (int j = 0; j < l1.size(); j++) {
for (int k = 0; k < l2.size(); k++) {
StringBuffer sb = new StringBuffer();
sb.append(l1.get(j));
sb.append("(");
sb.append(l2.get(k));
sb.append(")");
lcount.add(sb.toString());
}
}
}
dp[count++] = lcount;
}
return dp[n];
}
// 假如返回两个字符串的最长公共子序列的长度
public static int[][] longestCommonSubsequence(String str1, String str2) {
int[][] matrix = new int[str1.length() + 1][str2.length() + 1];//建立二维矩阵
// 初始化边界条件
for (int i = 0; i <= str1.length(); i++) {
matrix[i][0] = 0;//每行第一列置零
}
for (int j = 0; j <= str2.length(); j++) {
matrix[0][j] = 0;//每列第一行置零
}
// 填充矩阵
for (int i = 1; i <= str1.length(); i++) {
for (int j = 1; j <= str2.length(); j++) {
if (str1.charAt(i - 1) == str2.charAt(j - 1)) {
matrix[i][j] = matrix[i - 1][j - 1] + 1;
} else {
matrix[i][j] = (matrix[i - 1][j] >= matrix[i][j - 1] ? matrix[i - 1][j]
: matrix[i][j - 1]);
}
}
}
return matrix;
}
//根据矩阵输出LCS
public static void print(int[][] opt, String X, String Y, int i, int j) {
if (i == 0 || j == 0) {
return;
}
if (X.charAt(i - 1) == Y.charAt(j - 1)) {
print(opt, X, Y, i - 1, j - 1);
cnt++;
// System.out.print(X.charAt(i - 1));
} else if (opt[i - 1][j] >= opt[i][j]) {
print(opt, X, Y, i - 1, j);
} else {
print(opt, X, Y, i, j - 1);
}
}
}
滴滴笔试：求解第n个丑数
我们把只包含因子2,3和5的数称为丑数（Ugly Number),求从小到大的顺序第n的丑数，例如6,8都是丑数，但14不是，因为它包含因子7。习惯上我们把1当作第1个丑数
package ProgrammingWritten;
import java.util.Scanner;
/**
* Created by zdmein on 2017/9/10.
*/
public class didi2 {
public static void main(String args[])
{
Scanner cin = new Scanner(System.in);
int n = cin.nextInt();
System.out.println(getugly(n));
}
public static int getugly(int n) {
if(n==0)
return 0;
int[] a = new int[n];
int count = 1;
a[0] = 1;
int num2 = 0;
int num3 = 0;
int num5 = 0;
while(count<n){
int min = min(a[num2]*2,a[num3]*3,a[num5]*5);
a[count] = min;
while(a[num2]*2<=a[count]) num2++;
while(a[num3]*3<=a[count]) num3++;
while(a[num5]*5<=a[count]) num5++;
count++;
}
int result = a[n-1];
return result;
}
public static int min(int a,int b,int c){
int tmp = a>b?b:a;
return tmp>c?c:tmp;
}
}
