389. 找不同 & 179. 最大数

 

41. 缺失的第一个正数

给定一个未排序的整数数组，找出其中没有出现的最小的正整数。

示例 1:

输入: [1,2,0]
输出: 3
示例 2:

输入: [3,4,-1,1]
输出: 2
示例 3:

输入: [7,8,9,11,12]
输出: 1
说明:

你的算法的时间复杂度应为O(n)，并且只能使用常数级别的空间。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/first-missing-positive 

public  static int firstMissingPositive(int[] nums) {
	    	if(nums == null || nums.length == 0){
	    		return 1;
	    	}
	        Arrays.sort(nums);
	        int max = 1;
	        HashSet<Integer> set = new HashSet<>();
	        for (int i = 0; i < nums.length; i++) {
				set.add(nums[i]);
			}
	        for (int i = 0; i <= nums.length -1 ; i++) {
				if(set.contains(max)){
					max++;
				}else{
					break;
				}
			}
	    return max;
	  }

 

179. 最大数

给定一组非负整数，重新排列它们的顺序使之组成一个最大的整数。

示例 1:

输入: [10,2]
输出: 210
示例 2:

输入: [3,30,34,5,9]
输出: 9534330
说明: 输出结果可能非常大，所以你需要返回一个字符串而不是整数。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/largest-number
 

class Solution {
    public String largestNumber(int[] nums) {
	     
	  
	        ArrayList<Integer> list = new ArrayList<>();
	        for (int i = 0; i < nums.length; i++) {
				list.add(nums[i]);
			}
	        Collections.sort(list, (t1,t2)->{
	        	String s1 = t1 +""+ t2;
	        	String s2 = t2  +""+ t1;
	        	return  s2.compareTo(s1);
	        });
	        if(list.get(0) == 0){
	        	return "0";
	        }
	        StringBuilder sb = new StringBuilder();
	        for (int i = 0; i < list.size(); i++) {
				sb.append(list.get(i));
			}
	      return   sb.toString() ;
 	    
 	    
    }
}

389. 找不同

给定两个字符串 s 和 t，它们只包含小写字母。

字符串 t 由字符串 s 随机重排，然后在随机位置添加一个字母。

请找出在 t 中被添加的字母。

 

示例:

输入：
s = "abcd"
t = "abcde"

输出：
e

解释：
'e' 是那个被添加的字母。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-the-difference
 

   
   public  static char findTheDifference(String s, String t) { 
	   s = s + t;
	   int  tar  =0 ;
	   for (int i = 0; i <  s.length(); i++) {
		   tar ^= s.charAt(i);
	   }
	   return (char) tar;
   }

190. 颠倒二进制位

颠倒给定的 32 位无符号整数的二进制位。

 

示例 1：

输入: 00000010100101000001111010011100
输出: 00111001011110000010100101000000
解释: 输入的二进制串 00000010100101000001111010011100 表示无符号整数 43261596，
      因此返回 964176192，其二进制表示形式为 00111001011110000010100101000000。
示例 2：

输入：11111111111111111111111111111101
输出：10111111111111111111111111111111
解释：输入的二进制串 11111111111111111111111111111101 表示无符号整数 4294967293，
      因此返回 3221225471 其二进制表示形式为 10101111110010110010011101101001。
 

提示：

请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。
在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在上面的 示例 2 中，输入表示有符号整数 -3，输出表示有符号整数 -1073741825。
 

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-bits
 

public class Solution {
    // you need treat n as an unsigned value
    public int reverseBits(int n) {
        
        int result = 0;
        for (int i = 0; i <= 31; i++) {
            // 1. 将给定的二进制数,由低到高位逐个取出
            // 1.1 右移 i 位,
            int tmp = n >> i;
            // 1.2  取有效位
            tmp = tmp & 1;
            // 2. 然后通过位运算将其放置到反转后的位置.
            tmp = tmp << (31 - i);
            // 3. 将上述结果再次通过运算结合到一起
            result |= tmp;
        }
        return result;
    }
}

202. 快乐数

编写一个算法来判断一个数是不是“快乐数”。

一个“快乐数”定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。如果可以变为 1，那么这个数就是快乐数。

示例: 

输入: 19
输出: true
解释: 
 

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/happy-number
 

class Solution {
 public boolean isHappy(int n) {
      
    	while( n != 89){
    		n= sum(n);
    		if (n == 1) {
				return true;
			} 
    	}
    	return false;
    	
    }
   
    public int sum(int n){
    	int res = 0;
    	while(n != 0){
    		res += (n% 10)*(n % 10);
    		n /= 10;
    	}
    	return res;
    }
}

204. 计数质数

统计所有小于非负整数 n 的质数的数量。

示例:

输入: 10
输出: 4
解释: 小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7 。

class Solution {
 public int countPrimes(int n) {

        int[] nums = new int[n+1];
        for (int i = 1; i <= n; i++) {
            nums[i] = 1;
        }
        for (int i = 2; i < n; i++) {
            //如果当前数为质数
            if (nums[i] == 1) {
                //将对应数的倍数变为0
                for (int j = 2; i * j < n; j++) {
                    nums[i * j] = 0;
                }
            }
        }
        //遍历数组，统计值为1的元素个数
        int res = 0;
        for (int i = 2; i < n; i++) {
            if (nums[i] == 1)
                res++;
        }
        return res;
    
    }
}

205. 同构字符串

给定两个字符串 s 和 t，判断它们是否是同构的。

如果 s 中的字符可以被替换得到 t ，那么这两个字符串是同构的。

所有出现的字符都必须用另一个字符替换，同时保留字符的顺序。两个字符不能映射到同一个字符上，但字符可以映射自己本身。

示例 1:

输入: s = "egg", t = "add"
输出: true
示例 2:

输入: s = "foo", t = "bar"
输出: false
示例 3:

输入: s = "paper", t = "title"
输出: true
说明:
你可以假设 s 和 t 具有相同的长度。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/isomorphic-strings

class Solution {
    public boolean isIsomorphic(String s, String t) {
       
  
    Map<Character,Character> map = new HashMap<>();
    if(s.length()!=t.length())return false;
    
    for(int i = 0;i<s.length();i++){
        char ss = s.charAt(i);
        char tt = t.charAt(i);
        if(map.containsKey(ss)){
            if(map.get(ss)!=tt)return false;
        }else{
            if(map.containsValue(tt))return false;
            map.put(ss,tt);
        }

    }              
    return true; 
 
    }
}

219. 存在重复元素 II

 

给定一个整数数组和一个整数 k，判断数组中是否存在两个不同的索引 i 和 j，使得 nums [i] = nums [j]，并且 i 和 j 的差的绝对值最大为 k。

示例 1:

输入: nums = [1,2,3,1], k = 3
输出: true
示例 2:

输入: nums = [1,0,1,1], k = 1
输出: true
示例 3:

输入: nums = [1,2,3,1,2,3], k = 2
输出: false

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/contains-duplicate-ii
 

（散列表） 【通过】
思路

用散列表来维护这个k大小的滑动窗口。

算法

 在这个方法里面，我们需要一个支持在常量时间内完成 搜索，删除，插入 操作的数据结构，那就是散列表。 

遍历数组，对于每个元素做以下操作：
              在散列表中搜索当前元素，如果找到了就返回 true。
                在散列表中插入当前元素。
                如果当前散列表的大小超过了 k， 删除散列表中最旧的元素。
返回 false。

作者：LeetCode
链接：https://leetcode-cn.com/problems/contains-duplicate-ii/solution/cun-zai-zhong-fu-yuan-su-ii-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

class Solution {
    public boolean containsNearbyDuplicate(int[] nums, int k) {
        
    
    	Set<Integer> set = new HashSet<>();
        for (int i = 0; i < nums.length; ++i) {
            if (set.contains(nums[i])) return true;
            set.add(nums[i]);
            if (set.size() > k) {
                set.remove(nums[i - k]);
            }
        }
        return false;
    }
}

 

 

 

 

 

 

 

 

 

 

 

 

 

191. 位1的个数

编写一个函数，输入是一个无符号整数，返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。

 

示例 1：

输入：00000000000000000000000000001011
输出：3
解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 '1'。
示例 2：

输入：00000000000000000000000010000000
输出：1
解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 '1'。
示例 3：

输入：11111111111111111111111111111101
输出：31
解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 '1'。
 提示：

请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。
在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在上面的 示例 3 中，输入表示有符号整数 -3。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/number-of-1-bits
 

public class Solution {
    // you need to treat n as an unsigned value
    public int hammingWeight(int n) {
        
    	
    	int result = 0;
        for (int i = 0; i <= 31; i++) {
            // 1. 将给定的二进制数,由低到高位逐个取出
            // 1.1 右移 i 位,
            int tmp = n >> i;
            // 1.2  取有效位
            result += tmp & 1;
        }
        return result;
    
    
    }
}