Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/alxkm/leetcode
https://github.com/alxkm/leetcode
Last synced: about 1 month ago
JSON representation
- Host: GitHub
- URL: https://github.com/alxkm/leetcode
- Owner: alxkm
- License: mit
- Created: 2022-10-23T15:40:34.000Z (about 2 years ago)
- Default Branch: master
- Last Pushed: 2024-04-13T15:24:41.000Z (7 months ago)
- Last Synced: 2024-04-13T20:51:02.329Z (7 months ago)
- Language: Java
- Size: 1.27 MB
- Stars: 3
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Leetcode
Java cheatsheet:
Array {
Arrays.stream(givenArray).sum();
int minimumValue = Arrays.stream(givenArray).min().getAsInt();
int MaxmumValue = Arrays.stream(givenArray).max().getAsInt();
Collections.reverse(Arrays.asList(a));
Person maxByAge = Arrays.stream(persons).max(Comparator.comparing(Car::getAge)).orElseThrow(NoSuchElementException::new);
// Arrays.fill(arr, -1)
int[] arr = new int[5];
Arrays.fill(arr, -1);
// Arrays.asList()
List fruitsList = Arrays.asList("apple", "banana", "orange");
// asList()
java.util.List list = Arrays.asList("apple", "banana", "orange");
// binarySearch(array, fromIndex, toIndex, key, Comparator)
int[] array = {10, 20, 30, 40, 50};
int index = Arrays.binarySearch(array, 1, 4, 30, (a, b) -> a - b);
// binarySearch()
int[] sortedArray = {1, 2, 3, 4, 5};
int index2 = Arrays.binarySearch(sortedArray, 3);
// compare(array1, array2)
int[] array1 = {1, 2, 3};
int[] array2 = {1, 2, 3};
int result = Arrays.compare(array1, array2);
// copyOf(originalArray, newLength)
int[] originalArray = {1, 2, 3, 4, 5};
int[] newArray = Arrays.copyOf(originalArray, 3);
// copyOfRange(originalArray, fromIndex, endIndex)
int[] newRangeArray = Arrays.copyOfRange(originalArray, 1, 4);
// deepEquals(Object[] a1, Object[] a2)
Integer[] arrayA = {1, 2, 3};
Integer[] arrayB = {1, 2, 3};
boolean isEqual = Arrays.deepEquals(arrayA, arrayB);
// deepToString(Object[] a)
Integer[][] twoDArray = {{1, 2, 3}, {4, 5, 6}};
String deepToString = Arrays.deepToString(twoDArray);
// fill(originalArray, fillValue)
int[] fillArray = new int[5];
Arrays.fill(fillArray, 42);
// sort(originalArray)
int[] unsortedArray = {5, 2, 8, 1, 3};
Arrays.sort(unsortedArray);
// stream(originalArray)
int[] arrayStream = {1, 2, 3};
java.util.stream.Stream stream = Arrays.stream(arrayStream);
// toString(originalArray)
int[] arrayToString = {1, 2, 3};
String arrayString = Arrays.toString(arrayToString);
}
Collections {
// List
List list = new ArrayList<>(Arrays.asList(5, 2, 8, 1, 3));
// Collections.sort
// Collections.sort(list) sorts the list in natural order.
Collections.sort(list);
// Custom comparator
Collections.sort(personList, Comparator.comparingInt(Person::getAge));
// Sort numbers in reverse order using custom Comparator
Collections.sort(numbers, (num1, num2) -> num2 - num1);
// Collections.binarySearch
// Collections.binarySearch(list, 5) performs a binary search
// on the sorted list and returns the index of the element 5 (if found), or a negative value if not found.
//
int index = Collections.binarySearch(list, 5);
// Collections.indexedBinarySearch
// Collections.indexedBinarySearch(list, 0, list.size(), 5, (a, b) -> a - b)
// performs a binary search on the specified range of the sorted list using a custom comparator
//
int customComparatorIndex = Collections.indexedBinarySearch(list, 0, list.size(), 5, (a, b) -> a - b);
// Collections.reverse
// Collections.reverse(list) reverses the order of elements in the list
Collections.reverse(list);
// Collections.swap
// Collections.swap(list, 0, list.size() - 1) swaps the elements at index 0 and the last index in the list
Collections.swap(list, 0, list.size() - 1);
// Collections.fill
// Collections.fill(list, 0) replaces all elements in the list with the value 0.
Collections.fill(list, 0);
// Collections.min
// Collections.min(list) finds the minimum value in the list
int minValue = Collections.min(list);
// Collections.max
// Collections.max(list) finds the maximum value in the list.
int maxValue = Collections.max(list);
// Collections.rotate
// Collections.rotate(list, 2) rotates the elements in the list by 2 positions to the right.
Collections.rotate(list, 2);
// List
List list = Arrays.asList(1, 2, 3, 4, 5);
Collections.reverse(list);
// Set
Set set = new HashSet<>(Arrays.asList("apple", "banana", "orange"));
boolean isApplePresent = Collections.disjoint(set, Collections.singleton("apple"));
// Map
Map map = new HashMap<>();
map.put("apple", 10);
map.put("banana", 5);
int maxValue = Collections.max(map.values());
// Queue
Queue queue = new LinkedList<>(Arrays.asList(1, 2, 3, 4));
queue.offer(5);
Collections.sort(listOfNumbers);
Collections.reverse(Arrays.asList(a));
Map treemap =new TreeMap(Collections.reverseOrder());
treeMap.containsKey(keyElement)
treeMap.containsValue(valueElement)
List al = new ArrayList();
Integer[] arr = new Integer[al.size()];
arr = al.toArray(arr);
}
Math {
static double ceil(double a)
static long abs(long a)
static double min(double a, double b)
static double max(double a, double b)
static double sqrt(double a)
static double pow(double a, double b)
}
Character {
static int getNumericValue(char ch)
static int getNumericValue(int codePoint)
static boolean isDigit(char ch)
static boolean isLetter(char ch)
static boolean isLetterOrDigit(char ch)
static boolean isLowerCase(char ch)
static boolean isSpaceChar(char ch)
static boolean isUpperCase(char ch)
static boolean isWhitespace(char ch)
static char toLowerCase(char ch)
static int toUpperCase(int codePoint)
}
String {
String listString = String.join(", ", list);
charAt(int index)
String concat(String str)
boolean contains(CharSequence s)
boolean endsWith(String suffix)
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
int indexOf(int ch)
String intern()
boolean isEmpty()
int lastIndexOf(int ch)
int lastIndexOf(int ch, int fromIndex)
int lastIndexOf(String str)
int lastIndexOf(String str, int fromIndex)
int length()
String replace(char oldChar, char newChar)
String replace(CharSequence target, CharSequence replacement)
String replaceAll(String regex, String replacement)
String replaceFirst(String regex, String replacement)
String[] split(String regex)
boolean startsWith(String prefix)
boolean startsWith(String prefix, int toffset)
CharSequence subSequence(int beginIndex, int endIndex)
String substring(int beginIndex)
String substring(int beginIndex, int endIndex)
char[] toCharArray()
String toLowerCase()
String toUpperCase()
String trim()
}
StringBuilder {
StringBuilder append(char c)
char charAt(int index)
StringBuilder delete(int start, int end)
StringBuilder deleteCharAt(int index)
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
int indexOf(String str)
int indexOf(String str, int fromIndex)
StringBuilder insert(int offset, boolean b)
int length()
StringBuilder replace(int start, int end, String str)
StringBuilder reverse()
void setCharAt(int index, char ch)
CharSequence subSequence(int start, int end)
String substring(int start)
}
Queue, Stack, Deque, PriorityQueue {
// PriorityQueue with custom comparator for priority
PriorityQueue priorityQueue = new PriorityQueue<>(Comparator.reverseOrder());
priorityQueue.add(5);
priorityQueue.add(2);
priorityQueue.add(8);
// Queue examples with some popular methods
Queue queue = new LinkedList<>();
queue.offer("John");
queue.offer("Alice");
String frontElement = queue.poll();
// Stack
Stack stack = new Stack<>();
stack.push(1);
stack.push(2);
int topElement = stack.pop();
}
Deque {
// Deque
Deque deque = new ArrayDeque<>();
// Adding elements to the Deque
deque.addFirst(1); // [1]
deque.addLast(2); // [1, 2]
deque.offerFirst(0); // [0, 1, 2]
deque.offerLast(3); // [0, 1, 2, 3]
// Getting elements from the Deque
int firstElement = deque.peekFirst(); // Returns 0
int lastElement = deque.peekLast(); // Returns 3
int removedFirst = deque.pollFirst(); // Removes and returns 0
int removedLast = deque.pollLast(); // Removes and returns 3
// Size and clearing
int size = deque.size(); // Returns 2
boolean isEmpty = deque.isEmpty(); // Returns false
deque.clear(); // Clears the deque, now it's empty
// Iterating through the Deque
Deque stringDeque = new LinkedList<>();
stringDeque.addAll(Arrays.asList("apple", "banana", "orange"));
for (String fruit : stringDeque) {
System.out.print(fruit + " "); // Output: apple banana orange
}
}
PriorityQueue {
// Create a PriorityQueue with a custom comparator for priority
PriorityQueue priorityQueue = new PriorityQueue<>(Comparator.comparingInt(Person::getPriority));
// Add persons to the priority queue
priorityQueue.add(new Person("Alice", 2));
priorityQueue.add(new Person("Bob", 3));
priorityQueue.add(new Person("John", 1));
priorityQueue.add(new Person("Mary", 2));
// Priority Queue will be sorted based on the priority value (1, 2, 2, 3)
// Retrieve the person with the highest priority
Person highestPriorityPerson = priorityQueue.peek();
System.out.println("Priority Queue:");
while (!priorityQueue.isEmpty()) {
Person person = priorityQueue.poll();
System.out.println("Name: " + person.getName() + ", Priority: " + person.getPriority());
}
}
Set {
Set set1 = new HashSet<>();
set1.add("apple");
set1.add("banana");
set1.add("orange");
set1.add("grape");
Set set2 = new HashSet<>();
set2.add("banana");
set2.add("mango");
// Retain only the elements present in set2
set1.retainAll(set2);
}