minStack = new Stack<>();
-
- private static int push(int item) {
- minPush(item);
- return stack.push(item);
- }
-
- private static int pop() {
- minPop(stack.peek());
- return stack.pop();
- }
-
- private static int min() {
- return minStack.peek();
- }
-
- private static void minPush(int item) {
- if (minStack.empty() || item <= minStack.peek()) {
- minStack.push(item);
- }
- }
-
- private static void minPop(int item) {
- if (item == minStack.peek()) {
- minStack.pop();
- }
- }
-
- public static void main(String[] args) {
- push(2);
- push(5);
- push(1);
- push(1);
- push(6);
- push(8);
- Assert.check(min() == 1);
- pop();
- pop();
- pop();
- Assert.check(min() == 1);
- pop();
- Assert.check(min() == 2);
- }
-}
\ No newline at end of file
diff --git a/src/main/java/com/leetcode/graphs/WordLadder.java b/src/main/java/com/leetcode/graphs/WordLadder.java
deleted file mode 100644
index 61e706ce..00000000
--- a/src/main/java/com/leetcode/graphs/WordLadder.java
+++ /dev/null
@@ -1,121 +0,0 @@
-package com.leetcode.graphs;
-
-
-import javafx.util.Pair;
-
-import java.util.*;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-/**
- * Level: Medium
- * Link: https://leetcode.com/problems/word-ladder/
- * Description:
- * Given two words (beginWord and endWord), and a dictionary's word list, find the length of shortest transformation
- * sequence from beginWord to endWord, such that:
- *
- * Only one letter can be changed at a time. Each transformed word must exist in the word list. Note that beginWord
- * is not a transformed word.
- *
- * Note:
- * - Return 0 if there is no such transformation sequence.
- * - All words have the same length.
- * - All words contain only lowercase alphabetic characters.
- * - You may assume no duplicates in the word list.
- * - You may assume beginWord and endWord are non-empty and are not the same.
- *
- * Example 1:
- * Input:
- * beginWord = "hit",
- * endWord = "cog",
- * wordList = ["hot","dot","dog","lot","log","cog"]
- *
- * Output: 5
- *
- * Explanation: As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
- * return its length 5.
- *
- * Example 2:
- * Input:
- * beginWord = "hit"
- * endWord = "cog"
- * wordList = ["hot","dot","dog","lot","log"]
- *
- * Output: 0
- *
- * Explanation: The endWord "cog" is not in wordList, therefore no possible transformation.
- *
- * @author rampatra
- * @since 2019-08-15
- */
-public class WordLadder {
-
- /**
- * Runtime: 79 ms.
- *
- * @param beginWord
- * @param endWord
- * @param wordList
- * @return
- */
- public static int ladderLength(String beginWord, String endWord, List wordList) {
- int L = beginWord.length();
- Map> transformedToOriginalWordMap = new HashMap<>();
- Queue> queue = new LinkedList<>();
-
- wordList.forEach(word -> {
- String transformedWord;
- for (int i = 0; i < L; i++) {
- transformedWord = word.substring(0, i) + "*" + word.substring(i + 1, L);
- transformedToOriginalWordMap.putIfAbsent(transformedWord, new HashSet<>());
- transformedToOriginalWordMap.get(transformedWord).add(word);
- }
- }
- );
-
- Set visited = new HashSet<>();
- queue.add(new Pair<>(beginWord, 1));
- visited.add(beginWord);
-
- while (!queue.isEmpty()) {
- Pair currPair = queue.poll();
- String word = currPair.getKey();
- Integer level = currPair.getValue();
-
- if (word.equals(endWord)) {
- return level;
- }
-
- String transformedWord;
- for (int i = 0; i < L; i++) {
- transformedWord = word.substring(0, i) + "*" + word.substring(i + 1, L);
-
- for (String originalWord : transformedToOriginalWordMap.getOrDefault(transformedWord, Collections.emptySet())) {
- if (!visited.contains(originalWord)) {
- queue.add(new Pair<>(originalWord, level + 1));
- visited.add(originalWord);
- }
- }
- }
- }
-
- return 0;
- }
-
- /**
- * TODO: Optimized both end BFS solution
- *
- * @param beginWord
- * @param endWord
- * @param wordList
- * @return
- */
- public static int ladderLengthOptimized(String beginWord, String endWord, List wordList) {
- return -1;
- }
-
- public static void main(String[] args) {
- assertEquals(5, ladderLength("hit", "cog", Arrays.asList("hot", "dot", "dog", "lot", "log", "cog")));
- assertEquals(0, ladderLength("hit", "cog", Arrays.asList("hot", "dot", "dog", "lot", "log")));
- }
-}
\ No newline at end of file
diff --git a/src/main/java/com/leetcode/graphs/WordLadderII.java b/src/main/java/com/leetcode/graphs/WordLadderII.java
deleted file mode 100644
index 8265c259..00000000
--- a/src/main/java/com/leetcode/graphs/WordLadderII.java
+++ /dev/null
@@ -1,152 +0,0 @@
-package com.leetcode.graphs;
-
-import javafx.util.Pair;
-
-import java.util.*;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-/**
- * Level: Hard
- * Link: https://leetcode.com/problems/word-ladder-ii/
- * Description:
- * Given two words (beginWord and endWord), and a dictionary's word list, find all shortest transformation sequence(s)
- * from beginWord to endWord, such that:
- *
- * Only one letter can be changed at a time
- * Each transformed word must exist in the word list. Note that beginWord is not a transformed word.
- *
- * Note:
- * - Return an empty list if there is no such transformation sequence.
- * - All words have the same length.
- * - All words contain only lowercase alphabetic characters.
- * - You may assume no duplicates in the word list.
- * - You may assume beginWord and endWord are non-empty and are not the same.
- *
- * Example 1:
- * Input:
- * beginWord = "hit",
- * endWord = "cog",
- * wordList = ["hot","dot","dog","lot","log","cog"]
- *
- * Output:
- * [
- * ["hit","hot","dot","dog","cog"],
- * ["hit","hot","lot","log","cog"]
- * ]
- *
- *
- * Example 2:
- * Input:
- * beginWord = "hit"
- * endWord = "cog"
- * wordList = ["hot","dot","dog","lot","log"]
- *
- * Output: []
- * Explanation: The endWord "cog" is not in wordList, therefore no possible transformation.
- *
- * @author rampatra
- * @since 2019-08-15
- */
-public class WordLadderII {
-
- /**
- * The approach is same as {@link WordLadder}. We calculate the {@code minDistance} from start to end word and also
- * keep a map of words and its adjacent words (i.e, with only character difference). After we are done calculating
- * the {@code mindistance}, we perform a dfs on the map upto depth {@code minDistance} and if the last word at this
- * depth is equal to the end word then we add all words to the result.
- *
- * @param beginWord
- * @param endWord
- * @param wordList
- * @return
- */
- public static List> findLadders(String beginWord, String endWord, List wordList) {
- int L = beginWord.length();
- List> ladders = new LinkedList<>();
- Map> transformedToOriginalWordMap = new HashMap<>();
- Queue> queue = new LinkedList<>();
-
- wordList.forEach(word -> {
- String transformedWord;
- for (int i = 0; i < L; i++) {
- transformedWord = word.substring(0, i) + "*" + word.substring(i + 1, L);
- transformedToOriginalWordMap.putIfAbsent(transformedWord, new HashSet<>());
- transformedToOriginalWordMap.get(transformedWord).add(word);
- }
- }
- );
-
- int minDistance = -1;
- Set visited = new HashSet<>();
- queue.add(new Pair<>(beginWord, 1));
- visited.add(beginWord);
-
- HashMap> connectedNodes = new HashMap<>();
-
- while (!queue.isEmpty()) {
- Pair currPair = queue.poll();
- String word = currPair.getKey();
- Integer level = currPair.getValue();
-
- if (word.equals(endWord) && minDistance == -1) {
- minDistance = level - 1;
- }
-
- String transformedWord;
- for (int i = 0; i < L; i++) {
- transformedWord = word.substring(0, i) + "*" + word.substring(i + 1, L);
-
- for (String originalWord : transformedToOriginalWordMap.getOrDefault(transformedWord, Collections.emptySet())) {
- if (!visited.contains(originalWord)) {
- queue.add(new Pair<>(originalWord, level + 1));
- visited.add(originalWord);
- }
-
- if (!word.equals(originalWord)) {
- connectedNodes.putIfAbsent(word, new HashSet<>());
- connectedNodes.get(word).add(originalWord);
- }
- }
- }
- }
-
- dfs(ladders, new LinkedHashSet<>(), connectedNodes, beginWord, endWord, 0, minDistance);
-
- return ladders;
- }
-
- /**
- * Perform dfs on the map which contains words and its adjacent words.
- *
- * @param ladders
- * @param ladder
- * @param connectedNodes
- * @param startNode
- * @param endNode
- * @param distance
- * @param minDistance
- */
- private static void dfs(List> ladders, Set ladder, Map> connectedNodes,
- String startNode, String endNode, int distance, int minDistance) {
- if (distance == minDistance && startNode.equals(endNode)) {
- ladder.add(endNode);
- ladders.add(new ArrayList<>(ladder));
- return;
- } else if (distance > minDistance) {
- return;
- }
-
- ladder.add(startNode);
- for (String nextNode : connectedNodes.getOrDefault(startNode, new HashSet<>())) {
- if (!ladder.contains(nextNode)) {
- dfs(ladders, new LinkedHashSet<>(ladder), connectedNodes, nextNode, endNode, distance + 1, minDistance);
- }
- }
- }
-
- public static void main(String[] args) {
- assertEquals("[[hit, hot, lot, log, cog], [hit, hot, dot, dog, cog]]", findLadders("hit", "cog", Arrays.asList("hot", "dot", "dog", "lot", "log", "cog")).toString());
- // TODO Fix this test case System.out.println(findLadders("cet", "ism", Arrays.asList("kid", "tag", "pup", "ail", "tun", "woo", "erg", "luz", "brr", "gay", "sip", "kay", "per", "val", "mes", "ohs", "now", "boa", "cet", "pal", "bar", "die", "war", "hay", "eco", "pub", "lob", "rue", "fry", "lit", "rex", "jan", "cot", "bid", "ali", "pay", "col", "gum", "ger", "row", "won", "dan", "rum", "fad", "tut", "sag", "yip", "sui", "ark", "has", "zip", "fez", "own", "ump", "dis", "ads", "max", "jaw", "out", "btu", "ana", "gap", "cry", "led", "abe", "box", "ore", "pig", "fie", "toy", "fat", "cal", "lie", "noh", "sew", "ono", "tam", "flu", "mgm", "ply", "awe", "pry", "tit", "tie", "yet", "too", "tax", "jim", "san", "pan", "map", "ski", "ova", "wed", "non", "wac", "nut", "why", "bye", "lye", "oct", "old", "fin", "feb", "chi", "sap", "owl", "log", "tod", "dot", "bow", "fob", "for", "joe", "ivy", "fan", "age", "fax", "hip", "jib", "mel", "hus", "sob", "ifs", "tab", "ara", "dab", "jag", "jar", "arm", "lot", "tom", "sax", "tex", "yum", "pei", "wen", "wry", "ire", "irk", "far", "mew", "wit", "doe", "gas", "rte", "ian", "pot", "ask", "wag", "hag", "amy", "nag", "ron", "soy", "gin", "don", "tug", "fay", "vic", "boo", "nam", "ave", "buy", "sop", "but", "orb", "fen", "paw", "his", "sub", "bob", "yea", "oft", "inn", "rod", "yam", "pew", "web", "hod", "hun", "gyp", "wei", "wis", "rob", "gad", "pie", "mon", "dog", "bib", "rub", "ere", "dig", "era", "cat", "fox", "bee", "mod", "day", "apr", "vie", "nev", "jam", "pam", "new", "aye", "ani", "and", "ibm", "yap", "can", "pyx", "tar", "kin", "fog", "hum", "pip", "cup", "dye", "lyx", "jog", "nun", "par", "wan", "fey", "bus", "oak", "bad", "ats", "set", "qom", "vat", "eat", "pus", "rev", "axe", "ion", "six", "ila", "lao", "mom", "mas", "pro", "few", "opt", "poe", "art", "ash", "oar", "cap", "lop", "may", "shy", "rid", "bat", "sum", "rim", "fee", "bmw", "sky", "maj", "hue", "thy", "ava", "rap", "den", "fla", "auk", "cox", "ibo", "hey", "saw", "vim", "sec", "ltd", "you", "its", "tat", "dew", "eva", "tog", "ram", "let", "see", "zit", "maw", "nix", "ate", "gig", "rep", "owe", "ind", "hog", "eve", "sam", "zoo", "any", "dow", "cod", "bed", "vet", "ham", "sis", "hex", "via", "fir", "nod", "mao", "aug", "mum", "hoe", "bah", "hal", "keg", "hew", "zed", "tow", "gog", "ass", "dem", "who", "bet", "gos", "son", "ear", "spy", "kit", "boy", "due", "sen", "oaf", "mix", "hep", "fur", "ada", "bin", "nil", "mia", "ewe", "hit", "fix", "sad", "rib", "eye", "hop", "haw", "wax", "mid", "tad", "ken", "wad", "rye", "pap", "bog", "gut", "ito", "woe", "our", "ado", "sin", "mad", "ray", "hon", "roy", "dip", "hen", "iva", "lug", "asp", "hui", "yak", "bay", "poi", "yep", "bun", "try", "lad", "elm", "nat", "wyo", "gym", "dug", "toe", "dee", "wig", "sly", "rip", "geo", "cog", "pas", "zen", "odd", "nan", "lay", "pod", "fit", "hem", "joy", "bum", "rio", "yon", "dec", "leg", "put", "sue", "dim", "pet", "yaw", "nub", "bit", "bur", "sid", "sun", "oil", "red", "doc", "moe", "caw", "eel", "dix", "cub", "end", "gem", "off", "yew", "hug", "pop", "tub", "sgt", "lid", "pun", "ton", "sol", "din", "yup", "jab", "pea", "bug", "gag", "mil", "jig", "hub", "low", "did", "tin", "get", "gte", "sox", "lei", "mig", "fig", "lon", "use", "ban", "flo", "nov", "jut", "bag", "mir", "sty", "lap", "two", "ins", "con", "ant", "net", "tux", "ode", "stu", "mug", "cad", "nap", "gun", "fop", "tot", "sow", "sal", "sic", "ted", "wot", "del", "imp", "cob", "way", "ann", "tan", "mci", "job", "wet", "ism", "err", "him", "all", "pad", "hah", "hie", "aim", "ike", "jed", "ego", "mac", "baa", "min", "com", "ill", "was", "cab", "ago", "ina", "big", "ilk", "gal", "tap", "duh", "ola", "ran", "lab", "top", "gob", "hot", "ora", "tia", "kip", "han", "met", "hut", "she", "sac", "fed", "goo", "tee", "ell", "not", "act", "gil", "rut", "ala", "ape", "rig", "cid", "god", "duo", "lin", "aid", "gel", "awl", "lag", "elf", "liz", "ref", "aha", "fib", "oho", "tho", "her", "nor", "ace", "adz", "fun", "ned", "coo", "win", "tao", "coy", "van", "man", "pit", "guy", "foe", "hid", "mai", "sup", "jay", "hob", "mow", "jot", "are", "pol", "arc", "lax", "aft", "alb", "len", "air", "pug", "pox", "vow", "got", "meg", "zoe", "amp", "ale", "bud", "gee", "pin", "dun", "pat", "ten", "mob")));
- }
-}
diff --git a/src/main/java/com/leetcode/heaps/TopKFrequentElements.java b/src/main/java/com/leetcode/heaps/TopKFrequentElements.java
deleted file mode 100644
index 5a684325..00000000
--- a/src/main/java/com/leetcode/heaps/TopKFrequentElements.java
+++ /dev/null
@@ -1,68 +0,0 @@
-package com.leetcode.heaps;
-
-import javafx.util.Pair;
-
-import java.util.*;
-import java.util.stream.Collectors;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-/**
- * Level: Medium
- * Link: https://leetcode.com/problems/top-k-frequent-elements/
- * Description:
- * Given a non-empty array of integers, return the k most frequent elements.
- *
- * Example 1:
- * Input: nums = [1,1,1,2,2,3], k = 2
- * Output: [1,2]
- *
- * Example 2:
- * Input: nums = [1], k = 1
- * Output: [1]
- *
- * Note:
- * - You may assume k is always valid, 1 ≤ k ≤ number of unique elements.
- * - Your algorithm's time complexity must be better than O(n log n), where n is the array's size.
- *
- * @author rampatra
- * @since 2019-08-19
- */
-public class TopKFrequentElements {
-
- /**
- * TODO: A faster approach without using Pair.
- *
- * Runtime: 51 ms.
- *
- * @param nums
- * @param k
- * @return
- */
- public static List topKFrequent(int[] nums, int k) {
- Map numCount = new HashMap<>();
- PriorityQueue> pq = new PriorityQueue<>(Comparator.comparing(Pair::getValue));
-
- for (int num : nums) {
- numCount.put(num, numCount.getOrDefault(num, 0) + 1);
- }
-
- for (Map.Entry entry : numCount.entrySet()) {
- pq.add(new Pair<>(entry.getKey(), entry.getValue()));
-
- if (pq.size() > k) {
- pq.poll();
- }
- }
-
- return pq.stream().map(Pair::getKey).collect(Collectors.toList());
- }
-
- public static void main(String[] args) {
- assertEquals("[2, 1]", topKFrequent(new int[]{1, 1, 1, 2, 2, 3}, 2).toString());
- assertEquals("[0]", topKFrequent(new int[]{3, 0, 1, 0}, 1).toString());
- assertEquals("[1]", topKFrequent(new int[]{1}, 1).toString());
- assertEquals("[1, 2]", topKFrequent(new int[]{1, 2}, 2).toString());
- assertEquals("[2, -1]", topKFrequent(new int[]{4, 1, -1, 2, -1, 2, 3}, 2).toString());
- }
-}
diff --git a/src/main/java/com/leetcode/stacks/ExclusiveTimeOfFunctions.java b/src/main/java/com/leetcode/stacks/ExclusiveTimeOfFunctions.java
deleted file mode 100644
index 63c61dc2..00000000
--- a/src/main/java/com/leetcode/stacks/ExclusiveTimeOfFunctions.java
+++ /dev/null
@@ -1,89 +0,0 @@
-package com.leetcode.stacks;
-
-import javafx.util.Pair;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.Stack;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-/**
- * Level: Medium
- * Link: https://leetcode.com/problems/exclusive-time-of-functions/
- * Description:
- * On a single threaded CPU, we execute some functions. Each function has a unique id between 0 and N-1.
- *
- * We store logs in timestamp order that describe when a function is entered or exited.
- *
- * Each log is a string with this format: "{function_id}:{"start" | "end"}:{timestamp}". For example, "0:start:3"
- * means the function with id 0 started at the beginning of timestamp 3. "1:end:2" means the function with id 1 ended
- * at the end of timestamp 2.
- *
- * A function's exclusive time is the number of units of time spent in this function. Note that this does not include
- * any recursive calls to child functions.
- *
- * The CPU is single threaded which means that only one function is being executed at a given time unit.
- *
- * Return the exclusive time of each function, sorted by their function id.
- *
- * Input:
- * n = 2
- * logs = ["0:start:0","1:start:2","1:end:5","0:end:6"]
- * Output: [3, 4]
- * Explanation:
- * Function 0 starts at the beginning of time 0, then it executes 2 units of time and reaches the end of time 1.
- * Now function 1 starts at the beginning of time 2, executes 4 units of time and ends at time 5.
- * Function 0 is running again at the beginning of time 6, and also ends at the end of time 6, thus executing for 1 unit of time.
- * So function 0 spends 2 + 1 = 3 units of total time executing, and function 1 spends 4 units of total time executing.
- *
- *
- * Note:
- * -> 1 <= n <= 100
- * -> Two functions won't start or end at the same time.
- * -> Functions will always log when they exit.
- *
- * @author rampatra
- * @since 2019-08-17
- */
-public class ExclusiveTimeOfFunctions {
-
- /**
- * Runtime: 18 ms.
- *
- * @param n
- * @param logs
- * @return
- */
- public static int[] exclusiveTime(int n, List logs) {
- int[] times = new int[n];
- Stack> stack = new Stack<>();
-
- for (String log : logs) {
- String[] l = log.split(":");
- int id = Integer.parseInt(l[0]);
- String operation = l[1];
- int timestamp = Integer.parseInt(l[2]);
-
- if (operation.equals("start")) {
- if (!stack.empty()) { // if there are other processes started before, calculate their time until now
- times[stack.peek().getKey()] += (timestamp - stack.peek().getValue() - 1);
- }
- stack.push(new Pair<>(id, timestamp));
- } else {
- times[id] += timestamp - stack.pop().getValue() + 1;
- if (!stack.isEmpty()) { // if there are other processes, make their start time to now
- stack.push(new Pair<>(stack.pop().getKey(), timestamp));
- }
- }
- }
-
- return times;
- }
-
- public static void main(String[] args) {
- assertEquals("[4]", Arrays.toString(exclusiveTime(1, Arrays.asList("0:start:0", "0:start:1", "0:end:2", "0:end:3"))));
- assertEquals("[6]", Arrays.toString(exclusiveTime(1, Arrays.asList("0:start:0", "0:start:1", "0:start:2", "0:end:3", "0:end:4", "0:end:5"))));
- assertEquals("[3, 4]", Arrays.toString(exclusiveTime(2, Arrays.asList("0:start:0", "1:start:2", "1:end:5", "0:end:6"))));
- }
-}
\ No newline at end of file
diff --git a/src/main/java/com/rampatra/arrays/MaxSpan.java b/src/main/java/com/rampatra/arrays/MaxSpan.java
deleted file mode 100644
index 7db17c18..00000000
--- a/src/main/java/com/rampatra/arrays/MaxSpan.java
+++ /dev/null
@@ -1,45 +0,0 @@
-package com.rampatra.arrays;
-
-import com.sun.tools.javac.util.Assert;
-
-/**
- * Consider the leftmost and rightmost appearances of some value in an array. We'll say that the "span" is the
- * number of elements between the two inclusive. A single value has a span of 1. Returns the largest span found
- * in the given array.
- *
- * Examples:
- * maxSpan([1, 2, 1, 1, 3]) → 4
- * maxSpan([1, 4, 2, 1, 4, 1, 4]) → 6
- * maxSpan([1, 4, 2, 1, 4, 4, 4]) → 6
- *
- * Level: Easy
- *
- * @author rampatra
- * @link https://codingbat.com/prob/p189576
- * @since 2019-01-23
- */
-public class MaxSpan {
-
- public static int maxSpan(int[] nums) {
- if (nums.length == 0) return 0;
- int largestSpan = 1;
- for (int i = 0; i < nums.length; i++) {
- for (int j = nums.length - 1; j > i; j--) {
- if (nums[i] == nums[j]) {
- if (j - i + 1 > largestSpan) {
- largestSpan = j - i + 1;
- }
- }
- }
- }
- return largestSpan;
- }
-
- public static void main(String[] args) {
- Assert.check(maxSpan(new int[]{1, 2, 1, 1, 3}) == 4);
- Assert.check(maxSpan(new int[]{1, 4, 2, 1, 4, 1, 4}) == 6);
- Assert.check(maxSpan(new int[]{1, 4, 2, 1, 4, 4, 4}) == 6);
- Assert.check(maxSpan(new int[]{1}) == 1);
- Assert.check(maxSpan(new int[]{}) == 0);
- }
-}
diff --git a/src/main/java/com/rampatra/strings/WithoutString.java b/src/main/java/com/rampatra/strings/WithoutString.java
deleted file mode 100644
index 859b6a76..00000000
--- a/src/main/java/com/rampatra/strings/WithoutString.java
+++ /dev/null
@@ -1,45 +0,0 @@
-package com.rampatra.strings;
-
-import com.sun.tools.javac.util.Assert;
-
-/**
- * Given two strings, base and remove, return a version of the base string where all instances
- * of the remove string have been removed (not case sensitive). You may assume that the remove
- * string is length 1 or more. Remove only non-overlapping instances, so with "xxx" removing
- * "xx" leaves "x".
- *
- * @author rampatra
- * @since 2019-01-23
- */
-public class WithoutString {
-
- private static String withoutString(String base, String remove) {
- String original = base;
- base = base.toLowerCase();
- remove = remove.toLowerCase();
- int baseLen = base.length();
- int removeLen = remove.length();
- StringBuilder sb = new StringBuilder();
-
- for (int i = 0; i < baseLen; ) {
- int j = 0;
- // when we see a match, advance the pointer
- while (j < removeLen && i + j < baseLen && base.charAt(i + j) == remove.charAt(j)) {
- j++;
- }
- if (j == removeLen) { // an entire match was found, move ahead and skip these chars
- i += removeLen;
- } else {
- sb.append(original.charAt(i)); // entire match was not found so append the char to StringBuilder
- i++;
- }
- }
- return sb.toString();
- }
-
- public static void main(String[] args) {
- Assert.check(withoutString("Hello there", "llo").equals("He there"));
- Assert.check(withoutString("THIS is a FISH", "is").equals("TH a FH"));
- Assert.check(withoutString("xxx", "x").equals(""));
- }
-}
diff --git a/src/main/test/SortStackTest.java b/src/main/test/SortStackTest.java
new file mode 100644
index 00000000..520c8a07
--- /dev/null
+++ b/src/main/test/SortStackTest.java
@@ -0,0 +1,67 @@
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.Stack;
+
+import org.junit.jupiter.api.Test;
+
+import com.ctci.stacksandqueues.SortStack;
+
+class SortStackTest {
+
+/**
+ * note
+ */
+ @Test
+ public void testStackNull() {
+ Stack unsortedStack = new Stack();
+ unsortedStack.push(2);
+ unsortedStack.push(5);
+ unsortedStack.push(1);
+ unsortedStack.push(3);
+ boolean empty = unsortedStack.empty();
+ assertTrue("Array empty",empty);
+
+ }
+
+ @Test
+ public void testStackHaveOnevalue() {
+ Stack unsortedStack = new Stack();
+ unsortedStack.push(2);
+
+ if(unsortedStack.size() == 1) {
+ SortStack.printStack(unsortedStack);
+
+ assertTrue("array has only 1 value!", true);
+ }else {
+ SortStack.printStack(unsortedStack);
+ }
+
+
+ }
+
+ @Test
+ public void testCheckArraySort() {
+ Stack unsortedStack = new Stack();
+
+ unsortedStack.push(1);
+ unsortedStack.push(30);
+ unsortedStack.push(9);
+ unsortedStack.push(13);
+
+ for(int i = 0; i <= unsortedStack.size(); i++) {
+ for(int j = i + 1; j < unsortedStack.size(); j++) {
+ if(unsortedStack.get(i) > unsortedStack.get(j)) {
+ assertFalse("Unsorted array!", false);
+ SortStack.sortStack(unsortedStack);
+ }else {
+ assertTrue("Sorted array", true);
+ }
+ }
+ }
+
+ SortStack.printStack(unsortedStack);
+ }
+
+}