From 8363d61d43bd280813be416ec205fe4db9888243 Mon Sep 17 00:00:00 2001 From: Heva Date: Sun, 27 Nov 2016 19:51:35 -0500 Subject: [PATCH] Add files via upload --- Summary_Ranges.cpp | 88 +++++++++ Surrounded_Regions.cpp | 143 ++++++++++++++ Switch_statements.java | 101 ++++++++++ Symmetric_tree.cpp | 94 +++++++++ Tag_Content_Extractor.js | 73 +++++++ The_Love_Letter_Mystery.js | 63 ++++++ The_Skyline_Problem.js | 130 +++++++++++++ The_Utopian_Tree.js | 81 ++++++++ The_connected_cell_in_a_grid.js | 104 ++++++++++ Trapping_Rain_Water.cpp | 92 +++++++++ Two_Sum.cpp | 69 +++++++ Two_Sum_2_Input_Array_is_Sorted.cpp | 67 +++++++ UTF_8_Validation.cpp | 96 +++++++++ Ugly_Number.cpp | 11 ++ Unique_Binary_Search_Trees.cpp | 62 ++++++ Unique_Binary_Search_Trees_2.cpp | 112 +++++++++++ Unique_Word_Abbreviation.cpp | 104 ++++++++++ Valid_Anagram.cpp | 68 +++++++ Valid_Palindrome.cpp | 14 ++ Valid_Parentheses.cpp | 77 ++++++++ Valid_Sudoku.cpp | 33 ++++ Valid_Username_Checker.js | 66 +++++++ Validate_Binary_Search_Tree.cpp | 82 ++++++++ Walls_and_Gates.cpp | 106 ++++++++++ Welcome_to_java.cpp | 10 + Wiggle_Sort.cpp | 73 +++++++ Wiggle_Sort_2.cpp | 72 +++++++ Wiggle_Subsequence.cpp | 111 +++++++++++ Wildcard_Matching.cpp | 163 ++++++++++++++++ Word_Break.cpp | 61 ++++++ Word_Break_2.cpp | 92 +++++++++ Word_Ladder_2.cpp | 291 ++++++++++++++++++++++++++++ Word_Pattern.cpp | 80 ++++++++ Word_Search_2.cpp | 186 ++++++++++++++++++ ZigZag_Iterator.cpp | 105 ++++++++++ Zigzag_Conversion.cpp | 58 ++++++ template_strings.java | 173 +++++++++++++++++ test.cpp | 73 +++++++ test.exe | Bin 0 -> 95649 bytes unordered_map.cpp | 43 ++++ variables.java | 25 +++ 41 files changed, 3552 insertions(+) create mode 100644 Summary_Ranges.cpp create mode 100644 Surrounded_Regions.cpp create mode 100644 Switch_statements.java create mode 100644 Symmetric_tree.cpp create mode 100644 Tag_Content_Extractor.js create mode 100644 The_Love_Letter_Mystery.js create mode 100644 The_Skyline_Problem.js create mode 100644 The_Utopian_Tree.js create mode 100644 The_connected_cell_in_a_grid.js create mode 100644 Trapping_Rain_Water.cpp create mode 100644 Two_Sum.cpp create mode 100644 Two_Sum_2_Input_Array_is_Sorted.cpp create mode 100644 UTF_8_Validation.cpp create mode 100644 Ugly_Number.cpp create mode 100644 Unique_Binary_Search_Trees.cpp create mode 100644 Unique_Binary_Search_Trees_2.cpp create mode 100644 Unique_Word_Abbreviation.cpp create mode 100644 Valid_Anagram.cpp create mode 100644 Valid_Palindrome.cpp create mode 100644 Valid_Parentheses.cpp create mode 100644 Valid_Sudoku.cpp create mode 100644 Valid_Username_Checker.js create mode 100644 Validate_Binary_Search_Tree.cpp create mode 100644 Walls_and_Gates.cpp create mode 100644 Welcome_to_java.cpp create mode 100644 Wiggle_Sort.cpp create mode 100644 Wiggle_Sort_2.cpp create mode 100644 Wiggle_Subsequence.cpp create mode 100644 Wildcard_Matching.cpp create mode 100644 Word_Break.cpp create mode 100644 Word_Break_2.cpp create mode 100644 Word_Ladder_2.cpp create mode 100644 Word_Pattern.cpp create mode 100644 Word_Search_2.cpp create mode 100644 ZigZag_Iterator.cpp create mode 100644 Zigzag_Conversion.cpp create mode 100644 template_strings.java create mode 100644 test.cpp create mode 100644 test.exe create mode 100644 unordered_map.cpp create mode 100644 variables.java diff --git a/Summary_Ranges.cpp b/Summary_Ranges.cpp new file mode 100644 index 0000000..9c482f2 --- /dev/null +++ b/Summary_Ranges.cpp @@ -0,0 +1,88 @@ +/*228. Summary Ranges QuestionEditorial Solution My Submissions +Total Accepted: 58494 Total Submissions: 219243 Difficulty: Medium +Given a sorted integer array without duplicates, return the summary of its ranges. + +For example, given [0,1,2,4,5,7], return ["0->2","4->5","7"]. + +Credits: +Special thanks to @jianchao.li.fighter for adding this problem and creating all test cases. + +Hide Company Tags Google +Hide Tags Array +Hide Similar Problems (M) Missing Ranges (H) Data Stream as Disjoint Intervals +*/ + + + + +/*for each element, initialize the step as 1 +check how large it can range, and put this range into the ret array*/ + +///////////////////////////////////////////////////////////////////////////////////// +//C++ +class Solution { +public: + vector summaryRanges(vector& nums) { + vector ret; + int i = 0; + int n = nums.size(); + while(i"+to_string(nums[i+j-1])); //remember -1, before is ++j + i += j; + } + + return ret; + } +}; + +class Solution { +public: + vector summaryRanges(vector& nums) { + int nsize = nums.size(); + vector nrange; //the vector is a string vector + + for(int i = 0; i < nsize;){ + int start = i, end = i; + while(end+1 start) nrange.push_back(to_string(nums[start])+"->"+to_string(nums[end])); //nums[start] not start + else nrange.push_back(to_string(nums[start])); + i = end +1; //through this to control the next value + } + return nrange; + } +}; + + + + + + + +///////////////////////////////////////////////////////////////////////////////////// +//Java +public class Solution { + public List summaryRanges(int[] nums) { + List ret = new ArrayList<>(); + if(nums==null || nums.length==0) return ret; + + int i = 0; + int n = nums.length; + while(i"+Integer.toString(nums[i+j-1])); + /*if(step>=2){ + ret.add(Integer.toString(nums[start]) + "->" + + Integer.toString(nums[start+step-1])); + } else if(step==1){ + ret.add(Integer.toString(nums[start])); + }*/ + i += j; + } + + return ret; + } +} \ No newline at end of file diff --git a/Surrounded_Regions.cpp b/Surrounded_Regions.cpp new file mode 100644 index 0000000..b5da81b --- /dev/null +++ b/Surrounded_Regions.cpp @@ -0,0 +1,143 @@ +/*130. Surrounded Regions QuestionEditorial Solution My Submissions +Total Accepted: 60534 +Total Submissions: 362069 +Difficulty: Medium +Given a 2D board containing 'X' and 'O' (the letter O), capture all regions surrounded by 'X'. + +A region is captured by flipping all 'O's into 'X's in that surrounded region. + +For example, +X X X X +X O O X +X X O X +X O X X +After running your function, the board should be: + +X X X X +X X X X +X X X X +X O X X +Subscribe to see which companies asked this question + +Show Tags +Show Similar Problems +*/ + + +/*First, check the four border of the matrix. If there is a element is +'O', alter it and all its neighbor 'O' elements to '1'. +Then ,alter all the 'O' to 'X' +At last,alter all the '1' to 'O'*/ + +///////////////////////////////////////////////////////////////////////////////////// +//C++ +class Solution { +public: + void solve(vector>& board) { + int i, j; + int row = board.size(); + if(!row){ + return; + } + + int col = board[0].size(); + for(i = 0; i < row; i++){ + check(board, i, 0, row, col); + if(col>1){ + check(board, i, col-1, row, col); + } + } + + for(j = 1; j + 1 < col; j++){ + check(board, 0, j, row, col); + if(row>1){ + check(board, row-1, j, row, col); + } + } + + for(i = 0; i < row; i++){ + for(j = 0; j < col; j++){ + if(board[i][j] == 'O'){ + board[i][j] = 'X'; + } + } + } + + for(i = 0; i < row; i++){ + for(j = 0; j < col; j++){ + if(board[i][j] == '1'){ + board[i][j] = 'O'; + } + } + } + } + + void check(vector > &board, int i, int j, int row, int col){ + if(board[i][j]=='O'){ + board[i][j] = '1'; + if(i>1) check(board, i-1, j, row, col); + if(j>1) check(board, i, j-1, row, col); + if(i+11){ + check(board, i, col-1, row, col); + } + } + + for(j = 1; j + 1 < col; j++){ + check(board, 0, j, row, col); + if(row>1){ + check(board, row-1, j, row, col); + } + } + + for(i = 0; i < row; i++){ + for(j = 0; j < col; j++){ + if(board[i][j] == 'O'){ + board[i][j] = 'X'; + } + } + } + + for(i = 0; i < row; i++){ + for(j = 0; j < col; j++){ + if(board[i][j] == '1'){ + board[i][j] = 'O'; + } + } + } + } + + public void check(char[][] board, int i, int j, int row, int col){ + if(board[i][j] == 'O'){ + board[i][j] = '1'; + if(i>1) check(board, i-1, j, row, col); + if(j>1) check(board, i, j-1, row, col); + if(i+1 read more on how binary tree is serialized on OJ. +*/ + + + +/*BFS +Search the left node and right node at the same time +recursively check the node*/ + +///////////////////////////////////////////////////////////////////////////////////// +//C++ +/** + * Definition for a binary tree node. + * struct TreeNode { + * int val; + * TreeNode *left; + * TreeNode *right; + * TreeNode(int x) : val(x), left(NULL), right(NULL) {} + * }; + */ +class Solution { +public: + bool isSymmetric(TreeNode* root) { + if(!root) return true; + return CheckSymmetric(root->left, root->right); + } + + bool CheckSymmetric(TreeNode* lNode, TreeNode* rNode){ + if(!lNode && !rNode) return true; //both child is NULL, true + else if(!lNode || !rNode) return false; //if there is only one child is NULL, should return false + + if(lNode->val != rNode->val) return false; + return CheckSymmetric(lNode->left, rNode->right) && CheckSymmetric(lNode->right, rNode->left); + } +}; + + + + + + +///////////////////////////////////////////////////////////////////////////////////// +//Java +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode(int x) { val = x; } + * } + */ +public class Solution { + public boolean isSymmetric(TreeNode root) { + if(root == null){ + return true; + } + + return CheckSymmetric(root.left, root.right); + } + + public boolean CheckSymmetric(TreeNode left, TreeNode right){ + if(left==null && right==null){ + return true; + } else if(left==null || right==null){ + return false; + } + + if(left.val != right.val){ + return false; + } + + return CheckSymmetric(left.left,right.right) && CheckSymmetric(left.right, right.left); + } +} \ No newline at end of file diff --git a/Tag_Content_Extractor.js b/Tag_Content_Extractor.js new file mode 100644 index 0000000..82d2a94 --- /dev/null +++ b/Tag_Content_Extractor.js @@ -0,0 +1,73 @@ +/* +In a tag-based language like XML or HTML, contents are enclosed between a start tag and an end tag like contents. Note that the corresponding end tag starts with a /. + +Given a string of text in a tag-based language, parse this text and retrieve the contents enclosed within sequences of well-organized tags meeting the following criterion: + +The name of the start and end tags must be same. The HTML code

Hello World

is not valid, because the text starts with an h1 tag and ends with a non-matching h2 tag. + +Tags can be nested, but content between nested tags is considered not valid. For example, in

contentsinvalid

, contents is valid but invalid is not valid. + +Tags can consist of any printable characters. + +Input Format + +The first line of input contains a single integer, NN (the number of lines). +The NN subsequent lines each contain a line of text. + +Constraints + +1≤N≤1001≤N≤100 +Each line contains a maximum of 104104 printable characters. +The total number of characters in all test cases will not exceed 106106. +Output Format + +For each line, print the content enclosed within valid tags. +If a line contains multiple instances of valid content, print out each instance of valid content on a new line; if no valid content is found, print None. + +Sample Input + +4 +

Nayeem loves counseling

+

Sanjay has no watch

So wait for a while +safat codes like a ninja +Imtiaz has a secret crush +Sample Output + +Nayeem loves counseling +Sanjay has no watch +So wait for a while +None +Imtiaz has a secret crush +*/ + +import java.io.*; +import java.util.*; +import java.text.*; +import java.math.*; +import java.util.regex.*; + +public class Solution{ + public static void main(String[] args){ + + Scanner in = new Scanner(System.in); + int testCases = Integer.parseInt(in.nextLine()); + while(testCases>0){ + String line = in.nextLine(); + + //Write your code here + int count = 0; + Pattern r = Pattern.compile("<(.+?)>([^<>]+)"); + Matcher m = r.matcher(line); + while(m.find()){ + if (m.group(2).length()!=0){ + System.out.println(m.group(2)); + count++; + } + } + if(count==0) + System.out.println("None"); + + testCases--; + } + } +} diff --git a/The_Love_Letter_Mystery.js b/The_Love_Letter_Mystery.js new file mode 100644 index 0000000..d877cd2 --- /dev/null +++ b/The_Love_Letter_Mystery.js @@ -0,0 +1,63 @@ +/* +James找到了他的朋友Harry要给女朋友的情书。James很爱恶作剧，所以他决定要胡搞一下。他把信中的每个单字都变成了回文。对任何给定的字符串，他可以减少其中任何一个字符的值，例如'd'可以变成'c'，这算是一次操作。(另外，他最多只能将字符的值减少至'a'，'a'不能再被减少成'z')。找出将给定字符串转换成回文所需的最少操作次数。 + + +输入格式 +第一行包含整数 T 代表测试数据的组数。 +接着 T 行各包含一个字符串。 + +输出格式 +每个测试数据各输出一行，代表此数据需要的最少操作次数。 + +取值范围 +1 ≤ T ≤ 10 +1 ≤ 字符串长度 ≤ 104 + +样例输入 #00 + +3 +abc +abcba +abcd +样例输出 #00 + +2 +0 +4 +样例解析 + +第一组数据：ab*c* -> ab*b* -> ab*a*。 +第二组数据：abcba本身已经是回文了。 +第三组数据：abc*d* -> abc*c* -> abc*b* -> abc*a* = ab*c*a -> ab*b*a。 +*/ + +function processData(input) { + //Enter your code here + var data = input.split('\n'); + //var nsize = data[0]; + var nsize = parseInt(data[0]); + for(var i = 1; i <= nsize; i++){ + var count = 0; + var current_string = data[i]; //var current_string=input.split('\n')[i+1]; + var len = current_string.length-1; + var slen = 0; + while(slen <= len){ + count += Math.abs(current_string.charCodeAt(len)-current_string.charCodeAt(slen)); + slen++; + len--; + } + console.log(count); + } + +} + +process.stdin.resume(); +process.stdin.setEncoding("ascii"); +_input = ""; +process.stdin.on("data", function (input) { + _input += input; +}); + +process.stdin.on("end", function () { + processData(_input); +}); diff --git a/The_Skyline_Problem.js b/The_Skyline_Problem.js new file mode 100644 index 0000000..05089e1 --- /dev/null +++ b/The_Skyline_Problem.js @@ -0,0 +1,130 @@ +/* +A city's skyline is the outer contour of the silhouette formed by all the buildings in that city when viewed from a distance. Now suppose you are given the locations and height of all the buildings as shown on a cityscape photo (Figure A), write a program to output the skyline formed by these buildings collectively (Figure B). + + Buildings Skyline Contour +The geometric information of each building is represented by a triplet of integers [Li, Ri, Hi], where Li and Ri are the x coordinates of the left and right edge of the ith building, respectively, and Hi is its height. It is guaranteed that 0 ≤ Li, Ri ≤ INT_MAX, 0 < Hi ≤ INT_MAX, and Ri - Li > 0. You may assume all buildings are perfect rectangles grounded on an absolutely flat surface at height 0. + +For instance, the dimensions of all buildings in Figure A are recorded as: [ [2 9 10], [3 7 15], [5 12 12], [15 20 10], [19 24 8] ] . + +The output is a list of "key points" (red dots in Figure B) in the format of [ [x1,y1], [x2, y2], [x3, y3], ... ] that uniquely defines a skyline. A key point is the left endpoint of a horizontal line segment. Note that the last key point, where the rightmost building ends, is merely used to mark the termination of the skyline, and always has zero height. Also, the ground in between any two adjacent buildings should be considered part of the skyline contour. + +For instance, the skyline in Figure B should be represented as:[ [2 10], [3 15], [7 12], [12 0], [15 10], [20 8], [24, 0] ]. + +Notes: + +The number of buildings in any input list is guaranteed to be in the range [0, 10000]. +The input list is already sorted in ascending order by the left x position Li. +The output list must be sorted by the x position. +There must be no consecutive horizontal lines of equal height in the output skyline. For instance, [...[2 3], [4 5], [7 5], [11 5], [12 7]...] is not acceptable; the three lines of height 5 should be merged into one in the final output as such: [...[2 3], [4 5], [12 7], ...] + +Credits: +Special thanks to @stellari for adding this problem, creating these two awesome images and all test cases. + +Hide Company Tags Microsoft Google Facebook Twitter Yelp +Hide Tags Binary Indexed Tree Segment Tree Heap Divide and Conquer +*/ + + + + + + +/////////////////////////////////////////////////////////////////////////////////////////////////// +//C++ +class Solution { +public: + vector> getSkyline(vector>& buildings) { + multimap heights; + for(const vector &b:buildings){ + heights.emplace(b[0],b[2]); + heights.emplace(b[1],-b[2]); + } + + multiset hset = {0}; + vector > heightMap; + int x = -1; + int y = 0; + for(const pair h:heights){ + if((x>=0) && (h.first!=x) && (heightMap.empty() || (heightMap.rbegin()->second != y))){ + heightMap.emplace_back(x,y); + } + + if(h.second>=0){ + hset.insert(h.second); + }else{ + hset.erase(hset.find(-h.second)); + } + + x = h.first; + y = *hset.rbegin(); + } + + if(!heightMap.empty()){ + heightMap.emplace_back(x,0); + } + + return heightMap; + } +}; + + + + + +/*use heights = arraylist to store the buildings +push into the list, set the left side as negative one, set the right side as positive one +sort the heights according to their position +for each h in heights + if it is the left side of the building, push it into heightMap + else minus the correspond building key + use heightMap.firstKey() to get the curr height + if it is not equal to pre one, add it into skyLine list + +*/ + +///////////////////////////////////////////////////////////////////////////////////// +//Java +public class Solution { + public List getSkyline(int[][] buildings) { + List skyLine = new ArrayList<>(); + if(buildings==null ||buildings.length==0 || buildings[0].length==0) return skyLine; + + List heights = new ArrayList<>(); + for(int[] b:buildings){ + heights.add(new int[]{b[0],-b[2]}); //set new int[] + heights.add(new int[]{b[1],b[2]}); + } + + Collections.sort(heights, (a,b) -> (a[0]==b[0] ? a[1]-b[1] : a[0]-b[0])); + //TreeMap can sorted the elements + //key is the height of building's left side + //value is how many buildings has this left side + TreeMap heightMap = new TreeMap<>(Collections.reverseOrder()); + heightMap.put(0,1); + + int preHeight = 0; + for(int[] h:heights){ + if(h[1] < 0){ + //this is the left side of one building + Integer cur = heightMap.get(-h[1]); //use Integer not int, we need to compare it with null + cur = (cur==null ? 1 : cur+1); + heightMap.put(-h[1],cur); + } else { + //this is the right side of the building + Integer cur = heightMap.get(h[1]); + if(cur==1){//only one building has this value, remove this building from map + heightMap.remove(h[1]); + } else { + heightMap.put(h[1], cur-1); + } + } + int curHeight = heightMap.firstKey(); //use firstKey() to get the lowest key in heightMap, since we initialize reverseOrder(), this return the largest key + if(curHeight != preHeight){ + skyLine.add(new int[]{h[0],curHeight}); + preHeight = curHeight; + } + } + + return skyLine; + } +} \ No newline at end of file diff --git a/The_Utopian_Tree.js b/The_Utopian_Tree.js new file mode 100644 index 0000000..b128382 --- /dev/null +++ b/The_Utopian_Tree.js @@ -0,0 +1,81 @@ +/* +The Utopian Tree goes through 2 cycles of growth every year. Each spring, it doubles in height. Each summer, its height increases by 1 meter. + +Laura plants a Utopian Tree sapling with a height of 1 meter at the onset of spring. How tall will her tree be after NN growth cycles? + +Input Format + +The first line contains an integer, TT, the number of test cases. +TT subsequent lines each contain an integer, NN, denoting the number of cycles for that test case. + +Constraints +1≤T≤101≤T≤10 +0≤N≤600≤N≤60 +Output Format + +For each test case, print the height of the Utopian Tree after NN cycles. Each height must be printed on a new line. + +Sample Input + +3 +0 +1 +4 +Sample Output + +1 +2 +7 +Explanation + +There are 3 test cases. + +In the first case (N=0N=0), the initial height (H=1H=1) of the tree remains unchanged. + +In the second case (N=1N=1), the tree doubles in height and is 22 meters tall after the spring cycle. + +In the third case (N=4N=4), the tree doubles its height in spring (H=2H=2), then grows a meter in summer (H=3H=3), then doubles after the next spring (H=6H=6), and grows another meter after summer (H=7H=7). Thus, at the end of 4 cycles, its height is 77 meters. +*/ + +process.stdin.resume(); +process.stdin.setEncoding('ascii'); + +var input_stdin = ""; +var input_stdin_array = ""; +var input_currentline = 0; + +process.stdin.on('data', function (data) { + input_stdin += data; +}); + +process.stdin.on('end', function () { + input_stdin_array = input_stdin.split("\n"); + main(); +}); + +function readLine() { + return input_stdin_array[input_currentline++]; +} + +/////////////// ignore above this line //////////////////// + +function main() { + var t = parseInt(readLine()); + var initialHeight = 1; + var height = initialHeight; + for(var a0 = 0; a0 < t; a0++){ + var n = parseInt(readLine()); + if(n == 0) console.log(initialHeight); + else{ + height = initialHeight; + for(var a1 = 1; a1 <= n; a1++){ + if(a1%2 == 1) height = 2 * height; + else if(a1%2 == 0) height = height + 1; + }; + console.log(height); + } + } + + + +} \ No newline at end of file diff --git a/The_connected_cell_in_a_grid.js b/The_connected_cell_in_a_grid.js new file mode 100644 index 0000000..6075d1c --- /dev/null +++ b/The_connected_cell_in_a_grid.js @@ -0,0 +1,104 @@ +/* +You are given a matrix with mm rows and nn columns of cells, each of which contains either 11 or 00. Two cells are said to be connected if they are adjacent to each other horizontally, vertically, or diagonally. The connected and filled (i.e. cells that contain a 11) cells form a region. There may be several regions in the matrix. Find the number of cells in the largest region in the matrix. + +Input Format +There will be three parts of t input: +The first line will contain mm, the number of rows in the matrix. +The second line will contain nn, the number of columns in the matrix. +This will be followed by the matrix grid: the list of numbers that make up the matrix. + +Output Format +Print the length of the largest region in the given matrix. + +Constraints +0 0){ + arr.push(inputData[n].split(' ')); + n++; + } + + var counts = new Array(); + for(var i = 0; i < nrows; i++){ + for(var j = 0; j < ncols; j++) + counts.push(region(i, j, nrows, ncols, arr)); + } + + var maxcounts = counts[0]; + for(i = 0; i < counts.length; i++){ + if(counts[i]>maxcounts) maxcounts = counts[i]; + } + //console.log(counts); + console.log(maxcounts); +} + +function region(irow, icol, nrows, ncols, arr) +{ + if(irow >= nrows) irow = nrows-1; + if(icol >= ncols) icol = ncols-1; + if(irow < 0) irow = 0; + if(icol < 0) icol = 0; + var count = 0; + var arrele = arr[irow][icol]; + if(arrele == 8) return 0; //we have already count this region + if(arrele == 0) return 0; //it is not region + if(arrele == 1){//choose the next region + count++; + arr[irow][icol] = 8; + count += region(irow+1, icol, nrows, ncols, arr); + count += region(irow-1, icol, nrows, ncols, arr); + count += region(irow, icol+1, nrows, ncols, arr); + count += region(irow, icol-1, nrows, ncols, arr); + count += region(irow+1, icol+1, nrows, ncols, arr); + count += region(irow+1, icol-1, nrows, ncols, arr); + count += region(irow-1, icol+1, nrows, ncols, arr); + count += region(irow-1, icol-1, nrows, ncols, arr); + } + return count; +} + + +process.stdin.resume(); +process.stdin.setEncoding("ascii"); +_input = ""; +process.stdin.on("data", function (input) { + _input += input; +}); + +process.stdin.on("end", function () { + processData(_input); +}); + + diff --git a/Trapping_Rain_Water.cpp b/Trapping_Rain_Water.cpp new file mode 100644 index 0000000..516ec0d --- /dev/null +++ b/Trapping_Rain_Water.cpp @@ -0,0 +1,92 @@ +/*42. Trapping Rain Water QuestionEditorial Solution My Submissions +Total Accepted: 83168 Total Submissions: 243044 Difficulty: Hard +Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it is able to trap after raining. + +For example, +Given [0,1,0,2,1,0,1,3,2,1,2,1], return 6. + + +The above elevation map is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped. Thanks Marcos for contributing this image! + +Hide Company Tags Google Twitter Zenefits Amazon Apple Bloomberg +Hide Tags Array Stack Two Pointers +Hide Similar Problems (M) Container With Most Water (M) Product of Array Except Self (H) Trapping Rain Water II +*/ + + + +/*O(n) time, O(1) space +Two Pointers, +one for left, one for right, +try to find the maxL and maxR seperately +compare A[left] and A[right] +if A[left]<=A[right] + if A[left]>=maxL, update maxL, otherwise, add the ret water + left++ +otherwise, compare A[right] and maxR, similarly to right side, and right--*/ + +///////////////////////////////////////////////////////////////////////////////////// +//C++ +class Solution { +public: + int trap(vector& height) { + int left = 0, right = height.size()-1; + if(height.size()<=1) return 0; + int ret = 0; + int maxL = 0, maxR = 0; + while(left <= right){ + if(height[left] <= height[right]){ + //check left side, + if(height[left] >= maxL){ + maxL = height[left]; + } else { + ret += maxL-height[left]; + } + left++; + } else { + //check right side + if(height[right] >= maxR){ + maxR = height[right]; + } else { + ret += maxR-height[right]; + } + right--; + } + } + return ret; + } +}; + + + + +///////////////////////////////////////////////////////////////////////////////////// +//Java +public class Solution { + public int trap(int[] height) { + if(height==null || height.length==0) return 0; + int left = 0, right = height.length-1; + int ret = 0; + int maxL = 0, maxR = 0; + while(left <= right){ + if(height[left] <= height[right]) { + //check left side + if(height[left] >= maxL) { + maxL = height[left]; + } else { + ret += maxL-height[left]; + } + left++; //remember left++ + } else { + //check the right side + if(height[right] >= maxR) { + maxR = height[right]; + } else { + ret += maxR-height[right]; + } + right--;// remember right-- + } + } + return ret; + } +} diff --git a/Two_Sum.cpp b/Two_Sum.cpp new file mode 100644 index 0000000..643b060 --- /dev/null +++ b/Two_Sum.cpp @@ -0,0 +1,69 @@ +/*1. Two Sum QuestionEditorial Solution My Submissions +Total Accepted: 330110 Total Submissions: 1188061 Difficulty: Easy Contributors: Admin +Given an array of integers, return indices of the two numbers such that they add up to a specific target. + +You may assume that each input would have exactly one solution. + +Example: +Given nums = [2, 7, 11, 15], target = 9, + +Because nums[0] + nums[1] = 2 + 7 = 9, +return [0, 1]. +UPDATE (2016/2/13): +The return format had been changed to zero-based indices. Please read the above updated description carefully. + +Hide Company Tags LinkedIn Uber Airbnb Facebook Amazon Microsoft Apple Yahoo Dropbox Bloomberg Yelp Adobe +Hide Tags Array Hash Table +Hide Similar Problems (M) 3Sum (M) 4Sum (M) Two Sum II - Input array is sorted (E) Two Sum III - Data structure design +*/ + + + +/* +use hashmap to store the value in array, and their correspond index +for search, check if target-curvalue is exist in map, +if it is, return their index*/ + +///////////////////////////////////////////////////////////////////////////////////// +//C++ +class Solution { +public: + vector twoSum(vector& nums, int target) { + //Key is the number and value is its index in the vector. + unordered_map hash; + vector result; + for (int i = 0; i < nums.size(); i++) { + int numberToFind = target - nums[i]; + + //if numberToFind is found in map, return them + if (hash.find(numberToFind) != hash.end()) { + result.push_back(hash[numberToFind] ); + result.push_back(i); + return result; + } + + //number was not found. Put it in the map. + hash[nums[i]] = i; + } + return result; + } +}; + + + + +///////////////////////////////////////////////////////////////////////////////////// +//Java +public class Solution { + public int[] twoSum(int[] nums, int target) { + Map mymap = new HashMap<>(); + for(int i = 0; i < nums.length; ++i){ + int n1 = target-nums[i]; + if(mymap.containsKey(n1)){ + return new int[]{mymap.get(n1), i}; + } + mymap.put(nums[i],i); + } + return new int[]{-1,-1}; + } +} diff --git a/Two_Sum_2_Input_Array_is_Sorted.cpp b/Two_Sum_2_Input_Array_is_Sorted.cpp new file mode 100644 index 0000000..04d1b82 --- /dev/null +++ b/Two_Sum_2_Input_Array_is_Sorted.cpp @@ -0,0 +1,67 @@ +/*167. Two Sum II - Input array is sorted QuestionEditorial Solution My Submissions +Total Accepted: 32791 Total Submissions: 68140 Difficulty: Medium Contributors: Admin +Given an array of integers that is already sorted in ascending order, find two numbers such that they add up to a specific target number. + +The function twoSum should return indices of the two numbers such that they add up to the target, where index1 must be less than index2. Please note that your returned answers (both index1 and index2) are not zero-based. + +You may assume that each input would have exactly one solution. + +Input: numbers={2, 7, 11, 15}, target=9 +Output: index1=1, index2=2 + +Hide Company Tags Amazon +Hide Tags Array Two Pointers Binary Search +Hide Similar Problems (E) Two Sum +*/ + + + +/* O(n) +since it is already sorted, we use two pointers + one at start, and another one start from the end + each time move two pointers + if larger than target, move the back pointer + if less than target, move the forward poitner*/ + +///////////////////////////////////////////////////////////////////////////////////// +//C++ +class Solution { +public: + vector twoSum(vector& numbers, int target) { + int lo=0, hi=numbers.size()-1; + while (numbers[lo]+numbers[hi]!=target){ + if (numbers[lo]+numbers[hi]({lo+1,hi+1}); + } +}; + + + + +///////////////////////////////////////////////////////////////////////////////////// +//Java +public class Solution { + public int[] twoSum(int[] numbers, int target) { + int left = 0; + int right = numbers.length - 1; + + while(left <= right){ + int sum = numbers[left] + numbers[right]; + if(sum > target){ + //move the right pointer to make sum smaller + right--; + } else if (sum < target){ + left++; + } else { + //sum == target + break; + } + } + return new int[]{left+1, right+1}; + } +} diff --git a/UTF_8_Validation.cpp b/UTF_8_Validation.cpp new file mode 100644 index 0000000..5402eea --- /dev/null +++ b/UTF_8_Validation.cpp @@ -0,0 +1,96 @@ +/*393. UTF-8 Validation QuestionEditorial Solution My Submissions +Total Accepted: 546 +Total Submissions: 2431 +Difficulty: Medium +A character in UTF8 can be from 1 to 4 bytes long, subjected to the following rules: + +For 1-byte character, the first bit is a 0, followed by its unicode code. +For n-bytes character, the first n-bits are all one's, the n+1 bit is 0, followed by n-1 bytes with most significant 2 bits being 10. +This is how the UTF-8 encoding would work: + + Char. number range | UTF-8 octet sequence + (hexadecimal) | (binary) + --------------------+--------------------------------------------- + 0000 0000-0000 007F | 0xxxxxxx + 0000 0080-0000 07FF | 110xxxxx 10xxxxxx + 0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx + 0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx +Given an array of integers representing the data, return whether it is a valid utf-8 encoding. + +Note: +The input is an array of integers. Only the least significant 8 bits of each integer is used to store the data. This means each integer represents only 1 byte of data. + +Example 1: + +data = [197, 130, 1], which represents the octet sequence: 11000101 10000010 00000001. + +Return true. +It is a valid utf-8 encoding for a 2-bytes character followed by a 1-byte character. +Example 2: + +data = [235, 140, 4], which represented the octet sequence: 11101011 10001100 00000100. + +Return false. +The first 3 bits are all one's and the 4th bit is 0 means it is a 3-bytes character. +The next byte is a continuation byte which starts with 10 and that's correct. +But the second continuation byte does not start with 10, so it is invalid. +Hide Company Tags Google +Hide Tags Bit Manipulation +*/ + + + +/*seperately check the start of the number, using a count to control the last n-1 numbers +if (d>>5)==0b110, this number should be 2 bytes character ,count = 1 +if (d>>4)==0b1110, this number should be 3 bytes character ,count = 2 +if (d>>3)==0b11110, this number should be 4 bytes character ,count = 3 +if (d>>7)==0, this number should be 1 bytes character +then check the last n-1 numbers +when count!=0, means we need to continue check if it is a perfect characer number + if (d>>6)!=0b10, this number is not perfect, return false + else count--. check the next number, until count==0 +*/ + +///////////////////////////////////////////////////////////////////////////////////// +//C++ +class Solution { +public: + bool validUtf8(vector& data) { + int count = 0; + for(auto d: data){ + if(count==0){ + if((d>>5)==0b110) count = 1; + else if((d>>4)==0b1110) count = 2; + else if((d>>3)==0b11110) count = 3; + else if((d>>7)) return false; + } else { + if((d>>6)!=0b10) return false; + count--; + } + } + return !count; //check if count == 0 + } +}; + + + + +///////////////////////////////////////////////////////////////////////////////////// +//Java +public class Solution { + public boolean validUtf8(int[] data) { + int count = 0;//help check which bytes are this number + for(int d:data){ + if(count==0){ + if((d>>5)==0b110) count = 1; //2 bytes + else if((d>>4)==0b1110) count = 2; //3 bytes + else if((d>>3)==0b11110) count = 3;//4 bytes + else if((d>>7)!=0) return false; //not 1 bytes, remember != + } else { + if((d>>6)!=0b10) return false; + count--; + } + } + return count==0; + } +} \ No newline at end of file diff --git a/Ugly_Number.cpp b/Ugly_Number.cpp new file mode 100644 index 0000000..2999b2d --- /dev/null +++ b/Ugly_Number.cpp @@ -0,0 +1,11 @@ +class Solution { +public: + bool isUgly(int num) { + for(int i = 2; i < 6 && num; i++) + { + while(num%i == 0) + num /= i; + } + return num == 1; + } +}; \ No newline at end of file diff --git a/Unique_Binary_Search_Trees.cpp b/Unique_Binary_Search_Trees.cpp new file mode 100644 index 0000000..eae7dd8 --- /dev/null +++ b/Unique_Binary_Search_Trees.cpp @@ -0,0 +1,62 @@ +/*96. Unique Binary Search Trees QuestionEditorial Solution My Submissions +Total Accepted: 93941 +Total Submissions: 242894 +Difficulty: Medium +Given n, how many structurally unique BST's (binary search trees) that store values 1...n? + +For example, +Given n = 3, there are a total of 5 unique BST's. + + 1 3 3 2 1 + \ / / / \ \ + 3 2 1 1 3 2 + / / \ \ + 2 1 2 3 +Subscribe to see which companies asked this question*/ + + + +/*DP dynamic programming +define two functions +G(n): the number of unique BST for the sequence of length n +F(i,n), 1<=i<=n: i is the root of BST, sequence ranges from 1 to n +G(n) = F(1, n) + F(2, n) + ... + F(n, n). +G(0)=1, G(1)=1. +F(i, n) = G(i-1) * G(n-i) 1 <= i <= n +G(n) = G(0) * G(n-1) + G(1) * G(n-2) + … + G(n-1) * G(0) */ + +///////////////////////////////////////////////////////////////////////////////////// +//C++ +class Solution { +public: + int numTrees(int n) { + vector G(n+1); + G[0] = 1; + G[1] = 1; + for(int i = 2; i <= n; ++i){ //start from 2 + for(int j = 1; j <= i; ++j){ //start from 1 + G[i] += G[j-1] * G[i-j]; //remember(+=) + } + } + return G[n]; + } +}; + + + + +///////////////////////////////////////////////////////////////////////////////////// +//Java +public class Solution { + public int numTrees(int n) { + int[] G = new int[n+1]; + G[0] = 1; + G[1] = 1; + for(int i = 2; i <= n; ++i){ + for(int j = 1; j <= i; ++j){ + G[i] += G[j-1]*G[i-j]; + } + } + return G[n]; + } +} \ No newline at end of file diff --git a/Unique_Binary_Search_Trees_2.cpp b/Unique_Binary_Search_Trees_2.cpp new file mode 100644 index 0000000..dbebe94 --- /dev/null +++ b/Unique_Binary_Search_Trees_2.cpp @@ -0,0 +1,112 @@ +/*95. Unique Binary Search Trees II QuestionEditorial Solution My Submissions +Total Accepted: 63260 +Total Submissions: 212899 +Difficulty: Medium +Given an integer n, generate all structurally unique BST's (binary search trees) that store values 1...n. + +For example, +Given n = 3, your program should return all 5 unique BST's shown below. + + 1 3 3 2 1 + \ / / / \ \ + 3 2 1 1 3 2 + / / \ \ + 2 1 2 3 +Subscribe to see which companies asked this question*/ + + +/*DP*/ +/*1...n is the in-order traversal for BST +pick i-th node as the root, the elements i to (i-1) should be the left node +the element (i+1) to n should be the right node +recursively do this +*/ + +///////////////////////////////////////////////////////////////////////////////////// +//C++ +/** + * Definition for a binary tree node. + * struct TreeNode { + * int val; + * TreeNode *left; + * TreeNode *right; + * TreeNode(int x) : val(x), left(NULL), right(NULL) {} + * }; + */ +class Solution { +public: + vector generateTrees(int n) { + if(n==0){ + return vector(); + } + return buildTree(1, n); + } + + vector buildTree(int start, int end){ + vector ret; + if(start>end){ + ret.push_back(NULL); + } + + vector left, right; + for(int i = start; i <= end; ++i){ + left = buildTree(start, i-1); + right = buildTree(i+1, end); + for(TreeNode* l:left){ + for(TreeNode* r:right){ + TreeNode* root = new TreeNode(i); + root->left = l; + root->right = r; + ret.push_back(root); + } + } + } + + return ret; + } +}; + + + + +///////////////////////////////////////////////////////////////////////////////////// +//Java +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode(int x) { val = x; } + * } + */ +public class Solution { + public List generateTrees(int n) { + if(n==0){ + return (new LinkedList()); + } + return buildTree(1,n); + } + + public List buildTree(int start, int end){ + List ret = new LinkedList<>(); + if(start > end){ + ret.add(null); + } + + for(int i = start; i <= end; ++i){ + List left = buildTree(start, i-1); + List right = buildTree(i+1, end); + for(TreeNode l:left){ + for(TreeNode r:right){ + TreeNode root = new TreeNode(i); + root.left = l; + root.right = r; + ret.add(root); + } + } + } + + return ret; + } +} \ No newline at end of file diff --git a/Unique_Word_Abbreviation.cpp b/Unique_Word_Abbreviation.cpp new file mode 100644 index 0000000..f65d590 --- /dev/null +++ b/Unique_Word_Abbreviation.cpp @@ -0,0 +1,104 @@ +/*288. Unique Word Abbreviation QuestionEditorial Solution My Submissions +Total Accepted: 15926 +Total Submissions: 102353 +Difficulty: Easy +An abbreviation of a word follows the form . Below are some examples of word abbreviations: + +a) it --> it (no abbreviation) + + 1 +b) d|o|g --> d1g + + 1 1 1 + 1---5----0----5--8 +c) i|nternationalizatio|n --> i18n + + 1 + 1---5----0 +d) l|ocalizatio|n --> l10n +Assume you have a dictionary and given a word, find whether its abbreviation is unique in the dictionary. A word's abbreviation is unique if no other word from the dictionary has the same abbreviation. + +Example: +Given dictionary = [ "deer", "door", "cake", "card" ] + +isUnique("dear") -> false +isUnique("cart") -> true +isUnique("cane") -> false +isUnique("make") -> true +Hide Company Tags Google +Hide Tags Hash Table Design +Hide Similar Problems (E) Two Sum III - Data structure design (M) Generalized Abbreviation +*/ + + + +/*Use unordered_map to store the unique word +for isUnique, just check if this abbreviation exist*/ + +///////////////////////////////////////////////////////////////////////////////////// +//C++ +class ValidWordAbbr { + private: + unordered_map> mymap; +public: + ValidWordAbbr(vector &dictionary) { + for(string s:dictionary){ + int n = s.size(); + string newString = s[0] + to_string(n) + s[n-1]; + mymap[newString].insert(s); + } + } + + bool isUnique(string word) { + int n = word.size(); + string newString = word[0] + to_string(n) + word[n-1]; + return mymap[newString].count(word) == mymap[newString].size(); + } +}; + + +// Your ValidWordAbbr object will be instantiated and called as such: +// ValidWordAbbr vwa(dictionary); +// vwa.isUnique("hello"); +// vwa.isUnique("anotherWord"); + + + + +///////////////////////////////////////////////////////////////////////////////////// +//Java +public class ValidWordAbbr { + private HashMap> mymap; + + public ValidWordAbbr(String[] dictionary) { + mymap = new HashMap>(); + for(String s:dictionary){ + String newString = getKey(s); + //if s is already inserted, check if it is equal + if(!mymap.containsKey(newString)){ + mymap.put(newString, new HashSet()); + } + mymap.get(newString).add(s); + // System.out.println(mymap.get(newString) + " " + newString); + } + } + + public boolean isUnique(String word) { + String newString = getKey(word); + // System.out.println(newString + " " + mymap.containsKey(newString)); + return !mymap.containsKey(newString) || + (mymap.get(newString).size()==1 && mymap.get(newString).contains(word)); + } + + public String getKey(String s){ + if(s.length() <=2 ) return s; + int n = s.length(); + return s.charAt(0) + Integer.toString(n-2) + s.charAt(n-1); + } +} + + +// Your ValidWordAbbr object will be instantiated and called as such: +// ValidWordAbbr vwa = new ValidWordAbbr(dictionary); +// vwa.isUnique("Word"); +// vwa.isUnique("anotherWord"); diff --git a/Valid_Anagram.cpp b/Valid_Anagram.cpp new file mode 100644 index 0000000..9a4d6e0 --- /dev/null +++ b/Valid_Anagram.cpp @@ -0,0 +1,68 @@ +/*242. Valid Anagram QuestionEditorial Solution My Submissions +Total Accepted: 107559 +Total Submissions: 246357 +Difficulty: Easy +Given two strings s and t, write a function to determine if t is an anagram of s. + +For example, +s = "anagram", t = "nagaram", return true. +s = "rat", t = "car", return false. + +Note: +You may assume the string contains only lowercase alphabets. + +Follow up: +What if the inputs contain unicode characters? How would you adapt your solution to such case? + +Subscribe to see which companies asked this question*/ + + + +/*use an extra array to store the count of each alphabet in string s and string t +one insert, one delete, if there are some count of element is not 0, return false +else return true*/ + +///////////////////////////////////////////////////////////////////////////////////// +//C++ +class Solution { +public: + bool isAnagram(string s, string t) { + if(s.length() != t.length()) return false; + vector snum(26,0); + for(int i = 0; i < s.length(); i++) + { + snum[s[i]-'a']++; + snum[t[i]-'a']--; + } + for(int i = 0; i < snum.size(); i++) + { + if(snum[i]) return false; + } + return true; + } +}; + + + + + + +///////////////////////////////////////////////////////////////////////////////////// +//Java +public class Solution { + public boolean isAnagram(String s, String t) { + int[] temp = new int[26]; + if(s.length() != t.length()) return false; + + for(int i = 0; i < s.length(); ++i){ + temp[s.charAt(i)-'a']++; //use charAt to get the char + temp[t.charAt(i)-'a']--; + } + + for(int i:temp){ + if(i!=0) return false; + } + + return true; + } +} \ No newline at end of file diff --git a/Valid_Palindrome.cpp b/Valid_Palindrome.cpp new file mode 100644 index 0000000..355c85c --- /dev/null +++ b/Valid_Palindrome.cpp @@ -0,0 +1,14 @@ +#include //toupper & isalnum + +class Solution { +public: + bool isPalindrome(string s) { + for(int i = 0, j = s.size()-1; i < j; i++, j--) + { + while(!isalnum(s[i]) && (i s1; + + for(char c:s){ + if(c=='(' || c=='{' || c=='[') s1.push(c); + else if(c==')' && !s1.empty() && s1.top()=='(') s1.pop(); + else if(c=='}' && !s1.empty() && s1.top()=='{') s1.pop(); + else if(c==']' && !s1.empty() && s1.top()=='[') s1.pop(); + else return false; + } + + return s1.empty(); + } +}; + +class Solution { +public: + bool isValid(string s) { + stack s1; + for(char &c : s){ + switch(c){ + case '(': //s1.push(c); break; + case '{': //s1.push(c); break; + case '[': s1.push(c); break; + case ')': if(s1.empty() || s1.top()!='(') return false; else s1.pop(); break; + case '}': if(s1.empty() || s1.top()!='{') return false; else s1.pop(); break; + case ']': if(s1.empty() || s1.top()!='[') return false; else s1.pop(); break; + default: ; + } + } + return s1.empty(); + } +}; + + + + + + +///////////////////////////////////////////////////////////////////////////////////// +//Java +public class Solution { + public boolean isValid(String s) { + Stack s1 = new Stack<>(); + for(char c:s.toCharArray()){ + if(c=='(' || c=='{' || c=='[' ) s1.push(c); + else if(c==')' && !s1.empty() && s1.peek()=='(') s1.pop(); //remember !empty + else if(c=='}' && !s1.empty() && s1.peek()=='{') s1.pop(); + else if(c==']' && !s1.empty() && s1.peek()=='[') s1.pop(); + else return false; //need to return false like []} situation + } + + return s1.empty(); + } +} \ No newline at end of file diff --git a/Valid_Sudoku.cpp b/Valid_Sudoku.cpp new file mode 100644 index 0000000..6edb8e3 --- /dev/null +++ b/Valid_Sudoku.cpp @@ -0,0 +1,33 @@ +/* +Determine if a Sudoku is valid, according to: Sudoku Puzzles - The Rules. + +The Sudoku board could be partially filled, where empty cells are filled with the character '.'. + + +A partially filled sudoku which is valid. +*/ + +class Solution { +public: + bool isValidSudoku(vector>& board) { + vector > rboard(9, vector(9,0)); //control the rows + vector > cboard(9, vector(9,0)); //control the columns + vector > subboard(9, vector(9,0));//control the subboards + + for(int i = 0; i < board.size(); i++){ + for(int j = 0; j < board[i].size(); j++){ + if(board[i][j] != '.'){ + int num = board[i][j] - '0' - 1; + int k = i / 3 * 3 + j / 3; //control the position of the subboards + + if(rboard[i][num] || cboard[j][num] || subboard[k][num]) //check if this number has occur + return false; + + rboard[i][num] = cboard[j][num] = subboard[k][num] = 1; + } + } + } + + return true; + } +}; \ No newline at end of file diff --git a/Valid_Username_Checker.js b/Valid_Username_Checker.js new file mode 100644 index 0000000..aa7e1f7 --- /dev/null +++ b/Valid_Username_Checker.js @@ -0,0 +1,66 @@ +/* +Regular expressions (regexpregexp) help us match or search for patterns in strings. In this problem, you will be given a username. Your task is to check whether that username is valid. A valid username will have the following properties: + +The username can contain alphanumeric characters and/or underscores(_). +The username must start with an alphabetic character. +8 ≤≤ |Username| ≤≤ 30. +To simplify your task, we have provided a portion of the code in the editor. You just need to write down the regexregex pattern which will be used to validate the username input. + +Input Format + +The first line of input contains an integer NN, representing the number of testcases. Each of the next NN lines contains a string that represents a username. + +Constraints + +The username consists of any printable characters. +1≤N≤1001≤N≤100 +Output Format + +For each username, output Valid if the username is valid; otherwise, output Invalid. + +Sample Input + +4 +alpha_naheed +xahidbuffon +nagib@007 +123Swakkhar +Sample Output + +Valid +Valid +Invalid +Invalid +Explanation + +The first two cases fulfill the constraints of a valid username. The third case is invalid because it contains an invalid character '@'. The fourth case is also invalid because it starts with a numeric character. +*/ + +import java.io.*; +import java.util.*; +import java.text.*; +import java.math.*; +import java.util.regex.*; + +public class Solution { + public static void main(String[] args){ + Scanner in = new Scanner(System.in); + int testCases = Integer.parseInt(in.nextLine()); + while(testCases>0){ + String username = in.nextLine(); + //String pattern = Complete this line in the editable area below + + String pattern = "^[A-Za-z][A-Za-z0-9_]{7,29}$";//~~Write your pattern here~~; + + Pattern r = Pattern.compile(pattern); + Matcher m = r.matcher(username); + + if (m.find( )) { + System.out.println("Valid"); + } else { + System.out.println("Invalid"); + } + testCases--; + } + } +} diff --git a/Validate_Binary_Search_Tree.cpp b/Validate_Binary_Search_Tree.cpp new file mode 100644 index 0000000..d2d46cb --- /dev/null +++ b/Validate_Binary_Search_Tree.cpp @@ -0,0 +1,82 @@ +/*98. Validate Binary Search Tree QuestionEditorial Solution My Submissions +Total Accepted: 107794 +Total Submissions: 500597 +Difficulty: Medium +Given a binary tree, determine if it is a valid binary search tree (BST). + +Assume a BST is defined as follows: + +The left subtree of a node contains only nodes with keys less than the node's key. +The right subtree of a node contains only nodes with keys greater than the node's key. +Both the left and right subtrees must also be binary search trees. +Example 1: + 2 + / \ + 1 3 +Binary tree [2,1,3], return true. +Example 2: + 1 + / \ + 2 3 +Binary tree [1,2,3], return false.*/ + + + +/*Set the min_value and max_value +the left child should always less than the root.val +the right child should always larger than the root.val +update the min_value and max_value after each recursive +when check the left child, we set the max value as root.val +when check the right child, we set the min value as root.val*/ + +///////////////////////////////////////////////////////////////////////////////////// +//C++ +/** + * Definition for a binary tree node. + * struct TreeNode { + * int val; + * TreeNode *left; + * TreeNode *right; + * TreeNode(int x) : val(x), left(NULL), right(NULL) {} + * }; + */ +class Solution { +public: + bool isValidBST(TreeNode* root) { + return isValid(root, LONG_MIN, LONG_MAX); + } + + bool isValid(TreeNode* root, long min, long max){ // should be "long" + if(!root) return true; + if(root->val>=max || root->val<=min) return false; + // cout << root->val; + return isValid(root->left, min, root->val) && isValid(root->right, root->val, max); + } +}; + + + + + +///////////////////////////////////////////////////////////////////////////////////// +//Java +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode(int x) { val = x; } + * } + */ +public class Solution { + public boolean isValidBST(TreeNode root) { + return isValid(root, Long.MIN_VALUE, Long.MAX_VALUE); + } + + public boolean isValid(TreeNode root, long min, long max){ + if(root==null) return true; + if(root.val>=max || root.val<=min) return false; + return isValid(root.left, min, root.val) && isValid(root.right, root.val, max); + } +} \ No newline at end of file diff --git a/Walls_and_Gates.cpp b/Walls_and_Gates.cpp new file mode 100644 index 0000000..2439a1a --- /dev/null +++ b/Walls_and_Gates.cpp @@ -0,0 +1,106 @@ +/*286. Walls and Gates QuestionEditorial Solution My Submissions +Total Accepted: 16681 Total Submissions: 41393 Difficulty: Medium +You are given a m x n 2D grid initialized with these three possible values. + +-1 - A wall or an obstacle. +0 - A gate. +INF - Infinity means an empty room. We use the value 231 - 1 = 2147483647 to represent INF as you may assume that the distance to a gate is less than 2147483647. +Fill each empty room with the distance to its nearest gate. If it is impossible to reach a gate, it should be filled with INF. + +For example, given the 2D grid: +INF -1 0 INF +INF INF INF -1 +INF -1 INF -1 + 0 -1 INF INF +After running your function, the 2D grid should be: + 3 -1 0 1 + 2 2 1 -1 + 1 -1 2 -1 + 0 -1 3 4 +Hide Company Tags Google Facebook +Hide Tags Breadth-first Search +Hide Similar Problems (M) Surrounded Regions (M) Number of Islands (H) Shortest Distance from All Buildings +*/ + + + +/* BFS O(mn) time +push all gates into queue first, +for each gate, update its neighbor cells, and push them to queue +*/ + +///////////////////////////////////////////////////////////////////////////////////// +//C++ +class Solution { +public: + void wallsAndGates(vector>& rooms) { + if(rooms.size()==0 || rooms[0].size()==0) return; + queue> myqueue; + int row = rooms.size(); + int col = rooms[0].size(); + //find all 0 gates + for(int i = 0; i < row; ++i){ + for(int j = 0; j < col; ++j){ + if(rooms[i][j] == 0){ + myqueue.emplace(i,j); + } + } + } + + //set four directions + vector> dirs = {{-1,0},{1,0},{0,1},{0,-1}}; + while(!myqueue.empty()){ + int first = myqueue.front().first; + int second = myqueue.front().second; + myqueue.pop(); + for(auto d:dirs){ + int x = first+d.first; + int y = second + d.second; + // if x y out of range or it is obstasle, or has small distance aready + if(x<0 || x>=row || y<0 || y>=col + || rooms[x][y]<=rooms[first][second]) continue; + + rooms[x][y] = rooms[first][second] + 1; + myqueue.emplace(x,y); + } + } + } +}; + + + + +///////////////////////////////////////////////////////////////////////////////////// +//Java +public class Solution { + public void wallsAndGates(int[][] rooms) { + if(rooms.length==0 || rooms[0].length==0) return; + Queue myqueue = new LinkedList<>(); + int row = rooms.length; + int col = rooms[0].length; + //find all 0 gates + for(int i = 0; i < row; ++i){ + for(int j = 0; j < col; ++j){ + if(rooms[i][j] == 0){ + myqueue.add(new int[]{i,j}); + } + } + } + + //set four directions + int[][] dirs = new int[][]{{-1,0},{1,0},{0,1},{0,-1}}; + while(!myqueue.isEmpty()){ + int[] q = myqueue.remove(); + for(int[] d:dirs){ + int x = q[0] + d[0]; + int y = q[1] + d[1]; + // if x y out of range or it is obstasle, or has small distance aready + if(x<0 || x>= row || y<0 || y>= col + || rooms[x][y]<=rooms[q[0]][q[1]]) continue; + + rooms[x][y] = rooms[q[0]][q[1]] + 1; + myqueue.add(new int[]{x,y}); + } + } + } +} diff --git a/Welcome_to_java.cpp b/Welcome_to_java.cpp new file mode 100644 index 0000000..5e1d569 --- /dev/null +++ b/Welcome_to_java.cpp @@ -0,0 +1,10 @@ +public class Solution { + + public static void main(String []argv) + { + //Write your solution here. + System.out.println("Hello World."); + System.out.println("Hello Java."); + } + +} \ No newline at end of file diff --git a/Wiggle_Sort.cpp b/Wiggle_Sort.cpp new file mode 100644 index 0000000..749daa1 --- /dev/null +++ b/Wiggle_Sort.cpp @@ -0,0 +1,73 @@ +/*280. Wiggle Sort QuestionEditorial Solution My Submissions +Total Accepted: 16869 Total Submissions: 31864 Difficulty: Medium +Given an unsorted array nums, reorder it in-place such that nums[0] <= nums[1] >= nums[2] <= nums[3].... + +For example, given nums = [3, 5, 2, 1, 6, 4], one possible answer is [1, 6, 2, 5, 3, 4]. + +Hide Company Tags Google +Hide Tags Array Sort +Hide Similar Problems (M) Sort Colors (M) Wiggle Sort II +*/ + + + +/*O(n) time +we do it in-place +the nums should satisfy 2 conditions +1. i is odd, nums[i] >= nums[i-1] +2. i is even, nums[i] <= nums[i-1] +just to fix the ordering of nums that not satisfy these 2 conditions +*/ +///////////////////////////////////////////////////////////////////////////////////// +//C++ +class Solution { +public: + void wiggleSort(vector& nums) { + if(nums.size() < 1) return; + for(int i = 1; i < nums.size(); ++i){ + //i&1==1 i is odd + //i&1==0 i is even + if(((i&1) && nums[i] < nums[i-1]) + || (!(i&1) && nums[i] > nums[i-1])){ + swap(nums[i], nums[i-1]); + } + //if can replace by if(i%2 == (nums[i-1]>nums[i])) + } + //another for: + /*for(int i = 1; i < nums.size(); ++i){ + swap(nums[i], nums[i-(i%2 ^ (nums[i-1] nums[i-1]){ + swap(nums, i); + } + } else if (i%2 == 1){ + //i is odd + if(nums[i] < nums[i-1]){ + swap(nums, i); + } + } + } + } + + //swap i with i-1 + //pass array into function + public void swap(int[] nums, int i){ + int temp = nums[i]; + nums[i] = nums[i-1]; + nums[i-1] = temp; + } +} diff --git a/Wiggle_Sort_2.cpp b/Wiggle_Sort_2.cpp new file mode 100644 index 0000000..b54567c --- /dev/null +++ b/Wiggle_Sort_2.cpp @@ -0,0 +1,72 @@ +/*324. Wiggle Sort II QuestionEditorial Solution My Submissions +Total Accepted: 16345 +Total Submissions: 67725 +Difficulty: Medium +Given an unsorted array nums, reorder it such that nums[0] < nums[1] > nums[2] < nums[3].... + +Example: +(1) Given nums = [1, 5, 1, 1, 6, 4], one possible answer is [1, 4, 1, 5, 1, 6]. +(2) Given nums = [1, 3, 2, 2, 3, 1], one possible answer is [2, 3, 1, 3, 1, 2]. + +Note: +You may assume all input has valid answer. + +Follow Up: +Can you do it in O(n) time and/or in-place with O(1) extra space? + +Credits: +Special thanks to @dietpepsi for adding this problem and creating all test cases. + +Hide Company Tags Google +Hide Tags Sort +Hide Similar Problems (M) Sort Colors (M) Kth Largest Element in an Array (M) Wiggle Sort +*/ + + + +/* O(n) time and/or in-place with O(1) extra space +the number on the even indexes are larger than the odd indexes +1. sort the array, from small to high +2. the first half of array insert into the odd index +the last haf of array insert into the even index +use & AND operator to see this position is odd index or even index +from the back of string to change +eg: +Small half: 4 . 3 . 2 . 1 . 0 . +Large half: . 9 . 8 . 7 . 6 . 5 +---------------------------------- +Together: 4 9 3 8 2 7 1 6 0 5*/ + +///////////////////////////////////////////////////////////////////////////////////// +//C++ +class Solution { +public: + void wiggleSort(vector& nums) { + vector temp(nums); + sort(temp.begin(), temp.end()); + for(int i = nums.size()-1, j = 0, k = i/2+1; i>=0; i--){ + nums[i] = temp[i&1 ? k++: j++]; + } + } +}; + + + + +///////////////////////////////////////////////////////////////////////////////////// +//Java +public class Solution { + public void wiggleSort(int[] nums) { + int[] temp = new int[nums.length]; + for(int i = 0 ; i < nums.length; ++i){ + temp[i] = nums[i]; + } + //int[] temp = nums.clone(); //copy nums to temp --- way 1 + //int[] temp = Arrays.copyOf(nums, nums.length); //copy nums to temp --- way 2 + Arrays.sort(temp); + + for(int i = nums.length-1, j = 0, k = i/2+1; i>=0; --i){ + nums[i] = temp[(i&1)!=0 ? k++: j++]; + } + } +} diff --git a/Wiggle_Subsequence.cpp b/Wiggle_Subsequence.cpp new file mode 100644 index 0000000..28460cf --- /dev/null +++ b/Wiggle_Subsequence.cpp @@ -0,0 +1,111 @@ +/*376. Wiggle Subsequence QuestionEditorial Solution My Submissions +Total Accepted: 10129 Total Submissions: 29550 Difficulty: Medium +A sequence of numbers is called a wiggle sequence if the differences between successive numbers strictly alternate between positive and negative. The first difference (if one exists) may be either positive or negative. A sequence with fewer than two elements is trivially a wiggle sequence. + +For example, [1,7,4,9,2,5] is a wiggle sequence because the differences (6,-3,5,-7,3) are alternately positive and negative. In contrast, [1,4,7,2,5] and [1,7,4,5,5] are not wiggle sequences, the first because its first two differences are positive and the second because its last difference is zero. + +Given a sequence of integers, return the length of the longest subsequence that is a wiggle sequence. A subsequence is obtained by deleting some number of elements (eventually, also zero) from the original sequence, leaving the remaining elements in their original order. + +Examples: +Input: [1,7,4,9,2,5] +Output: 6 +The entire sequence is a wiggle sequence. + +Input: [1,17,5,10,13,15,10,5,16,8] +Output: 7 +There are several subsequences that achieve this length. One is [1,17,10,13,10,16,8]. + +Input: [1,2,3,4,5,6,7,8,9] +Output: 2 +Follow up: +Can you do it in O(n) time? + +Credits: +Special thanks to @agave and @StefanPochmann for adding this problem and creating all test cases. + +Subscribe to see which companies asked this question*/ + + + +/* +mark a variable larger to check if the next element should larger than current element +1,7,8,4,5,2 +1, larger mark: true, 7 list:1,7 +7, larger mark: false, 8 list: 1,8 change the list +8, larger mark: false, 4 list:1,8,4 +to each element, check if this element is satisfy larger mark, if it is, push into the list +else, update the last element in the list +we can directly update the original nums array*/ + +///////////////////////////////////////////////////////////////////////////////////// +//C++ +class Solution { +public: + int wiggleMaxLength(vector& nums) { + if(nums.size()==0 || nums.size()==1) return nums.size(); + + int k = 1; + while(knums[k-1]; + for(int i = k+1; i < nums.size(); ++i){ + if(larger && nums[i]nums[i-1]){ + nums[ret] = nums[i]; + ret++; + larger = !larger; + } else { + nums[ret-1] = nums[i]; + } + } + + return ret; + } +}; + + + + +///////////////////////////////////////////////////////////////////////////////////// +//Java +public class Solution { + public int wiggleMaxLength(int[] nums) { + if(nums.length==0 || nums.length==1) return nums.length; + + int k = 1;//check if the first element is equal to the next one + while(knums[k-1]; + for(int i = k+1; i < nums.length; ++i){ + if(larger && nums[i]nums[i-1]){ + nums[ret] = nums[i]; + ret++; + larger = !larger; + } else { + nums[ret-1] = nums[i]; + } + } + + // for(int i = 0; i < ret; ++i){ + // System.out.print(nums[i] + " "); + // } + + return ret; + } +} diff --git a/Wildcard_Matching.cpp b/Wildcard_Matching.cpp new file mode 100644 index 0000000..af068a0 --- /dev/null +++ b/Wildcard_Matching.cpp @@ -0,0 +1,163 @@ +/*44. Wildcard Matching QuestionEditorial Solution My Submissions +Total Accepted: 71003 Total Submissions: 383621 Difficulty: Hard +Implement wildcard pattern matching with support for '?' and '*'. + +'?' Matches any single character. +'*' Matches any sequence of characters (including the empty sequence). + +The matching should cover the entire input string (not partial). + +The function prototype should be: +bool isMatch(const char *s, const char *p) + +Some examples: +isMatch("aa","a") → false +isMatch("aa","aa") → true +isMatch("aaa","aa") → false +isMatch("aa", "*") → true +isMatch("aa", "a*") → true +isMatch("ab", "?*") → true +isMatch("aab", "c*a*b") → false +Hide Company Tags Google Snapchat Facebook +Hide Tags Dynamic Programming Backtracking Greedy String +Hide Similar Problems (H) Regular Expression Matching +*/ + + + +/*linear time constant space +use two index, i1 for str, i2 for pattern +index for * +match for * at s postion +start checking string + if p[i2]=='?' or s[i1]==p[i2], increase i1, i2 + else if p[i2]=='*', mark this position as index, match=i1 + else if index!=-1, means exist *, i2=index+1, match++, i1=match + else return false, character does not match +start checking remaing char in pattern + while (p < pattern.length() && pattern.charAt(p) == '*') p++; +return p == pattern.length(); + */ + +///////////////////////////////////////////////////////////////////////////////////// +//C++ +class Solution { +public: + bool isMatch(string s, string p) { + int i1 = 0; //point to s + int i2 = 0; //point to p + int match = 0; + int index = -1; + while(i1 < s.size()){ + if(i2& wordDict) { + vector ret(s.size()+1,false); + ret[0]=true; + for(int i = 1; i <= s.size(); ++i){//start from 1 to the end of string + for(int j = 0; j < i; ++j){ + if(ret[j] && wordDict.find(s.substr(j,i-j))!=wordDict.end()){ + // cout << i << " " << j << endl; + ret[i] = true; + break; + } + } + } + return ret[s.size()]; + } +}; + + + + +///////////////////////////////////////////////////////////////////////////////////// +//Java +public class Solution { + public boolean wordBreak(String s, Set wordDict) { + boolean[] ret = new boolean[s.length()+1]; //initialize s.length + ret[0] = true; + for(int i = 1; i <= s.length(); ++i){//start from 1 to the end of string + for(int j = 0; j < i; ++j){ + if(ret[j] && wordDict.contains(s.substring(j,i))){ + ret[i] = true; + break; + } + } + } + return ret[s.length()]; + } +} diff --git a/Word_Break_2.cpp b/Word_Break_2.cpp new file mode 100644 index 0000000..b8f7ff9 --- /dev/null +++ b/Word_Break_2.cpp @@ -0,0 +1,92 @@ +/*140. Word Break II QuestionEditorial Solution My Submissions +Total Accepted: 68499 Total Submissions: 321317 Difficulty: Hard +Given a string s and a dictionary of words dict, add spaces in s to construct a sentence where each word is a valid dictionary word. + +Return all such possible sentences. + +For example, given +s = "catsanddog", +dict = ["cat", "cats", "and", "sand", "dog"]. + +A solution is ["cats and dog", "cat sand dog"]. + +Hide Company Tags Dropbox Google Uber Snapchat Twitter +Hide Tags Dynamic Programming Backtracking +*/ + + + +/* O(len(wordDict) ^ len(s / minWordLenInDict)), because there're len(wordDict) possibilities for each cut +use a hashmap to store the previous results, to avoid duplicates +for each word in wordDict, find its own list, and add it to ret +*/ + +///////////////////////////////////////////////////////////////////////////////////// +//C++ +class Solution { + private: + unordered_map> mymap; + +public: + vector wordBreak(string s, unordered_set& wordDict) { + if(mymap.count(s)) return mymap[s]; + + vector ret; + if(wordDict.count(s)){ + ret.push_back(s); + } + + for(int i = 1; i < s.size(); ++i){ + //backtracking + string word = s.substr(i); + if(wordDict.count(word)){ + string rem = s.substr(0, i); + vector pre = combine(word, wordBreak(rem, wordDict)); + ret.insert(ret.end(), pre.begin(), pre.end()); + } + } + + mymap[s] = ret; + return ret; + } + + vector combine(string word, vector pre){ + for(int i = 0; i < pre.size(); ++i){ + pre[i] += " " + word; + } + return pre; + } +}; + + + + +///////////////////////////////////////////////////////////////////////////////////// +//Java +public class Solution { + HashMap> mymap = new HashMap<>(); + //store previous results, remember init it + + public List wordBreak(String s, Set wordDict) { + if(mymap.containsKey(s)) + return mymap.get(s); + + List ret = new LinkedList<>(); + if(s.length()==0){ + ret.add(""); + return ret; + } + + for(String w:wordDict){ + if(s.startsWith(w)){ // s is a string start with w + List sublist = wordBreak(s.substring(w.length()), wordDict); + for(String sub:sublist){ + ret.add(w + (sub.isEmpty()?"":" ") + sub); + } + } + } + + mymap.put(s, ret); + return ret; + } +} diff --git a/Word_Ladder_2.cpp b/Word_Ladder_2.cpp new file mode 100644 index 0000000..914191e --- /dev/null +++ b/Word_Ladder_2.cpp @@ -0,0 +1,291 @@ +/*126. Word Ladder II QuestionEditorial Solution My Submissions +Total Accepted: 49838 +Total Submissions: 362598 +Difficulty: Hard +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 intermediate word must exist in the word list +For example, + +Given: +beginWord = "hit" +endWord = "cog" +wordList = ["hot","dot","dog","lot","log"] +Return + [ + ["hit","hot","dot","dog","cog"], + ["hit","hot","lot","log","cog"] + ] +Note: +All words have the same length. +All words contain only lowercase alphabetic characters. +Subscribe to see which companies asked this question*/ + + + +/*Treat each word as a node of a tree. There are two trees. One tree's root node is "beginWord", and the other tree's root node is "endWord". + +The root node can yield all his children node, and they are the second layer of the tree. The second layer can yield all their children, then we get the third layer of the tree, ... , and so on. + +When one tree yield a new child, we search it in the last layer of the other tree. If we find an identical node in that tree, then we get some ladders connect two roots("beginWord" -> ... -> "endWord"). + +Another thing should be considered is: two(or more) different nodes may yield an identical child. That means the child may have two(or more) parents. For example, "hit" and "hot" can both yield "hat", means "hat" has two parents. + +So, the data struct of tree-node is: + +class Node { +public: + string word; + vectror parents; + Node(string w) : word(w) {} +} +Note: we don't need a children field for Node class, because we won't use it. + +Two nodes are considered equal when their word field are equal. So we introduce an compare function: + +bool nodecmp(Node* pa, Node* pb) +{ + return pa->word < pb->word; +} +Then we use nodecmp as the compare function to build a node set. + +typedef bool (*NodeCmper) (Node*, Node*); +typedef set NodeSet; +NodeSet layer(nodecmp); +Then we can store/search pointers of nodes in node set layer. For example: + +Node node1("hit"), node2("hot"), node3("hat"); +layer.insert(&node1); +layer.insert(&node2); +layer.insert(&node3); +auto itr = layer.find(new Node("hot")); +cout << (*itr)->word; // output: hot +Using these data structures, we can solve this problem with bi-direction BFS algorithm. Below is the AC code, and it is very very fast.*/ + +///////////////////////////////////////////////////////////////////////////////////// +//C++ + class Node; + + typedef vector Ladder; + typedef unordered_set StringSet; + typedef bool (*NodeCmper) (Node*, Node*); + typedef set NodeSet; + + class Node{ + public: + string word; + vector parents; + Node(string w): word(w) {} + + void addparent(Node* parent){ + parents.push_back(parent); + } + + void yieldChildren(NodeSet& nextlayer, StringSet& wordlist, NodeSet& targetlayer, + vector& ladders, bool forward){ + //if the child is found in $targetlayer, which means we found ladders that connect + // BEGIN-WORD and END-WORD, then we get all paths through this node to its ROOT node + // and all paths through the target child node to its ROOT node, and combine the two + // group of paths to a group of ladders, and append these ladders to $ladders + //else if the $ladders is empty, + // if the child is found in $nextlayer, then get that child, and add this node to its parents + // else, add the child to nextlayer, and add this node to its parents + //else, do nothing + string nextword = word; + for(int i = 0, n = nextword.length(); i < n; i++){ + char oldchar = nextword[i]; + for(nextword[i] = 'a'; nextword[i] <= 'z'; nextword[i]++){ + if(wordlist.count(nextword)){ //found a valid child-word, yield this child + //unordered_set---count---count elements with a specific key + Node *child = new Node(nextword); + yield(child, nextlayer, targetlayer, ladders, forward); + } + } + nextword[i] = oldchar; + } + } + + //yield one child + void yield(Node* child, NodeSet& nextlayer, NodeSet& targetlayer, + vector& ladders, bool forward){ + auto it = targetlayer.find(child); + if(it != targetlayer.end()){ + for(Ladder p1: this->getpaths()){ + for(Ladder p2: (*it)->getpaths()){ + if(forward){ + ladders.push_back(p1); + ladders.back().insert(ladders.back().end(), p2.rbegin(), p2.rend()); + } else { + ladders.push_back(p2); + ladders.back().insert(ladders.back().end(), p1.rbegin(), p1.rend()); + } + } + } + } else if(ladders.empty()){ + auto it = nextlayer.find(child); + if(it != nextlayer.end()){ + (*it)->addparent(this); + } else { + child->addparent(this); + nextlayer.insert(child); + } + } + } + + vector getpaths(){ + vector ladders; + if(parents.empty()){ + ladders.push_back(Ladder(1,word)); + } else { + for(Node *p: parents){ + for(Ladder lad : p->getpaths()){ + ladders.push_back(lad); + ladders.back().push_back(word); + } + } + } + return ladders; + } + }; + + bool nodecmp(Node* na, Node* nb){ + return na->word < nb->word; + } + +class Solution { +public: + vector> findLadders(string beginWord, string endWord, unordered_set &wordList) { + vector ladders; + Node headroot(beginWord), tailroot(endWord); + NodeSet frontlayer(nodecmp), backlayer(nodecmp); + NodeSet *p_layerA = &frontlayer, *p_layerB = &backlayer; + bool forward = true; + + if(beginWord == endWord){ + ladders.push_back(Ladder(1,beginWord)); + return ladders; + } + + frontlayer.insert(&headroot); + backlayer.insert(&tailroot); + wordList.insert(endWord); + while(!p_layerA->empty() && !p_layerB->empty() && ladders.empty()){ + NodeSet nextlayer(nodecmp); + if(p_layerA->size() > p_layerB->size()){ + swap(p_layerA, p_layerB); + forward = !forward; + } + + for(Node* node : *p_layerA){ + wordList.erase(node->word); + } + + for(Node *node : *p_layerA){ + node->yieldChildren(nextlayer, wordList, *p_layerB, ladders, forward); + } + + swap(*p_layerA, nextlayer); + } + + return ladders; + } +}; + + + + + + +/*The solution contains two steps 1 Use BFS to construct a graph. 2. Use DFS to construct the paths from end to start.Both solutions got AC within 1s. + +The first step BFS is quite important. I summarized three tricks + +Using a MAP to store the min ladder of each word, or use a SET to store the words visited in current ladder, when the current ladder was completed, delete the visited words from unvisited. That's why I have two similar solutions. +Use Character iteration to find all possible paths. Do not compare one word to all the other words and check if they only differ by one character. +One word is allowed to be inserted into the queue only ONCE.*/ + +///////////////////////////////////////////////////////////////////////////////////// +//Java +public class Solution { + private Map > mymap; + private List > ret; + + public List> findLadders(String beginWord, String endWord, Set wordList) { + ret = new ArrayList>(); + if(wordList.size() == 0){ + return ret; + } + + int min = Integer.MAX_VALUE; + + Queue q = new ArrayDeque(); + q.add(beginWord); + + mymap = new HashMap>(); + + Map ladder = new HashMap(); + for(String w:wordList){ + ladder.put(w, Integer.MAX_VALUE); + } + ladder.put(beginWord, 0); + + wordList.add(endWord); + while(!q.isEmpty()){//BFS:Dijisktra search + String word = q.poll(); + int step = ladder.get(word) + 1;//step indicates how many steps are needed to travel to one word + if(step>min) break; + + for(int i = 0; i < word.length(); i++){ + StringBuilder sb = new StringBuilder(word); + for(char ch = 'a'; ch <= 'z'; ch++){ + sb.setCharAt(i, ch); + String newWord = sb.toString(); + if(ladder.containsKey(newWord)){ + if(step>ladder.get(newWord)){ + continue; + } else if(step newList = new LinkedList(); + newList.add(word); + mymap.put(newWord, newList); + //mymap.put(newWord, new LinkedList(Arrays.asList(new String[]{word}))); + } + + if(newWord.equals(endWord)){ + min = step; + } + }// end if wordList contains newWord + }//end if iteration from 'a' to 'z' + }//end if iteration from the first to the last + } + + LinkedList res = new LinkedList(); + backTrace(endWord, beginWord, res); + + return ret; + } + + private void backTrace(String word, String start, List list){ + if(word.equals(start)){ + list.add(0,start); + ret.add(new ArrayList(list)); + list.remove(0); + return; + } + list.add(0, word); + if(mymap.get(word) != null){ + for(String s:mymap.get(word)){ + backTrace(s, start, list); + } + } + list.remove(0); + } +} \ No newline at end of file diff --git a/Word_Pattern.cpp b/Word_Pattern.cpp new file mode 100644 index 0000000..60dcc8c --- /dev/null +++ b/Word_Pattern.cpp @@ -0,0 +1,80 @@ +bool wordPattern(string pattern, string str) { + int *a = new int[26](); + unordered_map m; + + int patternIdx = 0, startIndex = 0; + + if (str.length() && str[str.length() - 1] != ' ') { + str += ' '; + } //find if the end of the string str is ' ' + + for (int i = 0; i < str.length(); ++i) { + if (patternIdx == pattern.length()) { + return false; + } + + if (str[i] == ' ') { + string sub = str.substr(startIndex, i - startIndex); + startIndex = ++i; //need to change the position + + int aIdx = pattern[patternIdx] - 97; + if (m.find(sub) == m.end()) { //find if there has been a bijection between pattern and str + if (!a[aIdx]) { + m[sub] = pattern[patternIdx]; + a[aIdx] = 1; + } else { + return false; + } + } else if (m[sub] != pattern[patternIdx]){ + return false; + } + patternIdx++; + } + } + return patternIdx == pattern.length(); +} + + + + +class Solution { +public: + bool wordPattern(string pattern, string str) { + vector apattern(26,0); + unordered_map sMap; + int spos = 0; + int aIdx1 = 0; + + if(str.length() && str[str.length()-1] != ' ') + str += ' '; + + for(int i = 0; i < str.length(); ++i) + { + if(aIdx1 == pattern.length()) + return false; + + if(str[i] == ' ') + { + string nstr = str.substr(spos, i - spos); + spos = ++i; + + int aIdx = pattern[aIdx1] - 97; + if(sMap.find(nstr) == sMap.end()) + { + if(!apattern[aIdx]) + { + sMap[nstr] = pattern[aIdx1]; + apattern[aIdx] = 1; + } + else + return false; + } + else if(sMap[nstr] != pattern[aIdx1]) + return false; + + aIdx1++; + } + } + return (aIdx1 == pattern.length()); + } +}; \ No newline at end of file diff --git a/Word_Search_2.cpp b/Word_Search_2.cpp new file mode 100644 index 0000000..3af338a --- /dev/null +++ b/Word_Search_2.cpp @@ -0,0 +1,186 @@ +/* +212. Word Search II QuestionEditorial Solution My Submissions +Total Accepted: 24287 +Total Submissions: 118222 +Difficulty: Hard +Given a 2D board and a list of words from the dictionary, find all words in the board. + +Each word must be constructed from letters of sequentially adjacent cell, where "adjacent" cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once in a word. + +For example, +Given words = ["oath","pea","eat","rain"] and board = + +[ + ['o','a','a','n'], + ['e','t','a','e'], + ['i','h','k','r'], + ['i','f','l','v'] +] +Return ["eat","oath"]. +Note: +You may assume that all inputs are consist of lowercase letters a-z. + +click to show hint. + +You would need to optimize your backtracking to pass the larger test. Could you stop backtracking earlier? + +If the current candidate does not exist in all words' prefix, you could stop backtracking immediately. What kind of data structure could answer such query efficiently? Does a hash table work? Why or why not? How about a Trie? If you would like to learn how to implement a basic trie, please work on this problem: Implement Trie (Prefix Tree) first. + +Hide Company Tags Microsoft Google Airbnb +Hide Tags Backtracking Trie +Hide Similar Problems (M) Word Search +*/ + + + + +/*use trie +dfs(board, i, j, TrieNode p, List ret) --- + i,j is the board position which we search start + ret is the list we need to return at the end +TrieNode --- next[], word(the end char of wordsTrie, store the words itself) +buildTrie(String[] string) --- + build the word trie according to given string array of words +findWords --- build the word trie \ + DFS searching the board +*/ + +//C++ +///////////////////////////////////////////////////////////////////////////////////////////////class Solution { + class TrieNode{ + public: + vector next; + string word; + TrieNode(){ + this->next = vector(26, nullptr); + this->word = ""; + } + }; + + public: + TrieNode* buildTrie(vector &words){ + TrieNode *root = new TrieNode(); + for(string w:words){ + TrieNode *p = root; + for(int i = 0; i < w.size(); i++){ + int c = w[i]-'a'; + if(p->next[c]==nullptr){ + p->next[c] = new TrieNode(); + } + p = p->next[c]; + } + p->word = w; + } + return root; + } + + public: + void dfs(vector > &board, int i, int j, TrieNode *p, vector &ret){ + char c = board[i][j]; + if(c=='#' || p->next[c-'a']==nullptr){ + return; + } + + p = p->next[c-'a']; + if(p->word != ""){ + ret.push_back(p->word); + p->word = ""; + } + + board[i][j] = '#'; + if(i > 0) + dfs(board, i-1, j, p, ret); + if(j > 0) + dfs(board, i, j-1, p, ret); + if(i < board.size()-1) + dfs(board, i+1, j, p, ret); + if(j < board[0].size()-1) + dfs(board, i, j+1, p, ret); + + board[i][j] = c; + } + +public: + vector findWords(vector>& board, vector& words) { + vector ret; + TrieNode *root = buildTrie(words); + + for(int i = 0; i < board.size(); i++){ + for(int j = 0; j < board[0].size(); j++){ + dfs(board, i, j, root, ret); + } + } + return ret; + } +}; + + + + + + + + +//java +//////////////////////////////////////////////////////////////////////////////////////////////// +public class Solution { + class TrieNode{ + TrieNode[] next = new TrieNode[26]; + String word; + } + + public TrieNode buildTrie(String[] words){ + TrieNode root = new TrieNode(); + for(String w:words){ + TrieNode p = root; + for(char c:w.toCharArray()){ + int i = c-'a'; + if(p.next[i] == null){ + p.next[i] = new TrieNode(); + } + p = p.next[i]; + } + p.word = w; + } + + return root; + } + + public void dfs(char[][] board, int i, int j, TrieNode p, List ret){ + char c = board[i][j]; + if(c=='#' || p.next[c-'a']==null) // this cell has already been searched + return; + + p = p.next[c-'a']; + if(p.word!=null){ + //once find a word, add it into list, and change it to null to avoid count it again + ret.add(p.word); + p.word = null; + } + + board[i][j] = '#'; //mark this cell has already been searched + if(i > 0) + dfs(board, i-1, j, p, ret); + if(j > 0) + dfs(board, i, j-1, p, ret); + if(i < board.length - 1) + dfs(board, i+1, j, p, ret); + if(j < board[0].length - 1) + dfs(board, i, j+1, p, ret); + + board[i][j] = c; //recover this node + } + + public List findWords(char[][] board, String[] words) { + List ret = new ArrayList<>(); + if(board.length==0 || board[0].length==0) return ret; + TrieNode root = buildTrie(words); + + for(int i = 0; i < board.length; i++){ + for(int j = 0; j < board[0].length; j++){ + dfs(board, i, j, root, ret); + } + } + return ret; + } +} \ No newline at end of file diff --git a/ZigZag_Iterator.cpp b/ZigZag_Iterator.cpp new file mode 100644 index 0000000..bdb278f --- /dev/null +++ b/ZigZag_Iterator.cpp @@ -0,0 +1,105 @@ +/*281. Zigzag Iterator QuestionEditorial Solution My Submissions +Total Accepted: 15095 Total Submissions: 32722 Difficulty: Medium +Given two 1d vectors, implement an iterator to return their elements alternately. + +For example, given two 1d vectors: + +v1 = [1, 2] +v2 = [3, 4, 5, 6] +By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1, 3, 2, 4, 5, 6]. + +Follow up: What if you are given k 1d vectors? How well can your code be extended to such cases? + +Clarification for the follow up question - Update (2015-09-18): +The "Zigzag" order is not clearly defined and is ambiguous for k > 2 cases. If "Zigzag" does not look right to you, replace "Zigzag" with "Cyclic". For example, given the following input: + +[1,2,3] +[4,5,6,7] +[8,9] +It should return [1,4,8,2,5,9,3,6,7]. +Hide Company Tags Google +Hide Tags Design +Hide Similar Problems (M) Binary Search Tree Iterator (M) Flatten 2D Vector (M) Peeking Iterator (M) Flatten Nested List Iterator +*/ + + + +/*c++ --- use queue to store the iterator of v1 and v2 or k vector's iterator +java --- use linkedlist to store the iterator of v1 and v2 or k vector's iterator +next() --- remove the first iterator, after poll it, if ther is element in it, add it into the back of list +hasNext() --- check if the list of iterator is empty +*/ + +///////////////////////////////////////////////////////////////////////////////////// +//C++ +class ZigzagIterator { + private: + queue::iterator, vector::iterator>> mylist; + +public: + ZigzagIterator(vector& v1, vector& v2) { + if(v1.size()!=0){ + mylist.push(make_pair(v1.begin(), v1.end()));//make pair + } + if(v2.size()!=0){ + mylist.push(make_pair(v2.begin(), v2.end())); + } + } + + int next() { + vector::iterator it = mylist.front().first; + vector::iterator itend = mylist.front().second; + mylist.pop(); + if(it+1!=itend){ + mylist.push(make_pair(it+1,itend)); + } + return *it; + } + + bool hasNext() { + return !mylist.empty(); + } +}; + +/** + * Your ZigzagIterator object will be instantiated and called as such: + * ZigzagIterator i(v1, v2); + * while (i.hasNext()) cout << i.next(); + */ + + + + +///////////////////////////////////////////////////////////////////////////////////// +//Java +public class ZigzagIterator { + private LinkedList mylist = new LinkedList<>(); //initialize LinkedList, otherwise cannot use poll() function + + public ZigzagIterator(List v1, List v2) { + if(!v1.isEmpty()){ + mylist.add(v1.iterator()); + } + if(!v2.isEmpty()){ + mylist.add(v2.iterator()); + } + } + + public int next() { + Iterator it = mylist.poll(); + int ret = (Integer)it.next(); //first transfer it into int + if(it.hasNext()){ + mylist.add(it); + } + return ret; + } + + public boolean hasNext() { + return !mylist.isEmpty(); + } +} + +/** + * Your ZigzagIterator object will be instantiated and called as such: + * ZigzagIterator i = new ZigzagIterator(v1, v2); + * while (i.hasNext()) v[f()] = i.next(); + */ diff --git a/Zigzag_Conversion.cpp b/Zigzag_Conversion.cpp new file mode 100644 index 0000000..53e0367 --- /dev/null +++ b/Zigzag_Conversion.cpp @@ -0,0 +1,58 @@ +/* +The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility) + +P A H N +A P L S I I G +Y I R +And then read line by line: "PAHNAPLSIIGYIR" +Write the code that will take a string and make this conversion given a number of rows: + +string convert(string text, int nRows); +convert("PAYPALISHIRING", 3) should return "PAHNAPLSIIGYIR". +*/ + +class Solution { +public: + string convert(string s, int numRows) { + if(numRows<=1) return s; //if there is only one line, it is no need to change the string + + int sCircle = 2 * numRows - 2; //count the number of elements in one circle + string sRes = ""; + for(int i = 0; i < numRows; ++i){ //let i control the rows + for(int j = i; j < s.size(); j += sCircle){ + sRes += s[j]; + int secondS = (j-i) + sCircle-i; + if(i!=0 && i!=numRows-1 && secondS bear != 'koala'); +// let bears = ['polar','koala'].filter((bear) => { +// return bear != 'koala'; +// }); +// console.log(bears); //['polar'] + +// class Bear{ +// constructor(){ +// this.type = 'bear'; +// } +// says(say){ +// setTimeout(()=>{ +// console.log(this.type + 'says' + say); +// }.bind(this),1000) +// } +// } +// var bear = new Bear(); +// bear.says(); //bear says undefined + +// var bears = [ +// 'grizzly', +// 'polar', +// ].join('\n') // grizzly +// console.log(bears) // polar + +// let bears = ' +// grizzly +// polar +// ' +// console.log(bears) + +// let bears = 'grizzly'; +// let says = 'growl'; +// console.log('The ${bear} says ${says'); //The grizzly says growl + +// let bear = 'grizzly'; +// let says = 'growl'; +// let zoo = {bear, says} +// console.log(zoo); //Object {bear:"grizzly", says:"growl"} + +// let grizzly = {type:'grizzly', many:2}; +// let{type, many} = grizzly; +// console.log(many,type); //2"gizzly" + +// function bear(type){ +// type = type || 'grizzly'; +// console.log(type); //girzzly +// } +// bear() + +// function bear(type = 'grizzly'){ +// console.log(type); //girzzly +// } +// bear() + +// function bear(...type){ +// console.log(type); +// } +// bear('polar','grizzly'); //{"polar","grizzly"} + +/* +JavaScript ES6 Template Strings + +Here's a useful video related to the major features in ES6 including template strings: + + +Template strings introduce a way to define strings with domain-specific languages (DSLs). It provides improved string interpolation, embedded expressions, multiline strings, formatting, and tagging for safe HTML. + +Template Strings + +Template strings are string literals allowing embedded expressions. +We can use multi-line strings and string interpolation features with them. + +Multiline Strings + +Any new line characters inserted in the source are part of the template string. +SAMPLE CODE + +console.log(`The HackerRank team is on a mission to flatten the world by restructuring +the DNA of every company on the planet. We rank programmers based on +their coding skills, helping companies source great programmers and reduce +the time to hire.`); +OUTPUT + +The HackerRank team is on a mission to flatten the world by restructuring +the DNA of every company on the planet. We rank programmers based on +their coding skills, helping companies source great programmers and reduce +the time to hire. +String Interpolation + +We can embed expressions within template strings by making use of its syntactic sugar. +SAMPLE CODE + +var contestant = "DOSHI"; +var score = "20"; + +console.log(`Congratulations ${contestant}!, Your score is ${score}.`); +OUTPUT + +Congratulations DOSHI!, Your score is 20. +Task + +Your task is to create a template string and assign it to the variable my_template_string. + +The template string should contain the following data only: + +My name is ${my_name}. +My id is ${my_id}. +My address is ${my_address}. +Note + +Do not create any variable other than my_template_string. +Do not print anything on the console. +Replace the blank (_______________________) with the template string. +*/ +/* +TO ANYONE STRUGGLING: +YOU HAVE TO USE ` INSTEAD OF ' or ". +You can find that key under the 'Esc' button, to the left of 1, above the 'tab' button on your keyboard. +*/ + +var my_template_string = +`My name is ${my_name}. +My id is ${my_id}. +My address is ${my_address}.`; + + diff --git a/test.cpp b/test.cpp new file mode 100644 index 0000000..bc276e6 --- /dev/null +++ b/test.cpp @@ -0,0 +1,73 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace std; + +int main(){ + double pi = 3.1415926; + complex w1(0,pi/3); + complex w2=exp(w1); + + vector > w(6); + w[0] = 1; + w[1] = w2; + for(int i = 2; i < w.size(); i++){ + w[i] = pow(w2,i); + } + + complex a0(2,0); + complex a1(4,0); + complex a2(3,0); + + vector > y(6); + for(int i = 0; i < y.size(); i++){ + y[i] = a0 + a1*w[i] + a2*w[i]*w[i]; + cout << y[i]; + } + cout << endl; + + complex b0(3,0); + complex b1(5,0); + complex b2(3,0); + complex b3(2,0); + + vector > z(6); + for(int i = 0; i < z.size(); i++){ + z[i] = b0 + b1*w[i] + b2*w[i]*w[i] + b3*w[i]*w[i]*w[i]; + cout << z[i]; + } + cout << endl; + + vector > yz(6); + for(int i = 0; i < yz.size(); i++){ + yz[i] = y[i]*z[i]; + cout << yz[i]; + } + cout << endl; + + vector > c(6); + complex n(6,0); + for(int i = 0; i < c.size(); i++){ + complex yzsum(0,0); + for(int j = 0; j < yz.size(); j++){ + yzsum += yz[j]/pow(w[i],j); + } + c[i] = yzsum/n; + cout << c[i]; + } + cout << endl; + + + return 0; +} \ No newline at end of file diff --git a/test.exe b/test.exe new file mode 100644 index 0000000000000000000000000000000000000000..aff4f0ab76dccb9ba6d344d32a3ba63f6ae14a68 GIT binary patch literal 95649 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 Tmenp5`$Z$NjMOsp4AK7wqK4yt literal 0 HcmV?d00001 diff --git a/unordered_map.cpp b/unordered_map.cpp new file mode 100644 index 0000000..10d8eee --- /dev/null +++ b/unordered_map.cpp @@ -0,0 +1,43 @@ +#include +#include +#include +#include +#include + +using namespace std; + +int main() +{ + unordered_map stringmap; + unordered_map string1({ { "apple","red" }, { "orange", "orange" }, + { "lemon" , "yellow" } }); + stringmap = string1; + cout << "contains: "; + for (auto& x : string1) cout << " " << x.first << ":" << x.second; + + cout << endl; + unordered_map stringmap1(string1.begin(), string1.end()); + cout << "contains2: "; + for (auto& x : stringmap1) cout << " " << x.first << ":" << x.second; + + std::unordered_map + myrecipe, + mypantry = { { "milk",2.0 },{ "flour",1.5 } }; + + std::pair myshopping("baking powder", 0.3); + + myrecipe.insert(myshopping); // copy insertion + myrecipe.insert(std::make_pair("eggs", 6.0)); // move insertion + myrecipe.insert(mypantry.begin(), mypantry.end()); // range insertion + myrecipe.insert({ { "sugar",0.8 },{ "salt",0.1 } }); // initializer list insertion + myrecipe["ti"] = 0.5; + + std::cout << "myrecipe contains:" << std::endl; + for (auto& x : myrecipe) + std::cout << x.first << ": " << x.second << std::endl; + + std::cout << std::endl; + + + return 0; +} \ No newline at end of file diff --git a/variables.java b/variables.java new file mode 100644 index 0000000..4a43801 --- /dev/null +++ b/variables.java @@ -0,0 +1,25 @@ +/* +Explanation + +Variables can be thought of as named containers where we can store data. +Data stored inside a variable can be retrieved by naming it at a later point. + +A variable in JavaScript is declared by using the var keyword: + +SAMPLE CODE + +var website = "hackerrank"; //Variable Declaration + +console.log(website); //Displaying variable website's content to console. +OUTPUT + +hackerrank +To learn more about valid JavaScript variable names, click here. + +Task + +In the editor below, declare a variable named newVariable and assign it the following string, "My First Variable". +*/ + +//Write your code below this line. +var newVariable = "My First Variable";