added Find Lucky Integer in an Array (easy)

Author: minhyeong-joe

Easy/FindLuckyIntegerInArray/README.md

@@ -0,0 +1,40 @@
+
+# Find Lucky Integer in an Array
+[Leetcode Link](https://leetcode.com/problems/find-lucky-integer-in-an-array/)
+
+## Problem:
+
+Given an array of integers `arr`, a lucky integer is an integer which has a frequency in the array equal to its value.
+
+Return *a lucky integer* in the array. If there are multiple lucky integers return the **largest** of them. If there is no lucky integer return **-1**.
+
+## Example:
+
+```
+Input: arr = [2,2,3,4]
+Output: 2
+Explanation: The only lucky number in the array is 2 because frequency[2] == 2.
+```
+```
+Input: arr = [1,2,2,3,3,3]
+Output: 3
+Explanation: 1, 2 and 3 are all lucky numbers, return the largest of them.
+```
+```
+Input: arr = [2,2,2,3,3]
+Output: -1
+Explanation: There are no lucky numbers in the array.
+```
+```
+Input: arr = [5]
+Output: -1
+```
+```
+Input: arr = [7,7,7,7,7,7,7]
+Output: 7
+```
+
+## Note:
+
+- `1 <= arr.length <= 500`
+- `1 <= arr[i] <= 500`

Easy/FindLuckyIntegerInArray/Solution.java

@@ -0,0 +1,55 @@
+package Easy.FindLuckyIntegerInArray;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Solution {
+ // Array with size 500 method
+ // Leetcode submission: 1ms (faster than 99.45%), 39.2MB (less than 65.26%)
+ public int findLucky(int[] arr) {
+ // Using HashMap as frequency counter is good
+ // but we can simply use array of size int[max] to reduce memory usage
+ int[] frequency = new int[500];
+ for (int num: arr) {
+ frequency[num-1]++;
+ }
+ // System.out.println(Arrays.toString(frequency));
+ // find the largest lucky number
+ for (int i = frequency.length-1; i >= 0; i--) {
+ if (i+1 == frequency[i]) {
+ return i+1;
+ }
+ }
+ return -1;
+ }
+
+ // HashMap method
+ // Leetcode submission: 4ms (faster than 44.68%), 39.5MB (less than 42.53%)
+ // public int findLucky(int[] arr) {
+ // Map<Integer, Integer> frequency = new HashMap<>();
+ // for (int num: arr) {
+ // if (frequency.containsKey(num)) {
+ // frequency.put(num, frequency.get(num)+1);
+ // } else {
+ // frequency.put(num, 1);
+ // }
+ // }
+ // // System.out.println(frequency.toString());
+ // List<Integer> luckyNumbers = new ArrayList<>();
+ // frequency.forEach((k,v) -> {
+ // if (k == v) {
+ // luckyNumbers.add(k);
+ // }
+ // });
+ // try {
+ // // System.out.println(Collections.max(luckyNumbers));
+ // return Collections.max(luckyNumbers);
+ // } catch (Exception e) {
+ // return -1;
+ // }
+ // }
+}

Easy/FindLuckyIntegerInArray/TestDriver.java

@@ -0,0 +1,33 @@
+package Easy.FindLuckyIntegerInArray;
+
+import java.util.Arrays;
+
+public class TestDriver {
+ public static void main(String[] args) {
+ Solution sol = new Solution();
+ int[] arr1 = {2, 2, 3, 4};
+ System.out.println("Input: arr = " + Arrays.toString(arr1));
+ System.out.println("Output: " + sol.findLucky(arr1));
+ System.out.println();
+
+ int[] arr2 = {1,2,2,3,3,3};
+ System.out.println("Input: arr = " + Arrays.toString(arr2));
+ System.out.println("Output: " + sol.findLucky(arr2));
+ System.out.println();
+
+ int[] arr3 = {2, 2, 2, 3, 3};
+ System.out.println("Input: arr = " + Arrays.toString(arr3));
+ System.out.println("Output: " + sol.findLucky(arr3));
+ System.out.println();
+
+ int[] arr4 = {5};
+ System.out.println("Input: arr = " + Arrays.toString(arr4));
+ System.out.println("Output: " + sol.findLucky(arr4));
+ System.out.println();
+
+ int[] arr5 = {7, 7, 7, 7, 7, 7, 7};
+ System.out.println("Input: arr = " + Arrays.toString(arr5));
+ System.out.println("Output: " + sol.findLucky(arr5));
+ System.out.println();
+ }
+}

Easy/ShortedUnsortedContinuousSubarray/Solution.java

@@ -1,3 +1,5 @@
+package Easy.ShortedUnsortedContinuousSubarray;
+
 import java.util.Arrays;
 
 // Sort array and check the length of unmatching subarray

Easy/ShortedUnsortedContinuousSubarray/TestDriver.java

@@ -1,3 +1,5 @@
+package Easy.ShortedUnsortedContinuousSubarray;
+
 import java.util.Arrays;
 
 class TestDriver {

README.md

@@ -28,6 +28,7 @@ Languages used: Java and Python
  - [Majority Element](Easy/MajorityElement)
  - [Reshape the Matrix](Easy/ReshapeMatrix)
  - [Shortest Unsorted Continuous Subarray](Easy/ShortedUnsortedContinuousSubarray)
+ - [Find Lucky Integer in an Array](Easy/FindLuckyIntegerInArray)
 - Medium
  - [Minimum Add to Make Parentheses Valid](Medium/MinimumAddtoMakeParenthesesValid)
  - [Distribute Coins in Binary Tree](Medium/DistributionCoinsInBinaryTree)