Skip to content

Commit d587f17

Browse files
author
yennj12
committed
update 692 java
1 parent a899844 commit d587f17

File tree

3 files changed

+154
-43
lines changed

3 files changed

+154
-43
lines changed

‎leetcode_java/src/main/java/LeetCodeJava/Sort/TopKFrequentWords.java‎

Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -99,6 +99,43 @@ public class TopKFrequentWords {
9999
// return res;
100100
// }
101101

102+
// V0-1
103+
// IDEA: Sort on map key set
104+
public List<String> topKFrequent_0_1(String[] words, int k) {
105+
106+
// IDEA: map sorting
107+
HashMap<String, Integer> freq = new HashMap<>();
108+
for (int i = 0; i < words.length; i++) {
109+
freq.put(words[i], freq.getOrDefault(words[i], 0) + 1);
110+
}
111+
List<String> res = new ArrayList(freq.keySet());
112+
113+
/**
114+
* NOTE !!!
115+
*
116+
* we directly sort over map's keySet
117+
* (with the data val, key that read from map)
118+
*
119+
*
120+
* example:
121+
*
122+
* Collections.sort(res,
123+
* (w1, w2) -> freq.get(w1).equals(freq.get(w2)) ? w1.compareTo(w2) : freq.get(w2) - freq.get(w1));
124+
*/
125+
Collections.sort(res, (x, y) -> {
126+
int valDiff = freq.get(y) - freq.get(x); // sort on `value` bigger number first (decreasing order)
127+
if (valDiff == 0){
128+
// Sort on `key ` with `lexicographically` order (increasing order)
129+
//return y.length() - x.length(); // ?
130+
return x.compareTo(y);
131+
}
132+
return valDiff;
133+
});
134+
135+
// get top K result
136+
return res.subList(0, k);
137+
}
138+
102139
// V1
103140
// IDEA: SORT
104141
// https://leetcode.com/problems/top-k-frequent-words/solutions/1244692/java-solution-by-keerthy0212-1jtv/

‎leetcode_java/src/main/java/dev/workspace6.java‎

Lines changed: 81 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -2356,59 +2356,97 @@ else if (arr[mid] >= arr[mid+1] && arr[mid] >= arr[r]){
23562356
*
23572357
* -> use IDEA 2) first
23582358
*/
2359-
public List<String> topKFrequent(String[] words, int k) {
2360-
2361-
// edge
2362-
if (words.length == 0) {
2363-
return new ArrayList<>();
2364-
}
23652359

2366-
List<String> res = new ArrayList<>();
2367-
Map<String, Integer> map = new HashMap<>();
2368-
// biggest queue
2369-
// Queue<Integer> cntQueue = new LinkedList<>();
23702360

2371-
for (String x : words) {
2361+
public List<String> topKFrequent(String[] words, int k) {
23722362

2373-
map.putIfAbsent(x, 1);
2374-
Integer cur = map.get(x);
2375-
map.put(x, cur + 1);
2363+
// IDEA: map sorting
2364+
HashMap<String, Integer> freq = new HashMap<>();
2365+
for (int i = 0; i < words.length; i++) {
2366+
freq.put(words[i], freq.getOrDefault(words[i], 0) + 1);
23762367
}
2368+
List<String> res = new ArrayList(freq.keySet());
23772369

2378-
System.out.println(">>> (before sort) map = " + map);
2379-
2380-
// sort map by value and key lenth
2381-
// Convert the map to a list of entries
2382-
List<Map.Entry<String, Integer>> entryList = new ArrayList<>(map.entrySet());
2383-
2384-
// Sort the entry list
2385-
Collections.sort(entryList, new Comparator<Map.Entry<String, Integer>>() {
2386-
@Override
2387-
public int compare(Map.Entry<String, Integer> entry1, Map.Entry<String, Integer> entry2) {
2388-
// First, compare by value in decreasing order
2389-
int valueCompare = entry2.getValue().compareTo(entry1.getValue());
2390-
2391-
// If values are equal, compare by key length in increasing order
2392-
if (valueCompare == 0) {
2393-
return entry1.getKey().length() - entry2.getKey().length();
2394-
}
2395-
2396-
return valueCompare;
2370+
/**
2371+
* NOTE !!!
2372+
*
2373+
* we directly sort over map's keySet
2374+
* (with the data val, key that read from map)
2375+
*
2376+
*
2377+
* example:
2378+
*
2379+
* Collections.sort(res,
2380+
* (w1, w2) -> freq.get(w1).equals(freq.get(w2)) ? w1.compareTo(w2) : freq.get(w2) - freq.get(w1));
2381+
*/
2382+
Collections.sort(res, (x, y) -> {
2383+
int valDiff = freq.get(y) - freq.get(x); // sort on `value` bigger number first (decreasing order)
2384+
if (valDiff == 0){
2385+
// Sort on `key length` short key first (increasing order)
2386+
//return y.length() - x.length(); // ?
2387+
return x.compareTo(y);
23972388
}
2389+
return valDiff;
23982390
});
23992391

2400-
System.out.println(">>> (after sort) map = " + map);
2401-
for (Map.Entry<String, Integer> x : entryList) {
2402-
if (k == 0){
2403-
break;
2404-
}
2405-
res.add((String) x.getKey());
2406-
k -= 1;
2407-
}
2408-
2409-
return res;
2392+
// get top K result
2393+
return res.subList(0, k);
24102394
}
24112395

2396+
2397+
// public List<String> topKFrequent(String[] words, int k) {
2398+
//
2399+
// // edge
2400+
// if (words.length == 0) {
2401+
// return new ArrayList<>();
2402+
// }
2403+
//
2404+
// List<String> res = new ArrayList<>();
2405+
// Map<String, Integer> map = new HashMap<>();
2406+
// // biggest queue
2407+
// // Queue<Integer> cntQueue = new LinkedList<>();
2408+
//
2409+
// for (String x : words) {
2410+
//
2411+
// map.putIfAbsent(x, 1);
2412+
// Integer cur = map.get(x);
2413+
// map.put(x, cur + 1);
2414+
// }
2415+
//
2416+
// System.out.println(">>> (before sort) map = " + map);
2417+
//
2418+
// // sort map by value and key lenth
2419+
// // Convert the map to a list of entries
2420+
// List<Map.Entry<String, Integer>> entryList = new ArrayList<>(map.entrySet());
2421+
//
2422+
// // Sort the entry list
2423+
// Collections.sort(entryList, new Comparator<Map.Entry<String, Integer>>() {
2424+
// @Override
2425+
// public int compare(Map.Entry<String, Integer> entry1, Map.Entry<String, Integer> entry2) {
2426+
// // First, compare by value in decreasing order
2427+
// int valueCompare = entry2.getValue().compareTo(entry1.getValue());
2428+
//
2429+
// // If values are equal, compare by key length in increasing order
2430+
// if (valueCompare == 0) {
2431+
// return entry1.getKey().length() - entry2.getKey().length();
2432+
// }
2433+
//
2434+
// return valueCompare;
2435+
// }
2436+
// });
2437+
//
2438+
// System.out.println(">>> (after sort) map = " + map);
2439+
// for (Map.Entry<String, Integer> x : entryList) {
2440+
// if (k == 0){
2441+
// break;
2442+
// }
2443+
// res.add((String) x.getKey());
2444+
// k -= 1;
2445+
// }
2446+
//
2447+
// return res;
2448+
// }
2449+
24122450
// public List<String> topKFrequent(String[] words, int k) {
24132451
//
24142452
// // edge

‎leetcode_java/src/main/java/dev/workspace7.java‎

Lines changed: 36 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -347,4 +347,40 @@ public int totalFruit(int[] fruits) {
347347
return res;
348348
}
349349

350+
// LC 279
351+
/**
352+
*
353+
*
354+
Given an integer n, return the
355+
least number of perfect square numbers that sum to n.
356+
357+
A perfect square is an integer that is the
358+
square of an integer; in other words,
359+
it is the product of some integer with itself.
360+
For example, 1, 4, 9, and 16 are perfect squares while 3 and 11 are not.
361+
362+
363+
Example 1:
364+
365+
Input: n = 12
366+
Output: 3
367+
Explanation: 12 = 4 + 4 + 4.
368+
369+
370+
Example 2:
371+
372+
Input: n = 13
373+
Output: 2
374+
Explanation: 13 = 4 + 9.
375+
376+
Constraints:
377+
378+
1 <= n <= 104
379+
*
380+
*/
381+
public int numSquares(int n) {
382+
383+
return 1;
384+
}
385+
350386
}

0 commit comments

Comments
 (0)