[
{
"path": ".gitignore",
"content": "/bin/\n.idea\n"
},
{
"path": ".project",
"content": "\n\n\tinterviews\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\n"
},
{
"path": "LICENSE",
"content": "MIT License\n\nCopyright (c) 2018 Kevin Naughton Jr.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n"
},
{
"path": "README-zh-cn.md",
"content": "> * 原文地址：[github.com/kdn251/interviews](https://github.com/kdn251/interviews)\n> * 译文出自：[掘金翻译计划](https://github.com/xitu/gold-miner)\n> * 译者：[王下邀月熊](https://github.com/wxyyxc1992)\n> * 校对者：[PhxNirvana](https://github.com/phxnirvana)、[根号三](https://github.com/sqrthree)\n> * 这个 [链接](https://github.com/xitu/interviews/compare/master...kdn251:master) 用来查看本翻译与英文版是否有差别（如果你没有看到 README.md 发生变化，那就意味着这份翻译文档是最新的）。\n\n# Interviews\n> 软件工程技术面试个人指南。\n>\n> Maintainer - [Kevin Naughton Jr.](https://github.com/kdn251)\n\n## 其他语言版本\n\n- [English](./README.md)\n\n## 目录\n- [在线练习](#在线练习)\n- [在线面试编程](#在线面试编程)\n- [数据结构](#数据结构)\n- [算法](#算法)\n- [位运算](#位运算)\n- [算法复杂度分析](#算法复杂度分析)\n- [视频教程](#视频教程)\n- [面试书籍](#面试书籍)\n- [计算机科学与技术资讯](#计算机科学与技术资讯)\n- [文件结构](#文件结构)\n\n## 在线练习\n* [LeetCode](https://leetcode.com/)\n* [Virtual Judge](https://vjudge.net/)\n* [CareerCup](https://www.careercup.com/)\n* [HackerRank](https://www.hackerrank.com/)\n* [CodeFights](https://codefights.com/)\n* [Kattis](https://open.kattis.com/)\n* [HackerEarth](https://www.hackerearth.com)\n* [Codility](https://codility.com/programmers/lessons/1-iterations/)\n* [Code Forces](http://codeforces.com/)\n* [Code Chef](https://www.codechef.com/)\n* [Sphere Online Judge - SPOJ](http://www.spoj.com/)\n* [InterviewBit](https://www.interviewbit.com/)\n\n## 在线面试编程\n* [Pramp](https://www.pramp.com/ref/gt4-cn)\n* [Gainlo](http://www.gainlo.co/#!/)\n* [Refdash](https://refdash.com/)\n* [Interviewing.io](https://www.interviewing.io/)\n\n## 数据结构\n### Linked List\n * 链表即是由节点（Node）组成的线性集合，每个节点可以利用指针指向其他节点。它是一种包含了多个节点的、能够用于表示序列的数据结构。\n * **单向链表**: 链表中的节点仅指向下一个节点，并且最后一个节点指向空。\n * **双向链表**: 其中每个节点具有两个指针 p、n，使得 p 指向先前节点并且 n 指向下一个节点；最后一个节点的 n 指针指向 null。\n * **循环链表**：每个节点指向下一个节点并且最后一个节点指向第一个节点的链表。\n * 时间复杂度:\n * 索引: `O(n)`\n * 搜索: `O(n)`\n * 插入: `O(1)`\n * 移除: `O(1)`\n\n### Stack\n * 栈是元素的集合，其包含了两个基本操作：push 操作可以用于将元素压入栈，pop 操作可以将栈顶元素移除。\n * 遵循后入先出（LIFO）原则。\n * 时间复杂度:\n * 索引: `O(n)`\n * 搜索: `O(n)`\n * 插入: `O(1)`\n * 移除: `O(1)`\n\n### Queue\n * 队列是元素的集合，其包含了两个基本操作：enqueue 操作可以用于将元素插入到队列中，而 dequeue 操作则是将元素从队列中移除。\n * 遵循先入先出原则 (FIFO)。\n * 时间复杂度:\n * 索引: `O(n)`\n * 搜索: `O(n)`\n * 插入: `O(1)`\n * 移除: `O(1)`\n\n### Tree\n* 树是无向、连通的无环图。\n\n### Binary Tree\n * 二叉树即是每个节点最多包含左子节点与右子节点这两个节点的树形数据结构。\n * **满二叉树**: 树中的每个节点仅包含 0 或 2 个节点。\n * **完美二叉树（Perfect Binary Tree）**: 二叉树中的每个叶节点都拥有两个子节点，并且具有相同的高度。\n * **完全二叉树**: 除最后一层外，每一层上的结点数均达到最大值；在最后一层上只缺少右边的若干结点。\n\n### Binary Search Tree\n\n* 二叉搜索树（BST）是一种特殊的二叉树，其任何节点中的值都会大于或者等于其左子树中存储的值并且小于或者等于其右子树中存储的值。\n* 时间复杂度:\n * 索引: `O(log(n))`\n * 搜索: `O(log(n))`\n * 插入: `O(log(n))`\n * 删除: `O(log(n))`\n\n![\"Binary](\"/images/BST.png?raw=true\")
\n\n### Trie\n* 字典树，又称基数树或者前缀树，能够用于存储键为字符串的动态集合或者关联数组的搜索树。树中的节点并没有直接存储关联键值，而是该节点在树中的挂载位置决定了其关联键值。某个节点的所有子节点都拥有相同的前缀，整棵树的根节点则是空字符串。\n\n![Alt text](/images/trie.png?raw=true \"Trie\")\n\n### Fenwick Tree\n* 树状数组又称 Binary Indexed Tree，其表现形式为树，不过本质上是以数组实现。数组中的下标代表着树中的顶点，每个顶点的父节点或者子节点的下标能够通过位运算获得。数组中的每个元素包含了预计算的区间值之和，在整棵树更新的过程中同样会更新这些预计算的值。\n* 时间复杂度:\n * 区间求值: `O(log(n))`\n * 更新: `O(log(n))`\n\n![Alt text](/images/fenwickTree.png?raw=true \"Fenwick Tree\")\n\n### Segment Tree\n* 线段树是用于存放间隔或者线段的树形数据结构，它允许快速的查找某一个节点在若干条线段中出现的次数.\n* 时间复杂度:\n * 区间查询: `O(log(n))`\n * 更新: `O(log(n))`\n\n![Alt text](/images/segmentTree.png?raw=true \"Segment Tree\")\n\n### Heap\n* 堆是一种特殊的基于树的满足某些特性的数据结构，整个堆中的所有父子节点的键值都会满足相同的排序条件。堆更准确地可以分为最大堆与最小堆，在最大堆中，父节点的键值永远大于或者等于子节点的值，并且整个堆中的最大值存储于根节点；而最小堆中，父节点的键值永远小于或者等于其子节点的键值，并且整个堆中的最小值存储于根节点。\n* 时间复杂度:\n * 访问最大值 / 最小值: `O(1)`\n * 插入: `O(log(n))`\n * 移除最大值 / 最小值: `O(log(n))`\n\n![\"Max](\"/images/heap.png?raw=true\")
\n\n\n### Hashing\n* 哈希能够将任意长度的数据映射到固定长度的数据。哈希函数返回的即是哈希值，如果两个不同的键得到相同的哈希值，即将这种现象称为碰撞。\n* **Hash Map**: Hash Map 是一种能够建立起键与值之间关系的数据结构，Hash Map 能够使用哈希函数将键转化为桶或者槽中的下标，从而优化对于目标值的搜索速度。\n* 碰撞解决\n * **链地址法（Separate Chaining）**: 链地址法中，每个桶是相互独立的，包含了一系列索引的列表。搜索操作的时间复杂度即是搜索桶的时间（固定时间）与遍历列表的时间之和。\n * **开地址法（Open Addressing）**: 在开地址法中，当插入新值时，会判断该值对应的哈希桶是否存在，如果存在则根据某种算法依次选择下一个可能的位置，直到找到一个尚未被占用的地址。所谓开地址法也是指某个元素的位置并不永远由其哈希值决定。\n\n![Alt text](/images/hash.png?raw=true \"Hashing\")\n\n### Graph\n* 图是一种数据元素间为多对多关系的数据结构，加上一组基本操作构成的抽象数据类型。\n * **无向图（Undirected Graph）**: 无向图具有对称的邻接矩阵，因此如果存在某条从节点 u 到节点 v 的边，反之从 v 到 u 的边也存在。\n * **有向图（Directed Graph）**: 有向图的邻接矩阵是非对称的，即如果存在从 u 到 v 的边并不意味着一定存在从 v 到 u 的边。\n\n![\"Graph\"](\"/images/graph.png?raw=true\")
\n\n## 算法\n\n### 排序\n\n#### 快速排序\n* 稳定: 否\n* 时间复杂度:\n * 最优时间: `O(nlog(n))`\n * 最坏时间: `O(n^2)`\n * 平均时间: `O(nlog(n))`\n\n![Alt text](/images/quicksort.gif?raw=true \"Quicksort\")\n\n#### 归并排序\n* 归并排序是典型的分治算法，它不断地将某个数组分为两个部分，分别对左子数组与右子数组进行排序，然后将两个数组合并为新的有序数组。\n* 稳定: 是\n* 时间复杂度:\n * 最优时间: `O(nlog(n))`\n * 最坏时间: `O(nlog(n))`\n * 平均时间: `O(nlog(n))`\n\n![Alt text](/images/mergesort.gif?raw=true \"Mergesort\")\n\n#### 桶排序\n* 桶排序将数组分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序）。\n* 时间复杂度:\n * 最优时间: `Ω(n + k)`\n * 最坏时间: `O(n^2)`\n * 平均时间:`Θ(n + k)`\n\n\n![Alt text](/images/bucketsort.png?raw=true \"Bucket Sort\")\n\n#### 基数排序\n* 基数排序类似于桶排序，将数组分割到有限数目的桶中；不过其在分割之后并没有让每个桶单独地进行排序，而是直接进行了合并操作。\n* 时间复杂度:\n * 最优时间: `Ω(nk)`\n * 最坏时间: `O(nk)`\n * 平均时间: `Θ(nk)`\n\n### 图算法\n\n#### 深度优先搜索\n* 深度优先算法是一种优先遍历子节点而不是回溯的算法。\n* 时间复杂度: `O(|V| + |E|)`\n\n![Alt text](/images/dfsbfs.gif?raw=true \"DFS / BFS Traversal\")\n\n#### 广度优先搜索\n* 广度优先搜索是优先遍历邻居节点而不是子节点的图遍历算法。\n* 时间复杂度: `O(|V| + |E|)`\n\n![Alt text](/images/dfsbfs.gif?raw=true \"DFS / BFS Traversal\")\n\n#### 拓扑排序\n* 拓扑排序是对于有向图节点的线性排序，如果存在某条从 u 到 v 的边，则认为 u 的下标先于 v。\n* 时间复杂度: `O(|V| + |E|)`\n\n#### Dijkstra 算法\n* **Dijkstra 算法** 用于计算有向图中单源最短路径问题。\n* 时间复杂度: `O(|V|^2)`\n\n![Alt text](/images/dijkstra.gif?raw=true \"Dijkstra's\")\n\n#### Bellman-Ford 算法\n* **Bellman-Ford 算法**是在带权图中计算从单一源点出发到其他节点的最短路径的算法。\n* 尽管算法复杂度大于 Dijkstra 算法，但是它适用于包含了负值边的图。\n* 时间复杂度:\n * 最优时间: `O(|E|)`\n - 最坏时间: `O(|V||E|)`\n\n![Alt text](/images/bellman-ford.gif?raw=true \"Bellman-Ford\")\n\n#### Floyd-Warshall 算法\n* **Floyd-Warshall 算法** 能够用于在无环带权图中寻找任意节点的最短路径。\n* 时间复杂度:\n * 最优时间: `O(|V|^3)`\n * 最坏时间: `O(|V|^3)`\n * 平均时间: `O(|V|^3)`\n\n#### Prim 算法\n* **Prim 算法**是用于在带权无向图中计算最小生成树的贪婪算法。换言之，Prim 算法能够在图中抽取出连接所有节点的边的最小代价子集。\n* 时间复杂度: `O(|V|^2)`\n\n![Alt text](/images/prim.gif?raw=true \"Prim's Algorithm\")\n\n#### Kruskal 算法\n* **Kruskal 算法**同样是计算图的最小生成树的算法，与 Prim 的区别在于并不需要图是连通的。\n* 时间复杂度: `O(|E|log|V|)`\n\n![Alt text](/images/kruskal.gif?raw=true \"Kruskal's Algorithm\")\n\n## 位运算\n* 位运算即是在位级别进行操作的技术，合适的位运算能够帮助我们得到更快地运算速度与更小的内存使用。\n* 测试第 k 位: `s & (1 << k)`\n* 设置第 k 位: `s |= (1 << k)`\n* 第 k 位置零: `s &= ~(1 << k)`\n* 切换第 k 位值: `s ^= ~(1 << k)`\n* 乘以 2n: `s << n`\n* 除以 2n: `s >> n`\n* 交集: `s & t`\n* 并集: `s | t`\n* 减法: `s & ~t`\n* 交换 `x = x ^ y ^ (y = x)`\n* 取出最小非 0 位（Extract lowest set bit）: `s & (-s)`\n* 取出最小 0 位（Extract lowest unset bit）: `~s & (s + 1)`\n* 交换值:\n ```\n x ^= y;\n y ^= x;\n x ^= y;\n ```\n\n## 算法复杂度分析\n\n#### 大 O 表示\n* **大 O 表示** 用于表示某个算法的上限，往往用于描述最坏的情况。\n\n![Alt text](/images/bigO.png?raw=true \"Theta Notation\")\n\n#### 小 O 表示\n* **小 O 表示**用于描述某个算法的渐进上界，不过二者要更为紧密。\n\n#### 大 Ω 表示\n* **大 Ω 表示**用于描述某个算法的渐进下界。\n\n![Alt text](/images/bigOmega.png?raw=true \"Theta Notation\")\n\n#### 小 ω 表示\n* **Little Omega Notation**用于描述某个特定算法的下界，不过不一定很靠近。\n\n#### Theta Θ 表示\n* **Theta Notation**用于描述某个确定算法的确界。\n\n![Alt text](/images/theta.png?raw=true \"Theta Notation\")\n\n## 视频教程\n* Data Structures\n * [UC Berkeley Data Structures](https://www.youtube.com/watch?v=mFPmKGIrQs4&index=1&list=PL-XXv-cvA_iAlnI-BQr9hjqADPBtujFJd)\n * [MIT Advanced Data Structures](https://www.youtube.com/watch?v=T0yzrZL1py0&list=PLUl4u3cNGP61hsJNdULdudlRL493b-XZf&index=1)\n* Algorithms\n * [MIT Introduction to Algorithms](https://www.youtube.com/watch?v=HtSuA80QTyo&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=1)\n * [MIT Advanced Algorithms](https://www.youtube.com/playlist?list=PL6ogFv-ieghdoGKGg2Bik3Gl1glBTEu8c)\n\n## 面试书籍\n* Competitive Programming 3 - Steven Halim & Felix Halim\n* Cracking The Coding Interview - Gayle Laakmann McDowell\n* Cracking The PM Interview - Gayle Laakmann McDowell & Jackie Bavaro\n\n## 计算机科学与技术资讯\n* [Hacker News](https://news.ycombinator.com/)\n* [Lobsters](https://lobste.rs/)\n\n## 文件结构\n\n```\n.\n├── Array\n│ ├── bestTimeToBuyAndSellStock.java\n│ ├── findTheCelebrity.java\n│ ├── gameOfLife.java\n│ ├── increasingTripletSubsequence.java\n│ ├── insertInterval.java\n│ ├── longestConsecutiveSequence.java\n│ ├── maximumProductSubarray.java\n│ ├── maximumSubarray.java\n│ ├── mergeIntervals.java\n│ ├── missingRanges.java\n│ ├── productOfArrayExceptSelf.java\n│ ├── rotateImage.java\n│ ├── searchInRotatedSortedArray.java\n│ ├── spiralMatrixII.java\n│ ├── subsetsII.java\n│ ├── subsets.java\n│ ├── summaryRanges.java\n│ ├── wiggleSort.java\n│ └── wordSearch.java\n├── Backtracking\n│ ├── androidUnlockPatterns.java\n│ ├── generalizedAbbreviation.java\n│ └── letterCombinationsOfAPhoneNumber.java\n├── BinarySearch\n│ ├── closestBinarySearchTreeValue.java\n│ ├── firstBadVersion.java\n│ ├── guessNumberHigherOrLower.java\n│ ├── pow(x,n).java\n│ └── sqrt(x).java\n├── BitManipulation\n│ ├── binaryWatch.java\n│ ├── countingBits.java\n│ ├── hammingDistance.java\n│ ├── maximumProductOfWordLengths.java\n│ ├── numberOf1Bits.java\n│ ├── sumOfTwoIntegers.java\n│ └── utf-8Validation.java\n├── BreadthFirstSearch\n│ ├── binaryTreeLevelOrderTraversal.java\n│ ├── cloneGraph.java\n│ ├── pacificAtlanticWaterFlow.java\n│ ├── removeInvalidParentheses.java\n│ ├── shortestDistanceFromAllBuildings.java\n│ ├── symmetricTree.java\n│ └── wallsAndGates.java\n├── DepthFirstSearch\n│ ├── balancedBinaryTree.java\n│ ├── battleshipsInABoard.java\n│ ├── convertSortedArrayToBinarySearchTree.java\n│ ├── maximumDepthOfABinaryTree.java\n│ ├── numberOfIslands.java\n│ ├── populatingNextRightPointersInEachNode.java\n│ └── sameTree.java\n├── Design\n│ └── zigzagIterator.java\n├── DivideAndConquer\n│ ├── expressionAddOperators.java\n│ └── kthLargestElementInAnArray.java\n├── DynamicProgramming\n│ ├── bombEnemy.java\n│ ├── climbingStairs.java\n│ ├── combinationSumIV.java\n│ ├── countingBits.java\n│ ├── editDistance.java\n│ ├── houseRobber.java\n│ ├── paintFence.java\n│ ├── paintHouseII.java\n│ ├── regularExpressionMatching.java\n│ ├── sentenceScreenFitting.java\n│ ├── uniqueBinarySearchTrees.java\n│ └── wordBreak.java\n├── HashTable\n│ ├── binaryTreeVerticalOrderTraversal.java\n│ ├── findTheDifference.java\n│ ├── groupAnagrams.java\n│ ├── groupShiftedStrings.java\n│ ├── islandPerimeter.java\n│ ├── loggerRateLimiter.java\n│ ├── maximumSizeSubarraySumEqualsK.java\n│ ├── minimumWindowSubstring.java\n│ ├── sparseMatrixMultiplication.java\n│ ├── strobogrammaticNumber.java\n│ ├── twoSum.java\n│ └── uniqueWordAbbreviation.java\n├── LinkedList\n│ ├── addTwoNumbers.java\n│ ├── deleteNodeInALinkedList.java\n│ ├── mergeKSortedLists.java\n│ ├── palindromeLinkedList.java\n│ ├── plusOneLinkedList.java\n│ ├── README.md\n│ └── reverseLinkedList.java\n├── Queue\n│ └── movingAverageFromDataStream.java\n├── README.md\n├── Sort\n│ ├── meetingRoomsII.java\n│ └── meetingRooms.java\n├── Stack\n│ ├── binarySearchTreeIterator.java\n│ ├── decodeString.java\n│ ├── flattenNestedListIterator.java\n│ └── trappingRainWater.java\n├── String\n│ ├── addBinary.java\n│ ├── countAndSay.java\n│ ├── decodeWays.java\n│ ├── editDistance.java\n│ ├── integerToEnglishWords.java\n│ ├── longestPalindrome.java\n│ ├── longestSubstringWithAtMostKDistinctCharacters.java\n│ ├── minimumWindowSubstring.java\n│ ├── multiplyString.java\n│ ├── oneEditDistance.java\n│ ├── palindromePermutation.java\n│ ├── README.md\n│ ├── reverseVowelsOfAString.java\n│ ├── romanToInteger.java\n│ ├── validPalindrome.java\n│ └── validParentheses.java\n├── Tree\n│ ├── binaryTreeMaximumPathSum.java\n│ ├── binaryTreePaths.java\n│ ├── inorderSuccessorInBST.java\n│ ├── invertBinaryTree.java\n│ ├── lowestCommonAncestorOfABinaryTree.java\n│ ├── sumOfLeftLeaves.java\n│ └── validateBinarySearchTree.java\n├── Trie\n│ ├── addAndSearchWordDataStructureDesign.java\n│ ├── implementTrie.java\n│ └── wordSquares.java\n└── TwoPointers\n ├── 3Sum.java\n ├── 3SumSmaller.java\n ├── mergeSortedArray.java\n ├── minimumSizeSubarraySum.java\n ├── moveZeros.java\n ├── removeDuplicatesFromSortedArray.java\n ├── reverseString.java\n └── sortColors.java\n\n18 directories, 124 files\n```\n"
},
{
"path": "README.md",
"content": "# Interviews\n> Pass your coding interviews with [The Daily Byte](https://thedailybyte.dev/?ref=kevin) \n> [30,000+ Software Engineers have trusted us with their interview prep](https://thedailybyte.dev/?ref=kevin).\n![](\"/images/the-daily-byte.png?raw=true\")
\n>\n> Maintainer - [Kevin Naughton Jr.](https://github.com/kdn251)\n\n## Translations\n\n- [简体中文](./README-zh-cn.md)\n\n## Table of Contents\n- [YouTube](#youtube)\n- [The Daily Byte](#the-daily-byte)\n- [Instagram](#instagram)\n- [Articles](#articles)\n- [Online Judges](#online-judges)\n- [Live Coding Practice](#live-coding-practice)\n- [Data Structures](#data-structures)\n- [Algorithms](#algorithms)\n- [Greedy Algorithms](#greedy-algorithms)\n- [Bitmasks](#bitmasks)\n- [Runtime Analysis](#runtime-analysis)\n- [Video Lectures](#video-lectures)\n- [Interview Books](#interview-books)\n- [Computer Science News](#computer-science-news)\n- [Directory Tree](#directory-tree)\n\n## YouTube\n* [Kevin Naughton Jr.](https://www.youtube.com/channel/UCKvwPt6BifPP54yzH99ff1g)\n\n## The Daily Byte\n* [FAANG Interview Prep](https://thedailybyte.dev/?ref=kevin)\n\n## Instagram \n* [Kevin Naughton Jr.](https://www.instagram.com/kevinnaughtonjr)\n\n## Online Judges\n* [LeetCode](https://leetcode.com/)\n* [Virtual Judge](https://vjudge.net/)\n* [CareerCup](https://www.careercup.com/)\n* [HackerRank](https://www.hackerrank.com/)\n* [CodeFights](https://codefights.com/)\n* [Kattis](https://open.kattis.com/)\n* [HackerEarth](https://www.hackerearth.com)\n* [Codility](https://codility.com/programmers/lessons/1-iterations/)\n* [Code Forces](http://codeforces.com/)\n* [Code Chef](https://www.codechef.com/)\n* [Sphere Online Judge - SPOJ](http://www.spoj.com/)\n* [InterviewBit](https://www.interviewbit.com/)\n\n## Live Mock Interviews\n* [The Daily Byte](https://thedailybyte.dev/mock-interview)\n\n## Live Coding Practice\n* [The Daily Byte](https://thedailybyte.dev/?ref=kevin)\n* [Pramp](https://www.pramp.com/ref/gt4)\n* [Gainlo](http://www.gainlo.co/#!/)\n* [Refdash](https://refdash.com/)\n* [Interviewing.io](https://www.interviewing.io/)\n\n## Data Structures\n### Linked List\n * A *Linked List* is a linear collection of data elements, called nodes, each\n pointing to the next node by means of a pointer. It is a data structure\n consisting of a group of nodes which together represent a sequence.\n * **Singly-linked list**: linked list in which each node points to the next node and the last node points to null\n * **Doubly-linked list**: linked list in which each node has two pointers, p and n, such that p points to the previous node and n points to the next node; the last node's n pointer points to null\n * **Circular-linked list**: linked list in which each node points to the next node and the last node points back to the first node\n * Time Complexity:\n * Access: `O(n)`\n * Search: `O(n)`\n * Insert: `O(1)`\n * Remove: `O(1)`\n\n### Stack\n * A *Stack* is a collection of elements, with two principle operations: *push*, which adds to the collection, and\n *pop*, which removes the most recently added element\n * **Last in, first out data structure (LIFO)**: the most recently added object is the first to be removed\n * Time Complexity:\n * Access: `O(n)`\n * Search: `O(n)`\n * Insert: `O(1)`\n * Remove: `O(1)`\n\n### Queue\n * A *Queue* is a collection of elements, supporting two principle operations: *enqueue*, which inserts an element\n into the queue, and *dequeue*, which removes an element from the queue\n * **First in, first out data structure (FIFO)**: the oldest added object is the first to be removed\n * Time Complexity:\n * Access: `O(n)`\n * Search: `O(n)`\n * Insert: `O(1)`\n * Remove: `O(1)`\n\n### Tree\n * A *Tree* is an undirected, connected, acyclic graph\n\n### Binary Tree\n * A *Binary Tree* is a tree data structure in which each node has at most two children, which are referred to as\n the *left child* and *right child*\n * **Full Tree**: a tree in which every node has either 0 or 2 children\n * **Perfect Binary Tree**: a binary tree in which all interior nodes have two children and all leave have the same depth\n * **Complete Tree**: a binary tree in which every level *except possibly the last* is full and all nodes in the last\n level are as far left as possible\n\n### Binary Search Tree\n * A binary search tree, sometimes called BST, is a type of binary tree which maintains the property that the value in each\n node must be greater than or equal to any value stored in the left sub-tree, and less than or equal to any value stored\n in the right sub-tree\n * Time Complexity:\n * Access: `O(log(n))`\n * Search: `O(log(n))`\n * Insert: `O(log(n))`\n * Remove: `O(log(n))`\n\n\n\n### Trie\n* A trie, sometimes called a radix or prefix tree, is a kind of search tree that is used to store a dynamic set or associative\n array where the keys are usually Strings. No node in the tree stores the key associated with that node; instead, its position \n in the tree defines the key with which it is associated. All the descendants of a node have a common prefix of the String associated \n with that node, and the root is associated with the empty String.\n\n![Alt text](/images/trie.png?raw=true \"Trie\")\n\n### Fenwick Tree\n* A Fenwick tree, sometimes called a binary indexed tree, is a tree in concept, but in practice is implemented as an implicit data\n structure using an array. Given an index in the array representing a vertex, the index of a vertex's parent or child is calculated\n through bitwise operations on the binary representation of its index. Each element of the array contains the pre-calculated sum of\n a range of values, and by combining that sum with additional ranges encountered during an upward traversal to the root, the prefix\n sum is calculated\n* Time Complexity:\n * Range Sum: `O(log(n))`\n * Update: `O(log(n))`\n\n![Alt text](/images/fenwickTree.png?raw=true \"Fenwick Tree\")\n\n### Segment Tree\n* A Segment tree, is a tree data structure for storing intervals, or segments. It allows querying which of the stored segments contain\n a given point\n* Time Complexity:\n * Range Query: `O(log(n))`\n * Update: `O(log(n))`\n\n![Alt text](/images/segmentTree.png?raw=true \"Segment Tree\")\n\n### Heap\n* A *Heap* is a specialized tree based structure data structure that satisfies the *heap* property: if A is a parent node of\nB, then the key (the value) of node A is ordered with respect to the key of node B with the same ordering applying across the entire heap.\nA heap can be classified further as either a \"max heap\" or a \"min heap\". In a max heap, the keys of parent nodes are always greater\nthan or equal to those of the children and the highest key is in the root node. In a min heap, the keys of parent nodes are less than\nor equal to those of the children and the lowest key is in the root node\n* Time Complexity:\n * Access Max / Min: `O(1)`\n * Insert: `O(log(n))`\n * Remove Max / Min: `O(log(n))`\n\n\n\n\n### Hashing\n* *Hashing* is used to map data of an arbitrary size to data of a fixed size. The values returned by a hash\n function are called hash values, hash codes, or simply hashes. If two keys map to the same value, a collision occurs\n* **Hash Map**: a *hash map* is a structure that can map keys to values. A hash map uses a hash function to compute\n an index into an array of buckets or slots, from which the desired value can be found.\n* Collision Resolution\n * **Separate Chaining**: in *separate chaining*, each bucket is independent, and contains a list of entries for each index. The\n time for hash map operations is the time to find the bucket (constant time), plus the time to iterate through the list\n * **Open Addressing**: in *open addressing*, when a new entry is inserted, the buckets are examined, starting with the\n hashed-to-slot and proceeding in some sequence, until an unoccupied slot is found. The name open addressing refers to\n the fact that the location of an item is not always determined by its hash value\n\n\n![Alt text](/images/hash.png?raw=true \"Hashing\")\n\n### Graph\n* A *Graph* is an ordered pair of G = (V, E) comprising a set V of vertices or nodes together with a set E of edges or arcs,\n which are 2-element subsets of V (i.e. an edge is associated with two vertices, and that association takes the form of the\n unordered pair comprising those two vertices)\n * **Undirected Graph**: a graph in which the adjacency relation is symmetric. So if there exists an edge from node u to node\n v (u -> v), then it is also the case that there exists an edge from node v to node u (v -> u)\n * **Directed Graph**: a graph in which the adjacency relation is not symmetric. So if there exists an edge from node u to node v\n (u -> v), this does *not* imply that there exists an edge from node v to node u (v -> u)\n\n\n\n\n## Algorithms\n\n### Sorting\n\n#### Quicksort\n* Stable: `No`\n* Time Complexity:\n * Best Case: `O(nlog(n))`\n * Worst Case: `O(n^2)`\n * Average Case: `O(nlog(n))`\n\n![Alt text](/images/quicksort.gif?raw=true \"Quicksort\")\n\n#### Mergesort\n* *Mergesort* is also a divide and conquer algorithm. It continuously divides an array into two halves, recurses on both the\n left subarray and right subarray and then merges the two sorted halves\n* Stable: `Yes`\n* Time Complexity:\n * Best Case: `O(nlog(n))`\n * Worst Case: `O(nlog(n))`\n * Average Case: `O(nlog(n))`\n\n![Alt text](/images/mergesort.gif?raw=true \"Mergesort\")\n\n#### Bucket Sort\n* *Bucket Sort* is a sorting algorithm that works by distributing the elements of an array into a number of buckets. Each bucket\n is then sorted individually, either using a different sorting algorithm, or by recursively applying the bucket sorting algorithm\n* Time Complexity:\n * Best Case: `Ω(n + k)`\n * Worst Case: `O(n^2)`\n * Average Case:`Θ(n + k)`\n\n![Alt text](/images/bucketsort.png?raw=true \"Bucket Sort\")\n\n#### Radix Sort\n* *Radix Sort* is a sorting algorithm that like bucket sort, distributes elements of an array into a number of buckets. However, radix\n sort differs from bucket sort by 're-bucketing' the array after the initial pass as opposed to sorting each bucket and merging\n* Time Complexity:\n * Best Case: `Ω(nk)`\n * Worst Case: `O(nk)`\n * Average Case: `Θ(nk)`\n\n### Graph Algorithms\n\n#### Depth First Search\n* *Depth First Search* is a graph traversal algorithm which explores as far as possible along each branch before backtracking\n* Time Complexity: `O(|V| + |E|)`\n\n![Alt text](/images/dfsbfs.gif?raw=true \"DFS / BFS Traversal\")\n\n#### Breadth First Search\n* *Breadth First Search* is a graph traversal algorithm which explores the neighbor nodes first, before moving to the next\n level neighbors\n* Time Complexity: `O(|V| + |E|)`\n\n![Alt text](/images/dfsbfs.gif?raw=true \"DFS / BFS Traversal\")\n\n#### Topological Sort\n* *Topological Sort* is the linear ordering of a directed graph's nodes such that for every edge from node u to node v, u\n comes before v in the ordering\n* Time Complexity: `O(|V| + |E|)`\n\n#### Dijkstra's Algorithm\n* *Dijkstra's Algorithm* is an algorithm for finding the shortest path between nodes in a graph\n* Time Complexity: `O(|V|^2)`\n\n![Alt text](/images/dijkstra.gif?raw=true \"Dijkstra's\")\n\n#### Bellman-Ford Algorithm\n* *Bellman-Ford Algorithm* is an algorithm that computes the shortest paths from a single source node to all other nodes in a weighted graph\n* Although it is slower than Dijkstra's, it is more versatile, as it is capable of handling graphs in which some of the edge weights are\n negative numbers\n* Time Complexity:\n * Best Case: `O(|E|)`\n * Worst Case: `O(|V||E|)`\n\n![Alt text](/images/bellman-ford.gif?raw=true \"Bellman-Ford\")\n\n#### Floyd-Warshall Algorithm\n* *Floyd-Warshall Algorithm* is an algorithm for finding the shortest paths in a weighted graph with positive or negative edge weights, but\n no negative cycles\n* A single execution of the algorithm will find the lengths (summed weights) of the shortest paths between *all* pairs of nodes\n* Time Complexity:\n * Best Case: `O(|V|^3)`\n * Worst Case: `O(|V|^3)`\n * Average Case: `O(|V|^3)`\n\n#### Prim's Algorithm\n* *Prim's Algorithm* is a greedy algorithm that finds a minimum spanning tree for a weighted undirected graph. In other words, Prim's find a\n subset of edges that forms a tree that includes every node in the graph\n* Time Complexity: `O(|V|^2)`\n\n![Alt text](/images/prim.gif?raw=true \"Prim's Algorithm\")\n\n#### Kruskal's Algorithm\n* *Kruskal's Algorithm* is also a greedy algorithm that finds a minimum spanning tree in a graph. However, in Kruskal's, the graph does not\n have to be connected\n* Time Complexity: `O(|E|log|V|)`\n\n![Alt text](/images/kruskal.gif?raw=true \"Kruskal's Algorithm\")\n\n## Greedy Algorithms\n* *Greedy Algorithms* are algorithms that make locally optimal choices at each step in the hope of eventually reaching the globally optimal solution\n* Problems must exhibit two properties in order to implement a Greedy solution:\n * Optimal Substructure\n * An optimal solution to the problem contains optimal solutions to the given problem's subproblems\n * The Greedy Property\n * An optimal solution is reached by \"greedily\" choosing the locally optimal choice without ever reconsidering previous choices\n* Example - Coin Change\n * Given a target amount V cents and a list of denominations of n coins, i.e. we have coinValue[i] (in cents) for coin types i from [0...n - 1],\n what is the minimum number of coins that we must use to represent amount V? Assume that we have an unlimited supply of coins of any type\n * Coins - Penny (1 cent), Nickel (5 cents), Dime (10 cents), Quarter (25 cents)\n * Assume V = 41. We can use the Greedy algorithm of continuously selecting the largest coin denomination less than or equal to V, subtract that\n coin's value from V, and repeat.\n * V = 41 | 0 coins used\n * V = 16 | 1 coin used (41 - 25 = 16)\n * V = 6 | 2 coins used (16 - 10 = 6)\n * V = 1 | 3 coins used (6 - 5 = 1)\n * V = 0 | 4 coins used (1 - 1 = 0)\n * Using this algorithm, we arrive at a total of 4 coins which is optimal\n\n## Bitmasks\n* Bitmasking is a technique used to perform operations at the bit level. Leveraging bitmasks often leads to faster runtime complexity and\n helps limit memory usage\n* Test kth bit: `s & (1 << k);`\n* Set kth bit: `s |= (1 << k);`\n* Turn off kth bit: `s &= ~(1 << k);`\n* Toggle kth bit: `s ^= (1 << k);`\n* Multiple by 2n: `s << n;`\n* Divide by 2n: `s >> n;`\n* Intersection: `s & t;`\n* Union: `s | t;`\n* Set Subtraction: `s & ~t;`\n* Extract lowest set bit: `s & (-s);`\n* Extract lowest unset bit: `~s & (s + 1);`\n* Swap Values:\n ```\n x ^= y;\n y ^= x;\n x ^= y;\n ```\n\n## Runtime Analysis\n\n#### Big O Notation\n* *Big O Notation* is used to describe the upper bound of a particular algorithm. Big O is used to describe worst case scenarios\n\n![Alt text](/images/bigO.png?raw=true \"Theta Notation\")\n\n#### Little O Notation\n* *Little O Notation* is also used to describe an upper bound of a particular algorithm; however, Little O provides a bound\n that is not asymptotically tight\n\n#### Big Ω Omega Notation\n* *Big Omega Notation* is used to provide an asymptotic lower bound on a particular algorithm\n\n![Alt text](/images/bigOmega.png?raw=true \"Theta Notation\")\n\n#### Little ω Omega Notation\n* *Little Omega Notation* is used to provide a lower bound on a particular algorithm that is not asymptotically tight\n\n#### Theta Θ Notation\n* *Theta Notation* is used to provide a bound on a particular algorithm such that it can be \"sandwiched\" between\n two constants (one for an upper limit and one for a lower limit) for sufficiently large values\n\n![Alt text](/images/theta.png?raw=true \"Theta Notation\")\n\n## Video Lectures\n* Data Structures\n * [UC Berkeley Data Structures](https://archive.org/details/ucberkeley-webcast?&and[]=subject%3A%22Computer%20Science%22&and[]=subject%3A%22CS%22)\n * [MIT Advanced Data Structures](https://www.youtube.com/watch?v=T0yzrZL1py0&list=PLUl4u3cNGP61hsJNdULdudlRL493b-XZf&index=1)\n* Algorithms\n * [MIT Introduction to Algorithms](https://www.youtube.com/watch?v=HtSuA80QTyo&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=1)\n * [MIT Advanced Algorithms](https://www.youtube.com/playlist?list=PL6ogFv-ieghdoGKGg2Bik3Gl1glBTEu8c)\n * [UC Berkeley Algorithms](https://archive.org/details/ucberkeley-webcast?&and[]=subject%3A%22Computer%20Science%22&and[]=subject%3A%22CS%22)\n\n## Interview Books\n* [Competitive Programming 3 - Steven Halim & Felix Halim](https://www.amazon.com/Competitive-Programming-3rd-Steven-Halim/dp/B00FG8MNN8) \n* [Cracking The Coding Interview - Gayle Laakmann McDowell](https://www.amazon.com/Cracking-Coding-Interview-Programming-Questions/dp/0984782850/ref=sr_1_1?s=books&ie=UTF8)\n* [Cracking The PM Interview - Gayle Laakmann McDowell & Jackie Bavaro](https://www.amazon.com/Cracking-PM-Interview-Product-Technology-ebook/dp/B00ISYMUR6/ref=sr_1_1?s=books&ie=UTF8)\n* [Introduction to Algorithms - Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest & Clifford Stein](https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844/ref=sr_1_1?ie=UTF8&qid=1490295989&sr=8-1&keywords=Introduction+to+Algorithms)\n\n## Computer Science News\n* [Hacker News](https://news.ycombinator.com/)\n* [Lobsters](https://lobste.rs/)\n\n## Directory Tree\n\n```\n.\n├── Array\n│ ├── bestTimeToBuyAndSellStock.java\n│ ├── findTheCelebrity.java\n│ ├── gameOfLife.java\n│ ├── increasingTripletSubsequence.java\n│ ├── insertInterval.java\n│ ├── longestConsecutiveSequence.java\n│ ├── maximumProductSubarray.java\n│ ├── maximumSubarray.java\n│ ├── mergeIntervals.java\n│ ├── missingRanges.java\n│ ├── productOfArrayExceptSelf.java\n│ ├── rotateImage.java\n│ ├── searchInRotatedSortedArray.java\n│ ├── spiralMatrixII.java\n│ ├── subsetsII.java\n│ ├── subsets.java\n│ ├── summaryRanges.java\n│ ├── wiggleSort.java\n│ └── wordSearch.java\n├── Backtracking\n│ ├── androidUnlockPatterns.java\n│ ├── generalizedAbbreviation.java\n│ └── letterCombinationsOfAPhoneNumber.java\n├── BinarySearch\n│ ├── closestBinarySearchTreeValue.java\n│ ├── firstBadVersion.java\n│ ├── guessNumberHigherOrLower.java\n│ ├── pow(x,n).java\n│ └── sqrt(x).java\n├── BitManipulation\n│ ├── binaryWatch.java\n│ ├── countingBits.java\n│ ├── hammingDistance.java\n│ ├── maximumProductOfWordLengths.java\n│ ├── numberOf1Bits.java\n│ ├── sumOfTwoIntegers.java\n│ └── utf-8Validation.java\n├── BreadthFirstSearch\n│ ├── binaryTreeLevelOrderTraversal.java\n│ ├── cloneGraph.java\n│ ├── pacificAtlanticWaterFlow.java\n│ ├── removeInvalidParentheses.java\n│ ├── shortestDistanceFromAllBuildings.java\n│ ├── symmetricTree.java\n│ └── wallsAndGates.java\n├── DepthFirstSearch\n│ ├── balancedBinaryTree.java\n│ ├── battleshipsInABoard.java\n│ ├── convertSortedArrayToBinarySearchTree.java\n│ ├── maximumDepthOfABinaryTree.java\n│ ├── numberOfIslands.java\n│ ├── populatingNextRightPointersInEachNode.java\n│ └── sameTree.java\n├── Design\n│ └── zigzagIterator.java\n├── DivideAndConquer\n│ ├── expressionAddOperators.java\n│ └── kthLargestElementInAnArray.java\n├── DynamicProgramming\n│ ├── bombEnemy.java\n│ ├── climbingStairs.java\n│ ├── combinationSumIV.java\n│ ├── countingBits.java\n│ ├── editDistance.java\n│ ├── houseRobber.java\n│ ├── paintFence.java\n│ ├── paintHouseII.java\n│ ├── regularExpressionMatching.java\n│ ├── sentenceScreenFitting.java\n│ ├── uniqueBinarySearchTrees.java\n│ └── wordBreak.java\n├── HashTable\n│ ├── binaryTreeVerticalOrderTraversal.java\n│ ├── findTheDifference.java\n│ ├── groupAnagrams.java\n│ ├── groupShiftedStrings.java\n│ ├── islandPerimeter.java\n│ ├── loggerRateLimiter.java\n│ ├── maximumSizeSubarraySumEqualsK.java\n│ ├── minimumWindowSubstring.java\n│ ├── sparseMatrixMultiplication.java\n│ ├── strobogrammaticNumber.java\n│ ├── twoSum.java\n│ └── uniqueWordAbbreviation.java\n├── LinkedList\n│ ├── addTwoNumbers.java\n│ ├── deleteNodeInALinkedList.java\n│ ├── mergeKSortedLists.java\n│ ├── palindromeLinkedList.java\n│ ├── plusOneLinkedList.java\n│ ├── README.md\n│ └── reverseLinkedList.java\n├── Queue\n│ └── movingAverageFromDataStream.java\n├── README.md\n├── Sort\n│ ├── meetingRoomsII.java\n│ └── meetingRooms.java\n├── Stack\n│ ├── binarySearchTreeIterator.java\n│ ├── decodeString.java\n│ ├── flattenNestedListIterator.java\n│ └── trappingRainWater.java\n├── String\n│ ├── addBinary.java\n│ ├── countAndSay.java\n│ ├── decodeWays.java\n│ ├── editDistance.java\n│ ├── integerToEnglishWords.java\n│ ├── longestPalindrome.java\n│ ├── longestSubstringWithAtMostKDistinctCharacters.java\n│ ├── minimumWindowSubstring.java\n│ ├── multiplyString.java\n│ ├── oneEditDistance.java\n│ ├── palindromePermutation.java\n│ ├── README.md\n│ ├── reverseVowelsOfAString.java\n│ ├── romanToInteger.java\n│ ├── validPalindrome.java\n│ └── validParentheses.java\n├── Tree\n│ ├── binaryTreeMaximumPathSum.java\n│ ├── binaryTreePaths.java\n│ ├── inorderSuccessorInBST.java\n│ ├── invertBinaryTree.java\n│ ├── lowestCommonAncestorOfABinaryTree.java\n│ ├── sumOfLeftLeaves.java\n│ └── validateBinarySearchTree.java\n├── Trie\n│ ├── addAndSearchWordDataStructureDesign.java\n│ ├── implementTrie.java\n│ └── wordSquares.java\n└── TwoPointers\n ├── 3Sum.java\n ├── 3SumSmaller.java\n ├── mergeSortedArray.java\n ├── minimumSizeSubarraySum.java\n ├── moveZeros.java\n ├── removeDuplicatesFromSortedArray.java\n ├── reverseString.java\n └── sortColors.java\n\n18 directories, 124 files\n```\n"
},
{
"path": "company/Company.iml",
"content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n"
},
{
"path": "company/adobe/AddDigits.java",
"content": "//Given a non-negative integer num, repeatedly add all its digits until the result has only one digit.\n\n//For example:\n//Given num = 38, the process is like: 3 + 8 = 11, 1 + 1 = 2. Since 2 has only one digit, return it.\n\n//Follow up:\n//Could you do it without any loop/recursion in O(1) runtime?\n\nclass AddDigits {\n public int addDigits(int num) {\n while(num >= 10) {\n int temp = 0;\n while(num > 0) {\n temp += num % 10;\n num /= 10;\n }\n num = temp;\n }\n \n return num;\n }\n}\n\n"
},
{
"path": "company/adobe/MajorityElement.java",
"content": "//Given an array of size n, find the majority element. The majority element is the element that appears more than ⌊ n/2 ⌋ times.\n//You may assume that the array is non-empty and the majority element always exist in the array.\n\nclass MajorityElement {\n public int majorityElement(int[] nums) {\n if(nums.length == 1) {\n return nums[0];\n }\n \n HashMap map = new HashMap();\n for(int current: nums) {\n if(map.containsKey(current) && map.get(current) + 1 > nums.length / 2) {\n return current;\n } else if(map.containsKey(current)) {\n map.put(current, map.get(current) + 1);\n } else {\n map.put(current, 1);\n }\n }\n \n //no majority element exists\n return -1;\n }\n}\n"
},
{
"path": "company/airbnb/AddTwoNumbers.java",
"content": "// You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.\n\n// You may assume the two numbers do not contain any leading zero, except the number 0 itself.\n\n// Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)\n// Output: 7 -> 0 -> 8\n\n/**\n * Definition for singly-linked list.\n * public class ListNode {\n * int val;\n * ListNode next;\n * ListNode(int x) { val = x; }\n * }\n */\npublic class AddTwoNumbers {\n public ListNode addTwoNumbers(ListNode l1, ListNode l2) {\n ListNode current1 = l1;\n ListNode current2 = l2;\n \n ListNode head = new ListNode(0);\n ListNode currentHead = head;\n \n int sum = 0;\n \n while(current1 != null || current2 != null) {\n \n sum /= 10;\n \n if(current1 != null) {\n \n sum += current1.val;\n current1 = current1.next;\n \n }\n \n if(current2 != null) {\n \n sum += current2.val;\n current2 = current2.next;\n \n }\n \n currentHead.next = new ListNode(sum % 10);\n currentHead = currentHead.next;\n \n }\n \n \n if(sum / 10 == 1) {\n \n currentHead.next = new ListNode(1);\n \n }\n \n return head.next;\n \n }\n\n}"
},
{
"path": "company/airbnb/ContainsDuplicate.java",
"content": "//Given an array of integers, find if the array contains any duplicates. Your function should return \n//true if any value appears at least twice in the array, and it should return false if every element is distinct.\n\nclass ContainsDuplicate {\n public boolean containsDuplicate(int[] nums) {\n HashMap map = new HashMap();\n for(int i: nums) {\n if(map.containsKey(i)) {\n return true;\n } else {\n map.put(i, 1);\n }\n }\n \n return false;\n }\n}\n\n"
},
{
"path": "company/airbnb/ContainsDuplicatesII.java",
"content": "//Given an array of integers and an integer k, find out whether there are two distinct indices i and \n//j in the array such that nums[i] = nums[j] and the absolute difference between i and j is at most k.\n\nclass ContainsDuplicatesII {\n public boolean containsNearbyDuplicate(int[] nums, int k) {\n HashMap map = new HashMap();\n for(int i = 0; i < nums.length; i++) {\n int current = nums[i];\n if(map.containsKey(current) && i - map.get(current) <= k) {\n return true;\n } else {\n map.put(current, i);\n }\n }\n \n return false;\n }\n}\n\n"
},
{
"path": "company/airbnb/ConvertSortedArrayToBinarySearchTree.java",
"content": "// Given an array where elements are sorted in ascending order, convert it to a height balanced BST.\n\n/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) { val = x; }\n * }\n */\npublic class Solution {\n public TreeNode sortedArrayToBST(int[] nums) {\n if(nums.length == 0) {\n return null;\n }\n \n TreeNode root = helper(nums, 0, nums.length - 1);\n \n return root;\n }\n \n private TreeNode helper(int[] nums, int start, int end) {\n if(start <= end) {\n int mid = (start + end) / 2;\n \n TreeNode current = new TreeNode(nums[mid]);\n \n current.left = helper(nums, start, mid - 1);\n current.right = helper(nums, mid + 1, end);\n \n return current;\n }\n \n return null;\n }\n}\n"
},
{
"path": "company/airbnb/HouseRobber.java",
"content": "// You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security system connected and it will automatically contact the police if two adjacent houses were broken into on the same night.\n\n// Given a list of non-negative integers representing the amount of money of each house, determine the maximum amount of money you can rob tonight without alerting the police.\n\npublic class HouseRobber {\n public int rob(int[] nums) {\n if(nums.length == 0) {\n return 0;\n }\n\n if(nums.length == 1) {\n return nums[0];\n }\n \n int[] dp = new int[nums.length];\n \n dp[0] = nums[0];\n dp[1] = nums[0] > nums[1] ? nums[0] : nums[1];\n\n for(int i = 2; i < nums.length; i++) {\n dp[i] = Math.max(dp[i - 2] + nums[i], dp[i - 1]);\n }\n \n return dp[dp.length - 1];\n }\n}\n"
},
{
"path": "company/airbnb/MergeKSortedLists.java",
"content": "// Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.\n\n/**\n * Definition for singly-linked list.\n * public class ListNode {\n * int val;\n * ListNode next;\n * ListNode(int x) { val = x; }\n * }\n */\npublic class MergeKSortedLists {\n public ListNode mergeKLists(ListNode[] lists) {\n if (lists==null||lists.length==0) {\n return null;\n }\n \n PriorityQueue queue= new PriorityQueue(lists.length,new Comparator(){\n @Override\n public int compare(ListNode o1,ListNode o2){\n if (o1.val map = new HashMap<>();\n \n for(int i = 0; i < nums.length; i++) {\n if(map.containsKey(target - nums[i])) {\n result[1] = i;\n result[0] = map.get(target - nums[i]);\n\n return result;\n }\n \n map.put(nums[i], i);\n }\n \n return result;\n }\n}\n"
},
{
"path": "company/airbnb/ValidParentheses.java",
"content": "// Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.\n\n// The brackets must close in the correct order, \"()\" and \"()[]{}\" are all valid but \"(]\" and \"([)]\" are not.\n\npublic class ValidParentheses {\n public boolean isValid(String s) {\n if(s.length() % 2 == 1) {\n return false;\n }\n \n Stack stack = new Stack();\n \n for(int i = 0; i < s.length(); i++) {\n if(s.charAt(i) == '(' || s.charAt(i) == '[' || s.charAt(i) == '{') {\n stack.push(s.charAt(i));\n } else if(s.charAt(i) == ')' && !stack.isEmpty() && stack.peek() == '(') {\n stack.pop();\n } else if(s.charAt(i) == ']' && !stack.isEmpty() && stack.peek() == '[') {\n stack.pop();\n } else if(s.charAt(i) == '}' && !stack.isEmpty() && stack.peek() == '{') {\n stack.pop();\n } else {\n return false;\n }\n }\n \n return stack.isEmpty();\n }\n}\n"
},
{
"path": "company/amazon/3Sum.java",
"content": "// Given an array S of n integers, are there elements a, b, c in S such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.\n\n// Note: The solution set must not contain duplicate triplets.\n\n// For example, given array S = [-1, 0, 1, 2, -1, -4],\n\n// A solution set is:\n// [\n// [-1, 0, 1],\n// [-1, -1, 2]\n// ]\n\npublic class 3Sum {\n public List> threeSum(int[] nums) {\n List> result = new ArrayList<>();\n \n Arrays.sort(nums);\n \n for(int i = 0; i < nums.length - 2; i++) {\n if(i > 0 && nums[i] == nums[i - 1]) {\n continue;\n }\n \n int j = i + 1;\n int k = nums.length - 1;\n int target = -nums[i];\n \n while(j < k) {\n if(nums[j] + nums[k] == target) {\n ArrayList temp = new ArrayList();\n \n temp.add(nums[i]);\n temp.add(nums[j]);\n temp.add(nums[k]);\n \n result.add(temp);\n \n j++;\n k--;\n \n while(j < k && nums[j] == nums[j - 1]) {\n j++;\n }\n \n while(j < k && nums[k] == nums[k + 1]) {\n k--;\n }\n } else if(nums[j] + nums[k] > target) {\n k--;\n } else {\n j++;\n }\n }\n }\n \n return result;\n }\n}\n"
},
{
"path": "company/amazon/AddTwoNumbers.java",
"content": "// You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.\n\n// You may assume the two numbers do not contain any leading zero, except the number 0 itself.\n\n// Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)\n// Output: 7 -> 0 -> 8\n\n/**\n * Definition for singly-linked list.\n * public class ListNode {\n * int val;\n * ListNode next;\n * ListNode(int x) { val = x; }\n * }\n */\npublic class AddTwoNumbers {\n public ListNode addTwoNumbers(ListNode l1, ListNode l2) {\n ListNode current1 = l1;\n ListNode current2 = l2;\n \n ListNode head = new ListNode(0);\n ListNode currentHead = head;\n \n int sum = 0;\n \n while(current1 != null || current2 != null) {\n sum /= 10;\n \n if(current1 != null) {\n sum += current1.val;\n current1 = current1.next;\n }\n \n if(current2 != null) {\n sum += current2.val;\n current2 = current2.next;\n }\n\n currentHead.next = new ListNode(sum % 10);\n currentHead = currentHead.next;\n }\n \n if(sum / 10 == 1) {\n currentHead.next = new ListNode(1);\n }\n \n return head.next;\n }\n}\n"
},
{
"path": "company/amazon/BestTimeToBuyAndSellStock.java",
"content": "// Say you have an array for which the ith element is the price of a given stock on day i.\n\n// If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock), design an algorithm to find the maximum profit.\n\n// Example 1:\n// Input: [7, 1, 5, 3, 6, 4]\n// Output: 5\n\n// max. difference = 6-1 = 5 (not 7-1 = 6, as selling price needs to be larger than buying price)\n// Example 2:\n// Input: [7, 6, 4, 3, 1]\n// Output: 0\n\n// In this case, no transaction is done, i.e. max profit = 0.\n\npublic class BestTimeToBuyAndSellStock {\n public int maxProfit(int[] prices) {\n //Kadane's algorithm\n if(prices.length == 0) {\n return 0;\n }\n \n int max = 0;\n int min = prices[0];\n \n for(int i = 1; i < prices.length; i++) {\n if(prices[i] > min) {\n max = Math.max(max, prices[i] - min);\n } else {\n min = prices[i];\n }\n }\n \n return max;\n }\n}\n"
},
{
"path": "company/amazon/BinaryTreeLevelOrderTraversal.java",
"content": "// Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).\n\n// For example:\n// Given binary tree [3,9,20,null,null,15,7],\n// 3\n// / \\\n// 9 20\n// / \\\n// 15 7\n// return its level order traversal as:\n// [\n// [3],\n// [9,20],\n// [15,7]\n// ]\n\n/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) { val = x; }\n * }\n */\npublic class BinaryTreeLevelOrderTraversal {\n public List> levelOrder(TreeNode root) {\n List> result = new ArrayList>();\n\n if(root == null) {\n return result;\n }\n \n Queue queue = new LinkedList();\n \n queue.add(root);\n \n List tempList = new ArrayList();\n tempList.add(root.val);\n result.add(tempList);\n \n while(!queue.isEmpty()) {\n Queue currentLevel = new LinkedList();\n \n List list = new ArrayList();\n \n while(!queue.isEmpty()) {\n TreeNode current = queue.remove();\n \n if(current.left != null) {\n currentLevel.add(current.left);\n list.add(current.left.val);\n }\n \n if(current.right != null) {\n currentLevel.add(current.right);\n list.add(current.right.val);\n }\n }\n \n if(list.size() > 0) {\n result.add(list);\n }\n\n queue = currentLevel;\n }\n \n return result;\n }\n}\n"
},
{
"path": "company/amazon/EncodeAndDecodeTinyURL.java",
"content": "//TinyURL is a URL shortening service where you enter a URL such as https://leetcode.com/problems/design-tinyurl \n//and it returns a short URL such as http://tinyurl.com/4e9iAk.\n//\n//Design the encode and decode methods for the TinyURL service. There is no restriction on how your \n//encode/decode algorithm should work. You just need to ensure that a URL can be encoded to a tiny URL \n//and the tiny URL can be decoded to the original URL.\n\npublic class EncodeAndDecodeTinyURL {\n HashMap map = new HashMap();\n String characters = \"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\";\n int count = 1;\n\n public String getKey() {\n String key = \"\";\n while(count > 0) {\n count--;\n key += characters.charAt(count);\n count /= characters.length();\n }\n \n return key;\n }\n \n // Encodes a URL to a shortened URL.\n public String encode(String longUrl) {\n String key = getKey();\n map.put(key, longUrl);\n count++;\n \n return \"http://tinyurl.com/\" + key;\n }\n\n // Decodes a shortened URL to its original URL.\n public String decode(String shortUrl) {\n return map.get(shortUrl.replace(\"http://tinyurl.com/\", \"\"));\n }\n}\n\n// Your Codec object will be instantiated and called as such:\n// Codec codec = new Codec();\n// codec.decode(codec.encode(url));\n"
},
{
"path": "company/amazon/FirstUniqueCharacterInAString.java",
"content": "//Given a string, find the first non-repeating character in it and return it's index. If it doesn't exist, return -1.\n//\n//Examples:\n//\n//s = \"leetcode\"\n//return 0.\n//\n//s = \"loveleetcode\",\n//return 2.\n//Note: You may assume the string contain only lowercase letters.\n\nclass FirstUniqueCharacterInAString {\n public int firstUniqChar(String s) {\n HashMap characters = new HashMap();\n for(int i = 0; i < s.length(); i++) {\n char current = s.charAt(i);\n if(characters.containsKey(current)) {\n characters.put(current, -1);\n } else {\n characters.put(current, i);\n }\n }\n \n int min = Integer.MAX_VALUE;\n for(char c: characters.keySet()) {\n if(characters.get(c) > -1 && characters.get(c) < min) {\n min = characters.get(c);\n }\n }\n \n return min == Integer.MAX_VALUE ? -1 : min;\n \n }\n}\n"
},
{
"path": "company/amazon/GroupAnagrams.java",
"content": "// Given an array of strings, group anagrams together.\n\n// For example, given: [\"eat\", \"tea\", \"tan\", \"ate\", \"nat\", \"bat\"], \n// Return:\n\n// [\n// [\"ate\", \"eat\",\"tea\"],\n// [\"nat\",\"tan\"],\n// [\"bat\"]\n// ]\n// Note: All inputs will be in lower-case.\n\npublic class GroupAnagrams {\n public List> groupAnagrams(String[] strs) {\n if(strs == null || strs.length == 0) {\n return new ArrayList>();\n }\n \n HashMap> map = new HashMap>();\n \n Arrays.sort(strs);\n \n for(String s : strs) {\n char[] characters = s.toCharArray();\n \n Arrays.sort(characters);\n \n String key = String.valueOf(characters);\n \n if(!map.containsKey(key)) {\n map.put(key, new ArrayList());\n }\n \n map.get(key).add(s);\n }\n \n return new ArrayList>(map.values());\n }\n}\n"
},
{
"path": "company/amazon/InsertDeleteGetRandomO1.java",
"content": "//Design a data structure that supports all following operations in average O(1) time.\n\n//insert(val): Inserts an item val to the set if not already present.\n//remove(val): Removes an item val from the set if present.\n//getRandom: Returns a random element from current set of elements. Each element must have the same probability of being returned.\n\n//Example:\n// Init an empty set.\n//RandomizedSet randomSet = new RandomizedSet();\n\n// Inserts 1 to the set. Returns true as 1 was inserted successfully.\n//randomSet.insert(1);\n\n// Returns false as 2 does not exist in the set.\n//randomSet.remove(2);\n\n// Inserts 2 to the set, returns true. Set now contains [1,2].\n//randomSet.insert(2);\n\n// getRandom should return either 1 or 2 randomly.\n//randomSet.getRandom();\n\n// Removes 1 from the set, returns true. Set now contains [2].\n//randomSet.remove(1);\n\n// 2 was already in the set, so return false.\n//randomSet.insert(2);\n\n// Since 2 is the only number in the set, getRandom always return 2.\n//randomSet.getRandom();\n\nclass RandomizedSet {\n HashMap map;\n ArrayList values;\n\n /** Initialize your data structure here. */\n public RandomizedSet() {\n map = new HashMap();\n values = new ArrayList();\n }\n \n /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */\n public boolean insert(int val) {\n if(!map.containsKey(val)) {\n map.put(val, val);\n values.add(val);\n return true;\n }\n else {\n return false;\n }\n }\n \n /** Removes a value from the set. Returns true if the set contained the specified element. */\n public boolean remove(int val) {\n if(map.containsKey(val)) {\n map.remove(val);\n values.remove(values.indexOf(val));\n return true;\n }\n return false;\n }\n \n /** Get a random element from the set. */\n public int getRandom() {\n int random = (int)(Math.random() * values.size());\n int valueToReturn = values.get(random);\n return map.get(valueToReturn);\n }\n}\n\n/**\n * Your RandomizedSet object will be instantiated and called as such:\n * RandomizedSet obj = new RandomizedSet();\n * boolean param_1 = obj.insert(val);\n * boolean param_2 = obj.remove(val);\n * int param_3 = obj.getRandom();\n */\n\n"
},
{
"path": "company/amazon/KthLargestElementInAnArray.java",
"content": "// Find the kth largest element in an unsorted array. Note that it is the kth largest element in the sorted order, not the kth distinct element.\n\n// For example,\n// Given [3,2,1,5,6,4] and k = 2, return 5.\n\n// Note: \n// You may assume k is always valid, 1 ≤ k ≤ array's length.\n\npublic class KthLargestElementInAnArray {\n public int findKthLargest(int[] nums, int k) {\n int length = nums.length;\n\n Arrays.sort(nums);\n\n return nums[length - k];\n }\n}\n"
},
{
"path": "company/amazon/LetterCombinationsOfAPhoneNumber.java",
"content": "// Given a digit string, return all possible letter combinations that the number could represent.\n\n// A mapping of digit to letters (just like on the telephone buttons) is given below.\n\n// 2 - abc\n// 3 - def\n// 4 - ghi\n// 5 - jkl\n// 6 - mno\n// 7 - pqrs\n// 8 - tuv\n// 9 - wxyz\n\n// Input:Digit string \"23\"\n// Output: [\"ad\", \"ae\", \"af\", \"bd\", \"be\", \"bf\", \"cd\", \"ce\", \"cf\"].\n\nclass LetterCombinationsOfAPhoneNumber {\n public List letterCombinations(String digits) {\n List result = new ArrayList();\n \n if(digits == null || digits.length() == 0) {\n return result;\n }\n \n String[] mapping = {\n \"0\",\n \"1\",\n \"abc\",\n \"def\",\n \"ghi\",\n \"jkl\",\n \"mno\",\n \"pqrs\",\n \"tuv\",\n \"wxyz\"\n };\n \n letterCombinationsRecursive(result, digits, \"\", 0, mapping);\n \n return result;\n }\n \n public void letterCombinationsRecursive(List result, String digits, String current, int index, String[] mapping) {\n if(index == digits.length()) {\n result.add(current);\n return;\n }\n \n String letters = mapping[digits.charAt(index) - '0'];\n for(int i = 0; i < letters.length(); i++) {\n letterCombinationsRecursive(result, digits, current + letters.charAt(i), index + 1, mapping);\n }\n }\n}\n"
},
{
"path": "company/amazon/LinkedListCycle.java",
"content": "//Given a linked list, determine if it has a cycle in it.\n//Follow up:\n//Can you solve it without using extra space?\n/**\n * Definition for singly-linked list.\n * class ListNode {\n * int val;\n * ListNode next;\n * ListNode(int x) {\n * val = x;\n * next = null;\n * }\n * }\n */\npublic class Solution {\n public boolean hasCycle(ListNode head) {\n if(head == null || head.next == null) {\n return false;\n }\n \n ListNode slow = head;\n ListNode fast = head.next;\n while(fast != null && fast.next != null && fast != slow) {\n slow = slow.next;\n fast = fast.next.next;\n }\n \n return fast == slow;\n }\n}\n\n"
},
{
"path": "company/amazon/LongestPalindromicSubstring.java",
"content": "//Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.\n\n//Example:\n//Input: \"babad\"\n//Output: \"bab\"\n\n//Note: \"aba\" is also a valid answer.\n\n//Example:\n//Input: \"cbbd\"\n//Output: \"bb\"\n\nclass LongestPalindromicSubstring {\n public String longestPalindrome(String s) {\n if(s == null || s.length() == 0) {\n return \"\";\n }\n \n String longestPalindromicSubstring = \"\";\n for(int i = 0; i < s.length(); i++) {\n for(int j = i + 1; j <= s.length(); j++) {\n if(j - i > longestPalindromicSubstring.length() && isPalindrome(s.substring(i, j))) {\n longestPalindromicSubstring = s.substring(i, j);\n }\n }\n }\n \n return longestPalindromicSubstring;\n }\n \n public boolean isPalindrome(String s) {\n int i = 0;\n int j = s.length() - 1;\n while(i <= j) {\n if(s.charAt(i++) != s.charAt(j--)) {\n return false;\n }\n }\n \n return true;\n }\n}\n"
},
{
"path": "company/amazon/LowestCommonAncestorOfABinaryTree.java",
"content": "// Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.\n\n// According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes v and w as the lowest node in T that has both v and w as descendants (where we allow a node to be a descendant of itself).”\n\n// _______3______\n// / \\\n// ___5__ ___1__\n// / \\ / \\\n// 6 _2 0 8\n// / \\\n// 7 4\n// For example, the lowest common ancestor (LCA) of nodes 5 and 1 is 3. Another example is LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.\n\n/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) { val = x; }\n * }\n */\npublic class LowestCommonAncestorOfABinaryTree {\n public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {\n if(root == null || root == p || root == q) {\n return root;\n }\n \n TreeNode left = lowestCommonAncestor(root.left, p, q);\n TreeNode right = lowestCommonAncestor(root.right, p, q);\n \n if(left != null && right != null) {\n return root;\n }\n \n return left == null ? right : left;\n }\n}\n"
},
{
"path": "company/amazon/MergeKSortedLists.java",
"content": "// Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.\n\n/**\n * Definition for singly-linked list.\n * public class ListNode {\n * int val;\n * ListNode next;\n * ListNode(int x) { val = x; }\n * }\n */\npublic class MergeKSortedLists {\n public ListNode mergeKLists(ListNode[] lists) {\n if (lists==null||lists.length==0) {\n return null;\n }\n \n PriorityQueue queue= new PriorityQueue(lists.length,new Comparator(){\n @Override\n public int compare(ListNode o1,ListNode o2){\n if (o1.val= grid.length || j < 0 || j >= grid[0].length || grid[i][j] == '0') {\n return 0;\n }\n \n //set current index to 0\n grid[i][j] = '0';\n \n // sink all neighbors of current index\n sink(grid, i + 1, j);\n sink(grid, i - 1, j);\n sink(grid, i, j + 1);\n sink(grid, i, j - 1);\n \n //increment number of islands\n return 1;\n }\n}\n"
},
{
"path": "company/amazon/PalindromeLinkedList.java",
"content": "/**\n * Definition for singly-linked list.\n * public class ListNode {\n * int val;\n * ListNode next;\n * ListNode(int x) { val = x; }\n * }\n */\npublic class PalindromeLinkedList {\n public boolean isPalindrome(ListNode head) {\n if(head == null || head.next == null) {\n return true;\n }\n \n Stack stack = new Stack();\n \n ListNode fast = head;\n ListNode slow = head;\n\n while(fast != null && fast.next != null) {\n stack.push(slow.val);\n fast = fast.next.next;\n slow = slow.next;\n }\n \n if(fast != null) {\n slow = slow.next;\n }\n \n while(slow != null) {\n if(stack.pop() != slow.val) {\n return false;\n }\n\n slow = slow.next;\n }\n \n return true;\n }\n}\n"
},
{
"path": "company/amazon/ProductOfArrayExceptSelf.java",
"content": "// Given an array of n integers where n > 1, nums, return an array output such that output[i] is equal to the product of all the elements of nums except nums[i].\n\n// Solve it without division and in O(n).\n\n// For example, given [1,2,3,4], return [24,12,8,6].\n\n// Follow up:\n// Could you solve it with constant space complexity? (Note: The output array does not count as extra space for the purpose of space complexity analysis.)\n\npublic class ProductOfArrayExceptSelf {\n public int[] productExceptSelf(int[] nums) {\n int n = nums.length;\n int[] result = new int[n];\n int left = 1;\n \n for(int i = 0; i < nums.length; i++) {\n if(i > 0) {\n left *= nums[i - 1];\n }\n \n result[i] = left;\n }\n \n int right = 1;\n \n for(int i = n - 1; i >= 0; i--) {\n if(i < n - 1) {\n right *= nums[i + 1];\n }\n \n result[i] *= right;\n }\n \n return result;\n }\n}\n"
},
{
"path": "company/amazon/ReverseLinkedList.java",
"content": "// Reverse a singly linked list.\n\n/**\n * Definition for singly-linked list.\n * public class ListNode {\n * int val;\n * ListNode next;\n * ListNode(int x) { val = x; }\n * }\n */\npublic class ReverseLinkedList {\n public ListNode reverseList(ListNode head) {\n if(head == null) {\n return head;\n }\n \n ListNode newHead = null;\n \n while(head != null) {\n ListNode next = head.next;\n head.next = newHead;\n newHead = head;\n head = next;\n }\n \n return newHead;\n }\n}\n"
},
{
"path": "company/amazon/RotateImage.java",
"content": "// You are given an n x n 2D matrix representing an image.\n\n// Rotate the image by 90 degrees (clockwise).\n\n// Follow up:\n // Could you do this in-place?\n\npublic class RotateImage {\n public void rotate(int[][] matrix) {\n for(int i = 0; i < matrix.length; i++) {\n for(int j = 0; j < i; j++) {\n int temp = matrix[i][j];\n matrix[i][j] = matrix[j][i];\n matrix[j][i] = temp;\n }\n }\n \n for(int i = 0; i < matrix.length; i++) {\n for(int j = 0; j < matrix[0].length / 2; j++) {\n int temp = matrix[i][j];\n matrix[i][j] = matrix[i][matrix[0].length - 1 - j];\n matrix[i][matrix[0].length - 1 - j] = temp;\n }\n }\n }\n}\n"
},
{
"path": "company/amazon/Subsets.java",
"content": "// Given a set of distinct integers, nums, return all possible subsets.\n\n// Note: The solution set must not contain duplicate subsets.\n\n// For example,\n// If nums = [1,2,3], a solution is:\n\n// [\n// [3],\n// [1],\n// [2],\n// [1,2,3],\n// [1,3],\n// [2,3],\n// [1,2],\n// []\n// ]\n\npublic class Subsets {\n public List> subsets(int[] nums) {\n List> result = new ArrayList<>();\n \n recurse(result, nums, new Stack<>(), 0);\n \n return result;\n }\n \n \n private void recurse(List> result, int[] nums, Stack path, int position) {\n if(position == nums.length) {\n result.add(new ArrayList<>(path));\n\n return;\n }\n \n path.push(nums[position]);\n\n recurse(result, nums, path, position + 1);\n \n path.pop();\n \n recurse(result, nums, path, position + 1);\n }\n}\n"
},
{
"path": "company/amazon/TrappingRainWater.java",
"content": "// 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.\n\n// For example, \n// Given [0,1,0,2,1,0,1,3,2,1,2,1], return 6.\n\npublic class TrappingRainWater {\n public int trap(int[] height) {\n int water = 0;\n \n int leftIndex = 0;\n int rightIndex = height.length - 1;\n \n int leftMax = 0;\n int rightMax = 0;\n \n while(leftIndex <= rightIndex) {\n leftMax = Math.max(leftMax, height[leftIndex]);\n rightMax = Math.max(rightMax, height[rightIndex]);\n \n if(leftMax < rightMax) {\n water += leftMax - height[leftIndex];\n leftIndex++;\n } else {\n water += rightMax - height[rightIndex];\n rightIndex--;\n }\n }\n \n return water;\n }\n}\n\n"
},
{
"path": "company/amazon/TwoSum.java",
"content": "// Given an array of integers, return indices of the two numbers such that they add up to a specific target.\n\n// You may assume that each input would have exactly one solution, and you may not use the same element twice.\n\n// Example:\n// Given nums = [2, 7, 11, 15], target = 9,\n\n// Because nums[0] + nums[1] = 2 + 7 = 9,\n// return [0, 1].\n\npublic class TwoSum {\n public int[] twoSum(int[] nums, int target) {\n int[] result = new int[2];\n \n HashMap map = new HashMap<>();\n \n for(int i = 0; i < nums.length; i++) {\n if(map.containsKey(target - nums[i])) {\n result[1] = i;\n result[0] = map.get(target - nums[i]);\n\n return result;\n }\n \n map.put(nums[i], i);\n }\n \n return result;\n }\n}\n"
},
{
"path": "company/amazon/ValidParentheses.java",
"content": "// Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.\n\n// The brackets must close in the correct order, \"()\" and \"()[]{}\" are all valid but \"(]\" and \"([)]\" are not.\n\npublic class ValidParentheses {\n public boolean isValid(String s) {\n if(s.length() % 2 == 1) {\n return false;\n }\n \n Stack stack = new Stack();\n \n for(int i = 0; i < s.length(); i++) {\n if(s.charAt(i) == '(' || s.charAt(i) == '[' || s.charAt(i) == '{') {\n stack.push(s.charAt(i));\n } else if(s.charAt(i) == ')' && !stack.isEmpty() && stack.peek() == ')') {\n stack.pop();\n } else if(s.charAt(i) == ']' && !stack.isEmpty() && stack.peek() == ']') {\n stack.pop();\n } else if(s.charAt(i) == '}' && !stack.isEmpty() && stack.peek() == '}') {\n stack.pop();\n } else {\n return false;\n }\n }\n \n return stack.isEmpty();\n }\n}\n"
},
{
"path": "company/amazon/ValidateBinarySearchTree.java",
"content": "// Given a binary tree, determine if it is a valid binary search tree (BST).\n\n// Assume a BST is defined as follows:\n\n// The left subtree of a node contains only nodes with keys less than the node's key.\n// The right subtree of a node contains only nodes with keys greater than the node's key.\n// Both the left and right subtrees must also be binary search trees.\n// Example 1:\n// 2\n// / \\\n// 1 3\n// Binary tree [2,1,3], return true.\n// Example 2:\n// 1\n// / \\\n// 2 3\n// Binary tree [1,2,3], return false.\n\n/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) { val = x; }\n * }\n */\npublic class ValidateBinarySearchTree {\n public boolean isValidBST(TreeNode root) {\n if(root == null) {\n return true;\n }\n \n return validBSTRecursive(root, Long.MIN_VALUE, Long.MAX_VALUE);\n }\n \n public boolean validBSTRecursive(TreeNode root, long minValue, long maxValue) {\n if(root == null) {\n return true;\n } else if(root.val >= maxValue || root.val <= minValue) {\n return false;\n } else {\n return validBSTRecursive(root.left, minValue, root.val) && validBSTRecursive(root.right, root.val, maxValue);\n }\n }\n}\n"
},
{
"path": "company/amazon/WordBreak.java",
"content": "// Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, determine if s can be segmented into a space-separated sequence of one or more dictionary words. You may assume the dictionary does not contain duplicate words.\n\n// For example, given\n// s = \"leetcode\",\n// dict = [\"leet\", \"code\"].\n\n// Return true because \"leetcode\" can be segmented as \"leet code\".\n\npublic class WordBreak {\n public boolean wordBreak(String s, Set wordDict) {\n boolean[] dp = new boolean[s.length() + 1];\n \n dp[0] = true;\n \n for(int i = 1; i <= s.length(); i++) {\n for(int j = 0; j < i; j++) {\n if(dp[j] && wordDict.contains(s.substring(j, i))) {\n dp[i] = true;\n break;\n }\n }\n }\n \n return dp[s.length()];\n }\n}\n"
},
{
"path": "company/apple/ReverseWordsInAString.java",
"content": "//Given an input string, reverse the string word by word.\n//For example,\n//Given s = \"the sky is blue\",\n//return \"blue is sky the\".\n\npublic class ReverseWordsInAString {\n public String reverseWords(String s) {\n String[] words = s.trim().split(\"\\\\s+\");\n String result = \"\";\n for(int i = words.length - 1; i > 0; i--) {\n result += words[i] + \" \";\n }\n \n return result + words[0];\n }\n}\n\n"
},
{
"path": "company/apple/ValidSudoku.java",
"content": "//Determine if a Sudoku is valid, according to: Sudoku Puzzles - The Rules. (http://sudoku.com.au/TheRules.aspx)\n//The Sudoku board could be partially filled, where empty cells are filled with the character '.'.\n//A partially filled sudoku which is valid.\n\n//Note:\n//A valid Sudoku board (partially filled) is not necessarily solvable. Only the filled cells need to be validated.\n\nclass ValidSudoku {\n public boolean isValidSudoku(char[][] board) {\n for(int i = 0; i < board.length; i++){\n HashSet rows = new HashSet();\n HashSet columns = new HashSet();\n HashSet box = new HashSet();\n for (int j = 0; j < board[0].length; j++){\n if(board[i][j] != '.' && !rows.add(board[i][j])) {\n return false;\n }\n if(board[j][i]!='.' && !columns.add(board[j][i])) {\n return false;\n }\n int rowIndex = (i / 3) * 3;\n int columnIndex = (i % 3) * 3;\n if(board[rowIndex + j / 3][columnIndex + j % 3] != '.' && !box.add(board[rowIndex + j / 3][columnIndex + j % 3])) {\n return false;\n }\n }\n }\n return true;\n }\n}\n\n"
},
{
"path": "company/bloomberg/FirstUniqueCharacterInAString.java",
"content": "//Given a string, find the first non-repeating character in it and return it's index. If it doesn't exist, return -1.\n//\n//Examples:\n//\n//s = \"leetcode\"\n//return 0.\n//\n//s = \"loveleetcode\",\n//return 2.\n//Note: You may assume the string contain only lowercase letters.\n\nclass FirstUniqueCharacterInAString {\n public int firstUniqChar(String s) {\n HashMap characters = new HashMap();\n for(int i = 0; i < s.length(); i++) {\n char current = s.charAt(i);\n if(characters.containsKey(current)) {\n characters.put(current, -1);\n } else {\n characters.put(current, i);\n }\n }\n \n int min = Integer.MAX_VALUE;\n for(char c: characters.keySet()) {\n if(characters.get(c) > -1 && characters.get(c) < min) {\n min = characters.get(c);\n }\n }\n \n return min == Integer.MAX_VALUE ? -1 : min;\n \n }\n}\n"
},
{
"path": "company/bloomberg/LinkedListCycle.java",
"content": "//Given a linked list, determine if it has a cycle in it.\n//Follow up:\n//Can you solve it without using extra space?\n/**\n * Definition for singly-linked list.\n * class ListNode {\n * int val;\n * ListNode next;\n * ListNode(int x) {\n * val = x;\n * next = null;\n * }\n * }\n */\npublic class Solution {\n public boolean hasCycle(ListNode head) {\n if(head == null || head.next == null) {\n return false;\n }\n \n ListNode slow = head;\n ListNode fast = head.next;\n while(fast != null && fast.next != null && fast != slow) {\n slow = slow.next;\n fast = fast.next.next;\n }\n \n return fast == slow;\n }\n}\n\n"
},
{
"path": "company/bloomberg/LongestPalindromicSubstring.java",
"content": "//Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.\n\n//Example:\n//Input: \"babad\"\n//Output: \"bab\"\n\n//Note: \"aba\" is also a valid answer.\n\n//Example:\n//Input: \"cbbd\"\n//Output: \"bb\"\n\nclass LongestPalindromicSubstring {\n public String longestPalindrome(String s) {\n if(s == null || s.length() == 0) {\n return \"\";\n }\n \n String longestPalindromicSubstring = \"\";\n for(int i = 0; i < s.length(); i++) {\n for(int j = i + 1; j <= s.length(); j++) {\n if(j - i > longestPalindromicSubstring.length() && isPalindrome(s.substring(i, j))) {\n longestPalindromicSubstring = s.substring(i, j);\n }\n }\n }\n \n return longestPalindromicSubstring;\n }\n \n public boolean isPalindrome(String s) {\n int i = 0;\n int j = s.length() - 1;\n while(i <= j) {\n if(s.charAt(i++) != s.charAt(j--)) {\n return false;\n }\n }\n \n return true;\n }\n}\n\n"
},
{
"path": "company/bloomberg/MinStack.java",
"content": "//Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.\n//push(x) -- Push element x onto stack.\n//pop() -- Removes the element on top of the stack.\n//top() -- Get the top element.\n//getMin() -- Retrieve the minimum element in the stack.\n\n/**\n * Your MinStack object will be instantiated and called as such:\n * MinStack obj = new MinStack();\n * obj.push(x);\n * obj.pop();\n * int param_3 = obj.top();\n * int param_4 = obj.getMin();\n */\nclass MinStack {\n class Node {\n int data;\n int min;\n Node next;\n \n public Node(int data, int min) {\n this.data = data;\n this.min = min;\n this.next = null;\n }\n }\n Node head;\n \n /** initialize your data structure here. */\n public MinStack() {\n \n }\n \n public void push(int x) {\n if(head == null) {\n head = new Node(x, x);\n } else {\n Node newNode = new Node(x, Math.min(x, head.min));\n newNode.next = head;\n head = newNode;\n }\n }\n \n public void pop() {\n head = head.next;\n }\n \n public int top() {\n return head.data;\n }\n \n public int getMin() {\n return head.min;\n }\n}\n"
},
{
"path": "company/bloomberg/ReverseWordsInAString.java",
"content": "//Given an input string, reverse the string word by word.\n//For example,\n//Given s = \"the sky is blue\",\n//return \"blue is sky the\".\n\npublic class ReverseWordsInAString {\n public String reverseWords(String s) {\n String[] words = s.trim().split(\"\\\\s+\");\n String result = \"\";\n for(int i = words.length - 1; i > 0; i--) {\n result += words[i] + \" \";\n }\n \n return result + words[0];\n }\n}\n\n"
},
{
"path": "company/bloomberg/UniquePaths.java",
"content": "//A robot is located at the top-left corner of a m x n grid (marked 'Start' in the diagram below).\n//\n//The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).\n//\n//How many possible unique paths are there?\n\nclass UniquePaths {\n public int uniquePaths(int m, int n) {\n Integer[][] map = new Integer[m][n];\n \n //only 1 way to get to ith row, 0th column (move down)\n for(int i = 0; i < m; i++){\n map[i][0] = 1;\n }\n \n //only 1 way to get to ith column, 0th row (move right)\n for(int j= 0; j < n; j++){\n map[0][j]=1;\n }\n \n //x ways to get to ith row, jth column (# of ways to get to\n //ith - 1 row, jth column + # of ways to get to jth - 1 column\n //ith column\n for(int i = 1;i < m; i++){\n for(int j = 1; j < n; j++){\n map[i][j] = map[i - 1][j] + map[i][j - 1];\n }\n }\n\n return map[m - 1][n - 1];\n }\n}\n\n"
},
{
"path": "company/facebook/3Sum.java",
"content": "// Given an array S of n integers, are there elements a, b, c in S such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.\n\n// Note: The solution set must not contain duplicate triplets.\n\n// For example, given array S = [-1, 0, 1, 2, -1, -4],\n\n// A solution set is:\n// [\n// [-1, 0, 1],\n// [-1, -1, 2]\n// ]\n\npublic class 3Sum {\n public List> threeSum(int[] nums) {\n List> result = new ArrayList<>();\n \n Arrays.sort(nums);\n \n for(int i = 0; i < nums.length - 2; i++) {\n if(i > 0 && nums[i] == nums[i - 1]) {\n continue;\n }\n \n int j = i + 1;\n int k = nums.length - 1;\n int target = -nums[i];\n \n while(j < k) {\n if(nums[j] + nums[k] == target) {\n ArrayList temp = new ArrayList();\n \n temp.add(nums[i]);\n temp.add(nums[j]);\n temp.add(nums[k]);\n \n result.add(temp);\n \n j++;\n k--;\n \n while(j < k && nums[j] == nums[j - 1]) {\n j++;\n }\n\n while(j < k && nums[k] == nums[k + 1]) {\n k--;\n }\n } else if(nums[j] + nums[k] > target) {\n k--;\n } else {\n j++;\n }\n }\n }\n \n return result;\n }\n}\n"
},
{
"path": "company/facebook/AddAndSearchWordDataStructureDesign.java",
"content": "// Design a data structure that supports the following two operations:\n\n// void addWord(word)\n// bool search(word)\n// search(word) can search a literal word or a regular expression string containing only letters a-z or .. A . means it can represent any one letter.\n\n// For example:\n\n// addWord(\"bad\")\n// addWord(\"dad\")\n// addWord(\"mad\")\n// search(\"pad\") -> false\n// search(\"bad\") -> true\n// search(\".ad\") -> true\n// search(\"b..\") -> true\n\n// Note:\n // You may assume that all words are consist of lowercase letters a-z.\n\npublic class AddAndSearchWordDataStructure {\n public class TrieNode {\n public TrieNode[] children = new TrieNode[26];\n public String item = \"\";\n }\n \n private TrieNode root = new TrieNode();\n\n public void addWord(String word) {\n TrieNode node = root;\n\n for (char c : word.toCharArray()) {\n if (node.children[c - 'a'] == null) {\n node.children[c - 'a'] = new TrieNode();\n }\n\n node = node.children[c - 'a'];\n }\n\n node.item = word;\n }\n\n public boolean search(String word) {\n return match(word.toCharArray(), 0, root);\n }\n \n private boolean match(char[] chs, int k, TrieNode node) {\n if (k == chs.length) {\n return !node.item.equals(\"\"); \n }\n\n if (chs[k] != '.') {\n return node.children[chs[k] - 'a'] != null && match(chs, k + 1, node.children[chs[k] - 'a']);\n } else {\n for (int i = 0; i < node.children.length; i++) {\n if (node.children[i] != null) {\n if (match(chs, k + 1, node.children[i])) {\n return true;\n }\n }\n }\n }\n\n return false;\n }\n}\n"
},
{
"path": "company/facebook/AddBinary.java",
"content": "// Given two binary strings, return their sum (also a binary string).\n\n// For example,\n// a = \"11\"\n// b = \"1\"\n// Return \"100\"\n\npublic class AddBinary {\n public String addBinary(String a, String b) {\n StringBuilder result = new StringBuilder();\n \n int carry = 0;\n \n int i = a.length() - 1;\n int j = b.length() - 1;\n \n while(i >= 0 || j >= 0) {\n int sum = carry;\n\n if(i >= 0) {\n sum += a.charAt(i--) - '0';\n }\n\n if(j >= 0) {\n sum += b.charAt(j--) - '0';\n }\n\n result.append(sum % 2);\n carry = sum / 2;\n }\n \n if(carry != 0) {\n result.append(carry);\n }\n\n return result.reverse().toString();\n }\n}\n"
},
{
"path": "company/facebook/BestTimeToBuyAndSellStock.java",
"content": "// Say you have an array for which the ith element is the price of a given stock on day i.\n\n// If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock), design an algorithm to find the maximum profit.\n\n// Example 1:\n// Input: [7, 1, 5, 3, 6, 4]\n// Output: 5\n\n// max. difference = 6-1 = 5 (not 7-1 = 6, as selling price needs to be larger than buying price)\n// Example 2:\n// Input: [7, 6, 4, 3, 1]\n// Output: 0\n\n// In this case, no transaction is done, i.e. max profit = 0.\n\npublic class BestTimeToBuyAndSellStock {\n public int maxProfit(int[] prices) {\n //Kadane's algorithm\n if(prices.length == 0) {\n return 0;\n }\n \n int max = 0;\n int min = prices[0];\n \n for(int i = 1; i < prices.length; i++) {\n if(prices[i] > min) {\n max = Math.max(max, prices[i] - min);\n } else {\n min = prices[i];\n }\n }\n \n return max;\n }\n}\n"
},
{
"path": "company/facebook/BinarySearchTreeIterator.java",
"content": "// Implement an iterator over a binary search tree (BST). Your iterator will be initialized with the root node of a BST.\n\n// Calling next() will return the next smallest number in the BST.\n\n// Note: next() and hasNext() should run in average O(1) time and uses O(h) memory, where h is the height of the tree.\n\n/**\n * Definition for binary tree\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) { val = x; }\n * }\n */\n\npublic class BinarySearchTreeIterator {\n Stack stack;\n\n public BSTIterator(TreeNode root) {\n stack = new Stack();\n \n while(root != null) {\n stack.push(root);\n root = root.left;\n }\n }\n\n /** @return whether we have a next smallest number */\n public boolean hasNext() {\n return stack.isEmpty() ? false : true;\n }\n\n /** @return the next smallest number */\n public int next() {\n TreeNode nextSmallest = stack.pop();\n TreeNode addToStack = nextSmallest.right;\n \n while(addToStack != null) {\n stack.add(addToStack);\n addToStack = addToStack.left;\n }\n \n return nextSmallest.val;\n }\n}\n\n/**\n * Your BSTIterator will be called like this:\n * BSTIterator i = new BSTIterator(root);\n * while (i.hasNext()) v[f()] = i.next();\n */\n"
},
{
"path": "company/facebook/BinaryTreeLevelOrderTraversal.java",
"content": "// Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).\n\n// For example:\n// Given binary tree [3,9,20,null,null,15,7],\n// 3\n// / \\\n// 9 20\n// / \\\n// 15 7\n// return its level order traversal as:\n// [\n// [3],\n// [9,20],\n// [15,7]\n// ]\n\n/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) { val = x; }\n * }\n */\npublic class BinaryTreeLevelOrderTraversal {\n public List> levelOrder(TreeNode root) {\n List> result = new ArrayList>();\n \n if(root == null) {\n return result;\n }\n \n Queue queue = new LinkedList();\n \n queue.add(root);\n \n List tempList = new ArrayList();\n tempList.add(root.val);\n result.add(tempList);\n \n while(!queue.isEmpty()) {\n Queue currentLevel = new LinkedList();\n \n List list = new ArrayList();\n \n while(!queue.isEmpty()) {\n TreeNode current = queue.remove();\n \n if(current.left != null) {\n currentLevel.add(current.left);\n list.add(current.left.val);\n }\n \n if(current.right != null) {\n currentLevel.add(current.right);\n list.add(current.right.val);\n }\n }\n \n if(list.size() > 0) {\n result.add(list);\n }\n\n queue = currentLevel;\n }\n \n return result;\n }\n}\n"
},
{
"path": "company/facebook/BinaryTreePaths.java",
"content": "// Given a binary tree, return all root-to-leaf paths.\n\n// For example, given the following binary tree:\n\n// 1\n// / \\\n// 2 3\n// \\\n// 5\n// All root-to-leaf paths are:\n\n// [\"1->2->5\", \"1->3\"]\n\n/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) { val = x; }\n * }\n */\npublic class BinaryTreePaths {\n public List binaryTreePaths(TreeNode root) {\n List result = new ArrayList();\n \n if(root == null) {\n return result;\n }\n \n helper(new String(), root, result);\n \n return result;\n }\n \n public void helper(String current, TreeNode root, List result) {\n if(root.left == null && root.right == null) {\n result.add(current + root.val);\n }\n\n if(root.left != null) {\n helper(current + root.val + \"->\", root.left, result);\n }\n\n if(root.right != null) {\n helper(current + root.val + \"->\", root.right, result);\n }\n }\n}\n"
},
{
"path": "company/facebook/BinaryTreeVerticalOrderTraversal.java",
"content": "// Given a binary tree, return the vertical order traversal of its nodes' values. (ie, from top to bottom, column by column).\n\n// If two nodes are in the same row and column, the order should be from left to right.\n\n// Examples:\n\n// Given binary tree [3,9,20,null,null,15,7],\n// 3\n// /\\\n// / \\\n// 9 20\n// /\\\n// / \\\n// 15 7\n// return its vertical order traversal as:\n// [\n// [9],\n// [3,15],\n// [20],\n// [7]\n// ]\n// Given binary tree [3,9,8,4,0,1,7],\n// 3\n// /\\\n// / \\\n// 9 8\n// /\\ /\\\n// / \\/ \\\n// 4 01 7\n// return its vertical order traversal as:\n// [\n// [4],\n// [9],\n// [3,0,1],\n// [8],\n// [7]\n// ]\n// Given binary tree [3,9,8,4,0,1,7,null,null,null,2,5] (0's right child is 2 and 1's left child is 5),\n// 3\n// /\\\n// / \\\n// 9 8\n// /\\ /\\\n// / \\/ \\\n// 4 01 7\n// /\\\n// / \\\n// 5 2\n// return its vertical order traversal as:\n// [\n// [4],\n// [9,5],\n// [3,0,1],\n// [8,2],\n// [7]\n// ]\n\n/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) { val = x; }\n * }\n */\npublic class BinaryTreeVerticalOrderTraversal {\n public List> verticalOrder(TreeNode root) {\n List> result = new ArrayList<>();\n\n if(root == null) {\n return result;\n }\n \n Map> map = new HashMap<>();\n Queue q = new LinkedList<>();\n Queue cols = new LinkedList<>();\n \n q.add(root);\n cols.add(0);\n \n int min = 0;\n int max = 0;\n \n while(!q.isEmpty()) {\n TreeNode node = q.poll();\n int col = cols.poll();\n \n if(!map.containsKey(col)) {\n map.put(col, new ArrayList());\n }\n \n map.get(col).add(node.val);\n \n if(node.left != null) {\n q.add(node.left);\n cols.add(col - 1);\n min = Math.min(min, col - 1);\n }\n \n if(node.right != null) {\n q.add(node.right);\n cols.add(col + 1);\n max = Math.max(max, col + 1);\n }\n }\n \n for(int i = min; i <= max; i++) {\n result.add(map.get(i));\n }\n \n return result;\n }\n}\n"
},
{
"path": "company/facebook/CloneGraph.java",
"content": "// Clone an undirected graph. Each node in the graph contains a label and a list of its neighbors.\n\n// OJ's undirected graph serialization:\n// Nodes are labeled uniquely.\n\n// We use # as a separator for each node, and , as a separator for node label and each neighbor of the node.\n// As an example, consider the serialized graph {0,1,2#1,2#2,2}.\n\n// The graph has a total of three nodes, and therefore contains three parts as separated by #.\n\n// First node is labeled as 0. Connect node 0 to both nodes 1 and 2.\n// Second node is labeled as 1. Connect node 1 to node 2.\n// Third node is labeled as 2. Connect node 2 to node 2 (itself), thus forming a self-cycle.\n// Visually, the graph looks like the following:\n\n// 1\n// / \\\n// / \\\n// 0 --- 2\n// / \\\n// \\_/\n\n/**\n * Definition for undirected graph.\n * class UndirectedGraphNode {\n * int label;\n * List neighbors;\n * UndirectedGraphNode(int x) { label = x; neighbors = new ArrayList(); }\n * };\n */\npublic class CloneGraph {\n public HashMap map = new HashMap();\n \n public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {\n if(node == null) {\n return null;\n }\n \n if(map.containsKey(node.label)) {\n return map.get(node.label);\n }\n \n UndirectedGraphNode newNode = new UndirectedGraphNode(node.label);\n map.put(newNode.label, newNode);\n \n for(UndirectedGraphNode neighbor : node.neighbors) {\n newNode.neighbors.add(cloneGraph(neighbor));\n }\n \n return newNode;\n }\n}\n"
},
{
"path": "company/facebook/CombinationSumIV.java",
"content": "// Given an integer array with all positive numbers and no duplicates, find the number of possible combinations that add up to a positive integer target.\n\n// Example:\n\n// nums = [1, 2, 3]\n// target = 4\n\n// The possible combination ways are:\n// (1, 1, 1, 1)\n// (1, 1, 2)\n// (1, 2, 1)\n// (1, 3)\n// (2, 1, 1)\n// (2, 2)\n// (3, 1)\n\n// Note that different sequences are counted as different combinations.\n\n// Therefore the output is 7.\n\n// Follow up:\n // What if negative numbers are allowed in the given array?\n // How does it change the problem?\n // What limitation we need to add to the question to allow negative numbers?\n\npublic class Solution {\n\n public int combinationSum4(int[] nums, int target) {\n \n int[] dp = new int[target + 1];\n dp[0] = 1;\n \n for(int i = 1; i < dp.length; i++) {\n for(int j = 0; j < nums.length; j++) {\n \n if(i - nums[j] >= 0) {\n \n dp[i] += dp[i - nums[j]];\n \n }\n \n }\n \n }\n \n return dp[target];\n \n }\n\n}"
},
{
"path": "company/facebook/CountAndSay.java",
"content": "// The count-and-say sequence is the sequence of integers beginning as follows:\n// 1, 11, 21, 1211, 111221, ...\n\n// 1 is read off as \"one 1\" or 11.\n// 11 is read off as \"two 1s\" or 21.\n// 21 is read off as \"one 2, then one 1\" or 1211.\n// Given an integer n, generate the nth sequence.\n\n// Note: The sequence of integers will be represented as a string.\n\npublic class Solution {\n\n public String countAndSay(int n) {\n \n String s = \"1\";\n for(int i = 1; i < n; i++) {\n \n s = helper(s);\n \n }\n \n return s;\n \n }\n \n \n public String helper(String s) {\n \n StringBuilder sb = new StringBuilder();\n char c = s.charAt(0);\n int count = 1;\n \n for(int i = 1; i < s.length(); i++) {\n \n if(s.charAt(i) == c) count++;\n \n else {\n \n sb.append(count);\n sb.append(c);\n c = s.charAt(i);\n count = 1;\n \n }\n \n }\n \n sb.append(count);\n sb.append(c);\n return sb.toString();\n \n }\n \n}"
},
{
"path": "company/facebook/DecodeWays.java",
"content": "// A message containing letters from A-Z is being encoded to numbers using the following mapping:\n\n// 'A' -> 1\n// 'B' -> 2\n// ...\n// 'Z' -> 26\n\n// Given an encoded message containing digits, determine the total number of ways to decode it.\n\n// For example,\n// Given encoded message \"12\", it could be decoded as \"AB\" (1 2) or \"L\" (12).\n\n// The number of ways decoding \"12\" is 2.\n\npublic class DecodeWays {\n public int numDecodings(String s) {\n int n = s.length();\n\n if(n == 0) {\n return 0;\n }\n \n int[] dp = new int[n + 1];\n dp[n] = 1;\n dp[n - 1] = s.charAt(n - 1) != '0' ? 1 : 0;\n \n for(int i = n - 2; i >= 0; i--) {\n if(s.charAt(i) == '0') {\n continue;\n } else {\n dp[i] = (Integer.parseInt(s.substring(i, i + 2)) <= 26) ? dp[i + 1] + dp[i + 2] : dp[i + 1];\n }\n }\n \n return dp[0];\n }\n}\n"
},
{
"path": "company/facebook/EncodeAndDecodeTinyURL.java",
"content": "//TinyURL is a URL shortening service where you enter a URL such as https://leetcode.com/problems/design-tinyurl \n//and it returns a short URL such as http://tinyurl.com/4e9iAk.\n//\n//Design the encode and decode methods for the TinyURL service. There is no restriction on how your \n//encode/decode algorithm should work. You just need to ensure that a URL can be encoded to a tiny URL \n//and the tiny URL can be decoded to the original URL.\n\npublic class EncodeAndDecodeTinyURL {\n HashMap map = new HashMap();\n String characters = \"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\";\n int count = 1;\n\n public String getKey() {\n String key = \"\";\n while(count > 0) {\n count--;\n key += characters.charAt(count);\n count /= characters.length();\n }\n \n return key;\n }\n \n // Encodes a URL to a shortened URL.\n public String encode(String longUrl) {\n String key = getKey();\n map.put(key, longUrl);\n count++;\n \n return \"http://tinyurl.com/\" + key;\n }\n\n // Decodes a shortened URL to its original URL.\n public String decode(String shortUrl) {\n return map.get(shortUrl.replace(\"http://tinyurl.com/\", \"\"));\n }\n}\n\n// Your Codec object will be instantiated and called as such:\n// Codec codec = new Codec();\n// codec.decode(codec.encode(url));\n"
},
{
"path": "company/facebook/ExclusiveTimeOfFunctions.java",
"content": "//Given the running logs of n functions that are executed in a nonpreemptive single threaded CPU, find the exclusive time of these functions.\n\n//Each function has a unique id, start from 0 to n-1. A function may be called recursively or by another function.\n\n//A log is a string has this format : function_id:start_or_end:timestamp. For example, \"0:start:0\" means function 0 starts from the very beginning of time 0. \"0:end:0\" means function 0 ends to the very end of time 0.\n\n//Exclusive time of a function is defined as the time spent within this function, the time spent by calling other functions should not be considered as this function's exclusive time. You should return the exclusive time of each function sorted by their function id.\n\n//Example 1:\n//Input:\n//n = 2\n//logs = \n//[\"0:start:0\",\n //\"1:start:2\",\n //\"1:end:5\",\n //\"0:end:6\"]\n//Output:[3, 4]\n//Explanation:\n//Function 0 starts at time 0, then it executes 2 units of time and reaches the end of time 1. \n//Now function 0 calls function 1, function 1 starts at time 2, executes 4 units of time and end at time 5.\n//Function 0 is running again at time 6, and also end at the time 6, thus executes 1 unit of time. \n//So function 0 totally execute 2 + 1 = 3 units of time, and function 1 totally execute 4 units of time.\n//Note:\n//Input logs will be sorted by timestamp, NOT log id.\n//Your output should be sorted by function id, which means the 0th element of your output corresponds to the exclusive time of function 0.\n//Two functions won't start or end at the same time.\n//Functions could be called recursively, and will always end.\n//1 <= n <= 100\n\nclass ExclusiveTimeOfFunctions {\n public int[] exclusiveTime(int n, List logs) {\n Stack stack = new Stack ();\n int[] result = new int[n];\n String[] current = logs.get(0).split(\":\");\n stack.push(Integer.parseInt(current[0]));\n int i = 1;\n int previous = Integer.parseInt(current[2]);\n while (i < logs.size()) {\n current = logs.get(i).split(\":\");\n if (current[1].equals(\"start\")) {\n if (!stack.isEmpty()) {\n result[stack.peek()] += Integer.parseInt(current[2]) - previous;\n }\n stack.push(Integer.parseInt(current[0]));\n previous = Integer.parseInt(current[2]);\n } else {\n result[stack.peek()] += Integer.parseInt(current[2]) - previous + 1;\n stack.pop();\n previous = Integer.parseInt(current[2]) + 1;\n }\n i++;\n }\n return result;\n }\n}\n"
},
{
"path": "company/facebook/ExpressionAddOperators.java",
"content": "// Given a string that contains only digits 0-9 and a target value, return all possibilities to add binary operators (not unary) +, -, or * between the digits so they evaluate to the target value.\n\n// Examples: \n// \"123\", 6 -> [\"1+2+3\", \"1*2*3\"] \n// \"232\", 8 -> [\"2*3+2\", \"2+3*2\"]\n// \"105\", 5 -> [\"1*0+5\",\"10-5\"]\n// \"00\", 0 -> [\"0+0\", \"0-0\", \"0*0\"]\n// \"3456237490\", 9191 -> []\n\npublic class ExpressionAddOperators {\n public List addOperators(String num, int target) {\n List result = new ArrayList();\n\n if(num == null || num.length() == 0) {\n return result;\n }\n\n helper(result, \"\", num, target, 0, 0, 0);\n\n return result;\n }\n \n public void helper(List result, String path, String num, int target, int pos, long eval, long multed) {\n if(pos == num.length()) {\n if(eval == target) {\n result.add(path);\n }\n \n return;\n }\n \n for(int i = pos; i < num.length(); i++) {\n if(i != pos && num.charAt(pos) == '0') {\n break;\n }\n\n long cur = Long.parseLong(num.substring(pos, i + 1));\n\n if(pos == 0) {\n helper(result, path + cur, num, target, i + 1, cur, cur);\n } else {\n helper(result, path + \"+\" + cur, num, target, i + 1, eval + cur, cur);\n helper(result, path + \"-\" + cur, num, target, i + 1, eval - cur, -cur);\n helper(result, path + \"*\" + cur, num, target, i + 1, eval - multed + multed * cur, multed * cur);\n }\n }\n }\n}\n"
},
{
"path": "company/facebook/FindTheCelebrity.java",
"content": "// Suppose you are at a party with n people (labeled from 0 to n - 1) and among them, there may exist one celebrity. The definition of a celebrity is that all the other n - 1 people know him/her but he/she does not know any of them.\n\n// Now you want to find out who the celebrity is or verify that there is not one. The only thing you are allowed to do is to ask questions like: \"Hi, A. Do you know B?\" to get information of whether A knows B. You need to find out the celebrity (or verify there is not one) by asking as few questions as possible (in the asymptotic sense).\n\n// You are given a helper function bool knows(a, b) which tells you whether A knows B. Implement a function int findCelebrity(n), your function should minimize the number of calls to knows.\n\n// Note: There will be exactly one celebrity if he/she is in the party. Return the celebrity's label if there is a celebrity in the party. If there is no celebrity, return -1.\n\n/* The knows API is defined in the parent class Relation.\n boolean knows(int a, int b); */\n\npublic class FindTheCelebrity extends Relation {\n public int findCelebrity(int n) {\n //initialize candidate to 0\n int candidate = 0;\n \n //find viable candidate\n for(int i = 1; i < n; i++) {\n if(knows(candidate, i)) {\n candidate = i;\n }\n }\n \n \n //check that everyone else knows the candidate\n for(int i = 0; i < n; i++) {\n //if the candidate knows the current person or the current person does not know the candidate, return -1 (candidate is not a celebrity)\n if(i != candidate && knows(candidate, i) || !knows(i, candidate)) {\n return -1;\n }\n }\n \n //return the celebrity\n return candidate;\n }\n}\n"
},
{
"path": "company/facebook/FirstBadVersion.java",
"content": "// You are a product manager and currently leading a team to develop a new product. Unfortunately, the latest version of your product fails the quality check. Since each version is developed based on the previous version, all the versions after a bad version are also bad.\n\n// Suppose you have n versions [1, 2, ..., n] and you want to find out the first bad one, which causes all the following ones to be bad.\n\n// You are given an API bool isBadVersion(version) which will return whether version is bad. Implement a function to find the first bad version. You should minimize the number of calls to the API.\n\n/* The isBadVersion API is defined in the parent class VersionControl.\n boolean isBadVersion(int version); */\n\npublic class FirstBadVersion extends VersionControl {\n public int firstBadVersion(int n) {\n int start = 1;\n int end = n;\n \n while(start < end) {\n int mid = start + (end - start) / 2;\n\n if(!isBadVersion(mid)) {\n start = mid + 1;\n } else {\n end = mid;\n }\n }\n \n return start;\n }\n}\n"
},
{
"path": "company/facebook/FlattenNestedListIterator.java",
"content": "// Given a nested list of integers, implement an iterator to flatten it.\n\n// Each element is either an integer, or a list -- whose elements may also be integers or other lists.\n\n// Example 1:\n// Given the list [[1,1],2,[1,1]],\n\n// By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,1,2,1,1].\n\n// Example 2:\n// Given the list [1,[4,[6]]],\n\n// By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,4,6].\n\n/**\n * // This is the interface that allows for creating nested lists.\n * // You should not implement it, or speculate about its implementation\n * public interface NestedInteger {\n *\n * // @return true if this NestedInteger holds a single integer, rather than a nested list.\n * public boolean isInteger();\n *\n * // @return the single integer that this NestedInteger holds, if it holds a single integer\n * // Return null if this NestedInteger holds a nested list\n * public Integer getInteger();\n *\n * // @return the nested list that this NestedInteger holds, if it holds a nested list\n * // Return null if this NestedInteger holds a single integer\n * public List getList();\n * }\n */\npublic class FlattenNestedListIterator implements Iterator {\n Stack stack = new Stack();\n\n public NestedIterator(List nestedList) {\n for(int i = nestedList.size() - 1; i >= 0; i--) {\n stack.push(nestedList.get(i));\n }\n }\n\n @Override\n public Integer next() {\n return stack.pop().getInteger();\n }\n\n @Override\n public boolean hasNext() {\n while(!stack.isEmpty()) {\n NestedInteger current = stack.peek();\n\n if(current.isInteger()) {\n return true;\n }\n\n stack.pop();\n\n for(int i = current.getList().size() - 1; i >= 0; i--) {\n stack.push(current.getList().get(i));\n }\n }\n \n return false;\n }\n}\n\n/**\n * Your NestedIterator object will be instantiated and called as such:\n * NestedIterator i = new NestedIterator(nestedList);\n * while (i.hasNext()) v[f()] = i.next();\n */\n"
},
{
"path": "company/facebook/GroupAnagrams.java",
"content": "// Given an array of strings, group anagrams together.\n\n// For example, given: [\"eat\", \"tea\", \"tan\", \"ate\", \"nat\", \"bat\"], \n// Return:\n\n// [\n// [\"ate\", \"eat\",\"tea\"],\n// [\"nat\",\"tan\"],\n// [\"bat\"]\n// ]\n// Note: All inputs will be in lower-case.\n\npublic class GroupAnagrams {\n public List> groupAnagrams(String[] strs) {\n if(strs == null || strs.length == 0) {\n return new ArrayList>();\n }\n \n HashMap> map = new HashMap>();\n \n Arrays.sort(strs);\n \n for(String s : strs) {\n char[] characters = s.toCharArray();\n \n Arrays.sort(characters);\n \n String key = String.valueOf(characters);\n \n if(!map.containsKey(key)) {\n map.put(key, new ArrayList());\n }\n \n map.get(key).add(s);\n }\n \n return new ArrayList>(map.values());\n }\n}\n"
},
{
"path": "company/facebook/HammingDistance.java",
"content": "// The Hamming distance between two integers is the number of positions at which the corresponding bits are different.\n\n// Given two integers x and y, calculate the Hamming distance.\n\n// Note:\n// 0 ≤ x, y < 2^31.\n\n// Example:\n\n// Input: x = 1, y = 4\n\n// Output: 2\n\n// Explanation:\n// 1 (0 0 0 1)\n// 4 (0 1 0 0)\n// ↑ ↑\n\n// The above arrows point to positions where the corresponding bits are different.\n\npublic class HammingDistance {\n public int hammingDistance(int x, int y) {\n return Integer.bitCount(x ^ y);\n }\n}\n"
},
{
"path": "company/facebook/ImplementTrie.java",
"content": "// Implement a trie with insert, search, and startsWith methods.\n\n// Note:\n// You may assume that all inputs are consist of lowercase letters a-z.\n\n// Your Trie object will be instantiated and called as such:\n// Trie trie = new Trie();\n// trie.insert(\"somestring\");\n// trie.search(\"key\");\n\nclass TrieNode {\n HashMap map;\n char character;\n boolean last;\n \n // Initialize your data structure here.\n public TrieNode(char character) {\n this.map = new HashMap();\n this.character = character;\n this.last = false;\n }\n}\n\npublic class ImplementTrie {\n private TrieNode root;\n\n public Trie() {\n root = new TrieNode(' ');\n }\n\n // Inserts a word into the trie.\n public void insert(String word) {\n TrieNode current = root;\n \n for(char c : word.toCharArray()) {\n if(!current.map.containsKey(c)) {\n current.map.put(c, new TrieNode(c));\n }\n \n current = current.map.get(c);\n }\n \n current.last = true;\n }\n\n // Returns if the word is in the trie.\n public boolean search(String word) {\n TrieNode current = root;\n \n for(char c : word.toCharArray()) {\n if(!current.map.containsKey(c)) {\n return false;\n }\n\n current = current.map.get(c);\n }\n \n if(current.last == true) {\n return true;\n } else {\n return false;\n }\n }\n\n // Returns if there is any word in the trie\n // that starts with the given prefix.\n public boolean startsWith(String prefix) {\n TrieNode current = root;\n \n for(char c : prefix.toCharArray()) {\n if(!current.map.containsKey(c)) {\n return false;\n }\n \n current = current.map.get(c);\n }\n \n return true;\n }\n}\n\n"
},
{
"path": "company/facebook/InorderSuccessorInBST.java",
"content": "// Given a binary search tree and a node in it, find the in-order successor of that node in the BST.\n\n// Note: If the given node has no in-order successor in the tree, return null.\n\n/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) { val = x; }\n * }\n */\npublic class InorderSuccessorInBST {\n public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {\n TreeNode successor = null;\n \n while(root != null) {\n if(p.val < root.val) {\n successor = root;\n root = root.left;\n } else {\n root = root.right;\n }\n }\n \n return successor;\n }\n}\n"
},
{
"path": "company/facebook/InsertDeleteGetRandomO1.java",
"content": "//Design a data structure that supports all following operations in average O(1) time.\n\n//insert(val): Inserts an item val to the set if not already present.\n//remove(val): Removes an item val from the set if present.\n//getRandom: Returns a random element from current set of elements. Each element must have the same probability of being returned.\n\n//Example:\n// Init an empty set.\n//RandomizedSet randomSet = new RandomizedSet();\n\n// Inserts 1 to the set. Returns true as 1 was inserted successfully.\n//randomSet.insert(1);\n\n// Returns false as 2 does not exist in the set.\n//randomSet.remove(2);\n\n// Inserts 2 to the set, returns true. Set now contains [1,2].\n//randomSet.insert(2);\n\n// getRandom should return either 1 or 2 randomly.\n//randomSet.getRandom();\n\n// Removes 1 from the set, returns true. Set now contains [2].\n//randomSet.remove(1);\n\n// 2 was already in the set, so return false.\n//randomSet.insert(2);\n\n// Since 2 is the only number in the set, getRandom always return 2.\n//randomSet.getRandom();\n\nclass RandomizedSet {\n HashMap map;\n ArrayList values;\n\n /** Initialize your data structure here. */\n public RandomizedSet() {\n map = new HashMap();\n values = new ArrayList();\n }\n \n /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */\n public boolean insert(int val) {\n if(!map.containsKey(val)) {\n map.put(val, val);\n values.add(val);\n return true;\n }\n else {\n return false;\n }\n }\n \n /** Removes a value from the set. Returns true if the set contained the specified element. */\n public boolean remove(int val) {\n if(map.containsKey(val)) {\n map.remove(val);\n values.remove(values.indexOf(val));\n return true;\n }\n return false;\n }\n \n /** Get a random element from the set. */\n public int getRandom() {\n int random = (int)(Math.random() * values.size());\n int valueToReturn = values.get(random);\n return map.get(valueToReturn);\n }\n}\n\n/**\n * Your RandomizedSet object will be instantiated and called as such:\n * RandomizedSet obj = new RandomizedSet();\n * boolean param_1 = obj.insert(val);\n * boolean param_2 = obj.remove(val);\n * int param_3 = obj.getRandom();\n */\n\n"
},
{
"path": "company/facebook/InsertInterval.java",
"content": "// Given a set of non-overlapping intervals, insert a new interval into the intervals (merge if necessary).\n\n// You may assume that the intervals were initially sorted according to their start times.\n\n// Example 1:\n// Given intervals [1,3],[6,9], insert and merge [2,5] in as [1,5],[6,9].\n\n// Example 2:\n// Given [1,2],[3,5],[6,7],[8,10],[12,16], insert and merge [4,9] in as [1,2],[3,10],[12,16].\n\n// This is because the new interval [4,9] overlaps with [3,5],[6,7],[8,10].\n\n/**\n * Definition for an interval.\n * public class Interval {\n * int start;\n * int end;\n * Interval() { start = 0; end = 0; }\n * Interval(int s, int e) { start = s; end = e; }\n * }\n */\npublic class InsertInterval {\n public List insert(List intervals, Interval newInterval) {\n int i = 0;\n\n while(i < intervals.size() && intervals.get(i).end < newInterval.start) {\n i++;\n }\n\n while(i < intervals.size() && intervals.get(i).start <= newInterval.end) {\n newInterval = new Interval(Math.min(intervals.get(i).start, newInterval.start), Math.max(intervals.get(i).end, newInterval.end));\n intervals.remove(i);\n }\n \n intervals.add(i, newInterval);\n\n return intervals;\n }\n}\n"
},
{
"path": "company/facebook/IntegerToEnglishWords.java",
"content": "// Convert a non-negative integer to its english words representation. Given input is guaranteed to be less than 231 - 1.\n\n// For example,\n\n// 123 -> \"One Hundred Twenty Three\"\n// 12345 -> \"Twelve Thousand Three Hundred Forty Five\"\n// 1234567 -> \"One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven\"\n\npublic class IntegerToEnglishWords {\n private final String[] LESS_THAN_20 = { \"\", \"One\", \"Two\", \"Three\", \"Four\", \"Five\", \"Six\", \"Seven\", \"Eight\", \"Nine\", \"Ten\", \"Eleven\", \"Twelve\", \"Thirteen\", \"Fourteen\", \"Fifteen\", \"Sixteen\", \"Seventeen\", \"Eighteen\", \"Nineteen\" };\n private final String[] TENS = { \"\", \"Ten\", \"Twenty\", \"Thirty\", \"Forty\", \"Fifty\", \"Sixty\", \"Seventy\", \"Eighty\", \"Ninety\" };\n private final String[] THOUSANDS = { \"\", \"Thousand\", \"Million\", \"Billion\" };\n \n public String numberToWords(int num) {\n if(num == 0) {\n return \"Zero\";\n }\n \n int i = 0;\n String words = \"\";\n \n while(num > 0) {\n if(num % 1000 != 0) {\n words = helper(num % 1000) + THOUSANDS[i] + \" \" + words;\n }\n \n num /= 1000;\n i++;\n }\n \n return words.trim();\n }\n \n \n private String helper(int num) {\n if(num == 0) {\n return \"\";\n } else if(num < 20) {\n return LESS_THAN_20[num] + \" \";\n } else if(num < 100) {\n return TENS[num / 10] + \" \" + helper(num % 10);\n } else {\n return LESS_THAN_20[num / 100] + \" Hundred \" + helper(num % 100);\n }\n }\n}\n"
},
{
"path": "company/facebook/KthLargestElementInAnArray.java",
"content": "// Find the kth largest element in an unsorted array. Note that it is the kth largest element in the sorted order, not the kth distinct element.\n\n// For example,\n// Given [3,2,1,5,6,4] and k = 2, return 5.\n\n// Note: \n// You may assume k is always valid, 1 ≤ k ≤ array's length.\n\npublic class KthLargestElementInAnArray {\n public int findKthLargest(int[] nums, int k) {\n int length = nums.length;\n\n Arrays.sort(nums);\n\n return nums[length - k];\n }\n}\n"
},
{
"path": "company/facebook/LetterCombinationsOfAPhoneNumber.java",
"content": "// Given a digit string, return all possible letter combinations that the number could represent.\n\n// A mapping of digit to letters (just like on the telephone buttons) is given below.\n\n// 2 - abc\n// 3 - def\n// 4 - ghi\n// 5 - jkl\n// 6 - mno\n// 7 - pqrs\n// 8 - tuv\n// 9 - wxyz\n\n// Input:Digit string \"23\"\n// Output: [\"ad\", \"ae\", \"af\", \"bd\", \"be\", \"bf\", \"cd\", \"ce\", \"cf\"].\n\nclass LetterCombinationsOfAPhoneNumber {\n public List letterCombinations(String digits) {\n List result = new ArrayList();\n \n if(digits == null || digits.length() == 0) {\n return result;\n }\n \n String[] mapping = {\n \"0\",\n \"1\",\n \"abc\",\n \"def\",\n \"ghi\",\n \"jkl\",\n \"mno\",\n \"pqrs\",\n \"tuv\",\n \"wxyz\"\n };\n \n letterCombinationsRecursive(result, digits, \"\", 0, mapping);\n \n return result;\n }\n \n public void letterCombinationsRecursive(List result, String digits, String current, int index, String[] mapping) {\n if(index == digits.length()) {\n result.add(current);\n return;\n }\n \n String letters = mapping[digits.charAt(index) - '0'];\n for(int i = 0; i < letters.length(); i++) {\n letterCombinationsRecursive(result, digits, current + letters.charAt(i), index + 1, mapping);\n }\n }\n}\n"
},
{
"path": "company/facebook/LongestConsecutiveSequence.java",
"content": "// Given an unsorted array of integers, find the length of the longest consecutive elements sequence.\n\n// For example,\n// Given [100, 4, 200, 1, 3, 2],\n// The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length: 4.\n\n// Your algorithm should run in O(n) complexity.\n\nclass LongestConsecutiveSequence {\n public int longestConsecutive(int[] nums) {\n if(nums == null || nums.length == 0) {\n return 0;\n }\n \n Set set = new HashSet();\n for(int n: nums) {\n set.add(n);\n }\n \n int maxLength = 0;\n for(int n: set) {\n if(!set.contains(n - 1)) {\n int current = n;\n int currentMax = 1;\n \n while(set.contains(n + 1)) {\n currentMax++;\n n++;\n }\n \n maxLength = Math.max(maxLength, currentMax);\n }\n }\n \n return maxLength;\n }\n}\n"
},
{
"path": "company/facebook/LowestCommonAncestorOfABinaryTree.java",
"content": "// Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.\n\n// According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes v and w as the lowest node in T that has both v and w as descendants (where we allow a node to be a descendant of itself).”\n\n// _______3______\n// / \\\n// ___5__ ___1__\n// / \\ / \\\n// 6 _2 0 8\n// / \\\n// 7 4\n// For example, the lowest common ancestor (LCA) of nodes 5 and 1 is 3. Another example is LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.\n\n/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) { val = x; }\n * }\n */\npublic class LowestCommonAncestorsOfABinaryTree {\n public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {\n if(root == null || root == p || root == q) {\n return root;\n }\n \n TreeNode left = lowestCommonAncestor(root.left, p, q);\n TreeNode right = lowestCommonAncestor(root.right, p, q);\n \n if(left != null && right != null) {\n return root;\n }\n \n return left == null ? right : left;\n }\n}\n"
},
{
"path": "company/facebook/MaximumSizeSubarraySumEqualsK.java",
"content": "// Given an array nums and a target value k, find the maximum length of a subarray that sums to k. If there isn't one, return 0 instead.\n\n// Note:\n// The sum of the entire nums array is guaranteed to fit within the 32-bit signed integer range.\n\n// Example 1:\n// Given nums = [1, -1, 5, -2, 3], k = 3,\n// return 4. (because the subarray [1, -1, 5, -2] sums to 3 and is the longest)\n\n// Example 2:\n// Given nums = [-2, -1, 2, 1], k = 1,\n// return 2. (because the subarray [-1, 2] sums to 1 and is the longest)\n\n// Follow Up:\n// Can you do it in O(n) time?\n\npublic class MaximumSizeSubarraySumEqualsK {\n public int maxSubArrayLen(int[] nums, int k) {\n if(nums.length == 0) {\n return 0;\n }\n \n HashMap map = new HashMap();\n \n int maxLength = 0;\n \n int total = 0;\n \n map.put(0, -1);\n \n for(int i = 0; i < nums.length; i++) {\n total += nums[i];\n\n if(map.containsKey(total - k)) {\n maxLength = Math.max(maxLength, i - map.get(total - k));\n }\n\n if(!map.containsKey(total)) {\n map.put(total, i);\n }\n }\n \n return maxLength;\n }\n}\n"
},
{
"path": "company/facebook/MeetingRooms.java",
"content": "// Given an array of meeting time intervals consisting of start and end times [[s1,e1],[s2,e2],...] (si < ei), determine if a person could attend all meetings.\n\n// For example,\n// Given [[0, 30],[5, 10],[15, 20]],\n// return false.\n\n/**\n * Definition for an interval.\n * public class Interval {\n * int start;\n * int end;\n * Interval() { start = 0; end = 0; }\n * Interval(int s, int e) { start = s; end = e; }\n * }\n */\npublic class MeetingRooms {\n public boolean canAttendMeetings(Interval[] intervals) {\n if(intervals == null) {\n return false;\n }\n\n // Sort the intervals by start time\n Arrays.sort(intervals, new Comparator() {\n public int compare(Interval a, Interval b) { return a.start - b.start; }\n });\n\n for(int i = 1; i < intervals.length; i++) {\n if(intervals[i].start < intervals[i - 1].end) {\n return false;\n }\n }\n\n return true;\n }\n}\n"
},
{
"path": "company/facebook/MergeIntervals.java",
"content": "// Given a collection of intervals, merge all overlapping intervals.\n\n// For example,\n// Given [1,3],[2,6],[8,10],[15,18],\n// return [1,6],[8,10],[15,18].\n\n/**\n * Definition for an interval.\n * public class Interval {\n * int start;\n * int end;\n * Interval() { start = 0; end = 0; }\n * Interval(int s, int e) { start = s; end = e; }\n * }\n */\nclass MergeIntervals {\n public List merge(List intervals) {\n List result = new ArrayList();\n if(intervals == null || intervals.size() == 0) {\n return result;\n }\n \n Interval[] allIntervals = intervals.toArray(new Interval[intervals.size()]);\n Arrays.sort(allIntervals, new Comparator() {\n public int compare(Interval a, Interval b) {\n if(a.start == b.start) {\n return a.end - b.end;\n }\n return a.start - b.start;\n } \n });\n \n for(Interval i: allIntervals) {\n if (result.size() == 0 || result.get(result.size() - 1).end < i.start) {\n result.add(i);\n } else {\n result.get(result.size() - 1).end = Math.max(result.get(result.size() - 1).end, i.end);\n }\n }\n \n return result;\n }\n}\n"
},
{
"path": "company/facebook/MergeKSortedLists.java",
"content": "// Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.\n\n/**\n * Definition for singly-linked list.\n * public class ListNode {\n * int val;\n * ListNode next;\n * ListNode(int x) { val = x; }\n * }\n */\npublic class MergeKSortedLists {\n public ListNode mergeKLists(ListNode[] lists) {\n if (lists==null||lists.length==0) {\n return null;\n }\n \n PriorityQueue queue= new PriorityQueue(lists.length,new Comparator(){\n @Override\n public int compare(ListNode o1,ListNode o2){\n if (o1.val= 0 && j >= 0) {\n A[k--] = A[i] > B[j] ? A[i--] : B[j--];\n }\n \n while(j >= 0) {\n A[k--] = B[j--];\n }\n }\n}\n"
},
{
"path": "company/facebook/MinStack.java",
"content": "/**\n * Your MinStack object will be instantiated and called as such:\n * MinStack obj = new MinStack();\n * obj.push(x);\n * obj.pop();\n * int param_3 = obj.top();\n * int param_4 = obj.getMin();\n */\nclass MinStack {\n class Node {\n int data;\n int min;\n Node next;\n \n public Node(int data, int min) {\n this.data = data;\n this.min = min;\n this.next = null;\n }\n }\n Node head;\n \n /** initialize your data structure here. */\n public MinStack() {\n \n }\n \n public void push(int x) {\n if(head == null) {\n head = new Node(x, x);\n } else {\n Node newNode = new Node(x, Math.min(x, head.min));\n newNode.next = head;\n head = newNode;\n }\n }\n \n public void pop() {\n head = head.next;\n }\n \n public int top() {\n return head.data;\n }\n \n public int getMin() {\n return head.min;\n }\n}\n"
},
{
"path": "company/facebook/MinimumSizeSubarraySum.java",
"content": "// Given an array of n positive integers and a positive integer s, find the minimal length of a contiguous subarray of which the sum ≥ s. If there isn't one, return 0 instead.\n\n// For example, given the array [2,3,1,2,4,3] and s = 7,\n// the subarray [4,3] has the minimal length under the problem constraint.\n\npublic class MinimumSizeSubarraySum {\n public int minSubArrayLen(int s, int[] nums) {\n if(nums == null || nums.length == 0) {\n return 0;\n }\n \n int i = 0;\n int j = 0;\n int result = Integer.MAX_VALUE;\n int total = 0;\n \n while(i < nums.length) {\n total += nums[i++];\n \n while(total >= s) {\n result = Math.min(result, i - j);\n total -= nums[j++];\n }\n }\n \n return result == Integer.MAX_VALUE ? 0 : result;\n }\n}\n"
},
{
"path": "company/facebook/MinimumWindowSubstring.java",
"content": "// Given a string S and a string T, find the minimum window in S which will contain all the characters in T in complexity O(n).\n\n// For example,\n// S = \"ADOBECODEBANC\"\n// T = \"ABC\"\n// Minimum window is \"BANC\".\n\n// Note:\n// If there is no such window in S that covers all characters in T, return the empty string \"\".\n\n// If there are multiple such windows, you are guaranteed that there will always be only one unique minimum window in S.\n\npublic class MinimumWindowSubstring {\n public String minWindow(String s, String t) {\n HashMap map = new HashMap<>();\n \n for(char c : s.toCharArray()) {\n map.put(c, 0);\n }\n \n for(char c : t.toCharArray()) {\n if(map.containsKey(c)) {\n map.put(c, map.get(c)+ 1);\n } else {\n return \"\";\n }\n }\n \n int start = 0;\n int end = 0;\n int minStart = 0;\n int minLength = Integer.MAX_VALUE;\n int counter = t.length();\n \n while(end < s.length()) {\n char c1 = s.charAt(end);\n \n if(map.get(c1) > 0) {\n counter--;\n }\n \n map.put(c1, map.get(c1) - 1);\n end++;\n \n while(counter == 0) {\n if(minLength > end - start) {\n minLength = end - start;\n minStart = start;\n }\n \n char c2 = s.charAt(start);\n map.put(c2, map.get(c2) + 1);\n \n if(map.get(c2) > 0) {\n counter++;\n }\n \n start++;\n }\n }\n \n return minLength == Integer.MAX_VALUE ? \"\" : s.substring(minStart, minStart + minLength);\n }\n}\n"
},
{
"path": "company/facebook/MoveZeros.java",
"content": "// Given an array nums, write a function to move all 0's to the end of it while maintaining the relative order of the non-zero elements.\n\n// For example, given nums = [0, 1, 0, 3, 12], after calling your function, nums should be [1, 3, 12, 0, 0].\n\n// Note:\n // You must do this in-place without making a copy of the array.\n // Minimize the total number of operations.\n\npublic class MoveZeros {\n public void moveZeroes(int[] nums) {\n if(nums == null || nums.length == 0) {\n return;\n }\n \n int index = 0;\n for(int num : nums) {\n if(num != 0) {\n nums[index] = num;\n index++;\n }\n }\n \n while(index < nums.length) {\n nums[index] = 0;\n index++;\n }\n }\n}\n"
},
{
"path": "company/facebook/MultiplyStrings.java",
"content": "// Given two non-negative integers num1 and num2 represented as strings, return the product of num1 and num2.\n\n// Note:\n\n // The length of both num1 and num2 is < 110.\n // Both num1 and num2 contains only digits 0-9.\n // Both num1 and num2 does not contain any leading zero.\n // You must not use any built-in BigInteger library or convert the inputs to integer directly.\n\npublic class MultiplyStrings {\n public String multiply(String num1, String num2) {\n int m = num1.length();\n int n = num2.length();\n int[] pos = new int[m + n];\n \n for(int i = m - 1; i >= 0; i--) {\n for(int j = n - 1; j >= 0; j--) {\n int mul = (num1.charAt(i) - '0') * (num2.charAt(j) - '0');\n int p1 = i + j;\n int p2 = i + j + 1;\n int sum = mul + pos[p2];\n \n pos[p1] += sum / 10;\n pos[p2] = (sum) % 10;\n }\n }\n \n StringBuilder sb = new StringBuilder();\n\n for(int p : pos) {\n if(!(sb.length() == 0 && p == 0)) {\n sb.append(p);\n }\n }\n \n return sb.length() == 0 ? \"0\" : sb.toString();\n }\n}\n"
},
{
"path": "company/facebook/NumberOfIslands.java",
"content": "// Given a 2d grid map of '1's (land) and '0's (water), count the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.\n\n// Example 1:\n\n// 11110\n// 11010\n// 11000\n// 00000\n// Answer: 1\n\n// Example 2:\n\n// 11000\n// 11000\n// 00100\n// 00011\n// Answer: 3\n\npublic class NumberOfIslands {\n char[][] gridCopy;\n \n public int numIslands(char[][] grid) {\n //set grid copy to the current grid\n gridCopy = grid;\n \n //initialize number of islands to zero\n int numberOfIslands = 0;\n \n //iterate through every index of the grid\n for(int i = 0; i < grid.length; i++) {\n for(int j = 0; j < grid[0].length; j++) {\n //attempt to \"sink\" the current index of the grid\n numberOfIslands += sink(gridCopy, i, j);\n }\n }\n \n //return the total number of islands\n return numberOfIslands;\n }\n \n int sink(char[][] grid, int i, int j) {\n //check the bounds of i and j and if the current index is an island or not (1 or 0)\n if(i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] == '0') {\n return 0;\n }\n \n //set current index to 0\n grid[i][j] = '0';\n \n // sink all neighbors of current index\n sink(grid, i + 1, j);\n sink(grid, i - 1, j);\n sink(grid, i, j + 1);\n sink(grid, i, j - 1);\n \n //increment number of islands\n return 1;\n }\n}\n"
},
{
"path": "company/facebook/OneEditDistance.java",
"content": "// Given two strings S and T, determine if they are both one edit distance apart.\n\npublic class OneEditDistance {\n public boolean isOneEditDistance(String s, String t) {\n //iterate through the length of the smaller string\n for(int i = 0; i < Math.min(s.length(), t.length()); i++) {\n //if the current characters of the two strings are not equal\n if(s.charAt(i) != t.charAt(i)) {\n //return true if the remainder of the two strings are equal, false otherwise\n if(s.length() == t.length()) {\n return s.substring(i + 1).equals(t.substring(i + 1));\n } else if(s.length() < t.length()) {\n //return true if the strings would be the same if you deleted a character from string t\n return s.substring(i).equals(t.substring(i + 1));\n } else {\n //return true if the strings would be the same if you deleted a character from string s\n return t.substring(i).equals(s.substring(i + 1));\n }\n }\n }\n \n //if all characters match for the length of the two strings check if the two strings' lengths do not differ by more than 1\n return Math.abs(s.length() - t.length()) == 1;\n }\n}\n"
},
{
"path": "company/facebook/PaintHouseII.java",
"content": " // There are a row of n houses, each house can be painted with one of the k colors. The cost of painting each house with a certain color is different. You have to paint all the houses such that no two adjacent houses have the same color.\n\n// The cost of painting each house with a certain color is represented by a n x k cost matrix. For example, costs[0][0] is the cost of painting house 0 with color 0; costs[1][2] is the cost of painting house 1 with color 2, and so on... Find the minimum cost to paint all houses.\n\n// Note:\n// All costs are positive integers.\n\n// Follow up:\n// Could you solve it in O(nk) runtime?\n\npublic class PaintHouseII { \n public int minCostII(int[][] costs) {\n if(costs == null|| costs.length == 0) {\n return 0;\n }\n \n int m = costs.length;\n int n = costs[0].length;\n \n int min1 = -1;\n int min2 = -1;\n \n for(int i = 0; i < m; i++) {\n int last1 = min1;\n int last2 = min2;\n\n min1 = -1;\n min2 = -1;\n \n for(int j = 0; j < n; j++) {\n if(j != last1) {\n costs[i][j] += last1 < 0 ? 0 : costs[i - 1][last1];\n } else {\n costs[i][j] += last2 < 0 ? 0 : costs[i - 1][last2];\n }\n\n if(min1 < 0 || costs[i][j] < costs[i][min1]) {\n min2 = min1;\n min1 = j;\n } else if(min2 < 0 || costs[i][j] < costs[i][min2]) {\n min2 = j;\n }\n }\n }\n \n return costs[m - 1][min1]; \n }\n}\n"
},
{
"path": "company/facebook/PalindromeLinkedList.java",
"content": "/**\n * Definition for singly-linked list.\n * public class ListNode {\n * int val;\n * ListNode next;\n * ListNode(int x) { val = x; }\n * }\n */\npublic class PalindromeLinkedList {\n public boolean isPalindrome(ListNode head) {\n if(head == null || head.next == null) {\n return true;\n }\n \n Stack stack = new Stack();\n \n ListNode fast = head;\n ListNode slow = head;\n\n while(fast != null && fast.next != null) {\n stack.push(slow.val);\n fast = fast.next.next;\n slow = slow.next;\n }\n \n if(fast != null) {\n slow = slow.next;\n }\n \n while(slow != null) {\n if(stack.pop() != slow.val) {\n return false;\n }\n\n slow = slow.next;\n }\n \n return true;\n }\n}\n"
},
{
"path": "company/facebook/PalindromicSubstrings.java",
"content": "//Given a string, your task is to count how many palindromic substrings in this string.\n//The substrings with different start indexes or end indexes are counted as different substrings \n//even they consist of same characters.\n\n//Example 1:\n//Input: \"abc\"\n//Output: 3\n//Explanation: Three palindromic strings: \"a\", \"b\", \"c\".\n//Example 2:\n//Input: \"aaa\"\n//Output: 6\n//Explanation: Six palindromic strings: \"a\", \"a\", \"a\", \"aa\", \"aa\", \"aaa\".\n//Note:\n//The input string length won't exceed 1000.\n\nclass PalindromicSubstrings {\n int result = 0;\n public int countSubstrings(String s) {\n if(s == null || s.length() == 0) {\n return 0;\n }\n \n for(int i = 0; i < s.length(); i++) {\n extendPalindrome(s, i, i);\n extendPalindrome(s, i, i + 1);\n }\n \n return result;\n }\n \n public void extendPalindrome(String s, int left, int right) {\n while(left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {\n result++;\n left--;\n right++;\n }\n }\n}\n\n"
},
{
"path": "company/facebook/PowerOfXToTheN.java",
"content": "// Implement pow(x, n).\n\npublic class PowerOfXToTheN {\n public double myPow(double x, int n) {\n if(n == 0) {\n return 1;\n }\n \n if(Double.isInfinite(x)) {\n return 0;\n }\n \n if(n < 0) {\n n = -n;\n x = 1 / x;\n }\n \n return n % 2 == 0 ? myPow(x * x, n / 2) : x * myPow(x * x, n / 2);\n }\n}\n"
},
{
"path": "company/facebook/ProductOfArrayExceptSelf.java",
"content": "// Given an array of n integers where n > 1, nums, return an array output such that output[i] is equal to the product of all the elements of nums except nums[i].\n\n// Solve it without division and in O(n).\n\n// For example, given [1,2,3,4], return [24,12,8,6].\n\n// Follow up:\n// Could you solve it with constant space complexity? (Note: The output array does not count as extra space for the purpose of space complexity analysis.)\n\npublic class ProductOfArrayExceptSelf {\n public int[] productExceptSelf(int[] nums) {\n int n = nums.length;\n int[] result = new int[n];\n int left = 1;\n \n for(int i = 0; i < nums.length; i++) {\n if(i > 0) {\n left *= nums[i - 1];\n }\n \n result[i] = left;\n }\n \n int right = 1;\n \n for(int i = n - 1; i >= 0; i--) {\n if(i < n - 1) {\n right *= nums[i + 1];\n }\n \n result[i] *= right;\n }\n \n return result;\n }\n}\n"
},
{
"path": "company/facebook/RegularExpressionMatching.java",
"content": "// Implement regular expression matching with support for '.' and '*'.\n\n// '.' Matches any single character.\n// '*' Matches zero or more of the preceding element.\n\n// The matching should cover the entire input string (not partial).\n\n// The function prototype should be:\n// bool isMatch(const char *s, const char *p)\n\n// Some examples:\n// isMatch(\"aa\",\"a\") → false\n// isMatch(\"aa\",\"aa\") → true\n// isMatch(\"aaa\",\"aa\") → false\n// isMatch(\"aa\", \"a*\") → true\n// isMatch(\"aa\", \".*\") → true\n// isMatch(\"ab\", \".*\") → true\n// isMatch(\"aab\", \"c*a*b\") → true\n\npublic class RegularExpressionMatching {\n public boolean isMatch(String s, String p) {\n if(s == null || p == null) {\n return false;\n }\n \n boolean[][] dp = new boolean[s.length() + 1][p.length() + 1];\n dp[0][0] = true;\n \n for(int i = 0; i < p.length(); i++) {\n if(p.charAt(i) == '*' && dp[0][i - 1]) {\n dp[0][i + 1] = true;\n }\n }\n \n for(int i = 0; i < s.length(); i++) {\n for(int j = 0; j < p.length(); j++) {\n if(p.charAt(j) == '.') {\n dp[i + 1][j + 1] = dp[i][j];\n }\n \n if(p.charAt(j) == s.charAt(i)) {\n dp[i + 1][j + 1] = dp[i][j];\n }\n \n if(p.charAt(j) == '*') {\n if(p.charAt(j - 1) != s.charAt(i) && p.charAt(j - 1) != '.') {\n dp[i + 1][j + 1] = dp[i + 1][j - 1];\n } else {\n dp[i + 1][j + 1] = (dp[i + 1][j] || dp[i][j + 1] || dp[i + 1][j - 1]);\n }\n }\n }\n }\n \n return dp[s.length()][p.length()];\n }\n}\n"
},
{
"path": "company/facebook/RemoveDuplicatesFromSortedArray.java",
"content": "// Given a sorted array, remove the duplicates in place such that each element appear only once and return the new length.\n\n// Do not allocate extra space for another array, you must do this in place with constant memory.\n\n// For example,\n// Given input array nums = [1,1,2],\n\n// Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively. It doesn't matter what you leave beyond the new length.\n\npublic class RemoveDuplicatesFromSortedArray {\n public int removeDuplicates(int[] nums) {\n if(nums.length == 0 || nums == null) {\n return 0;\n }\n\n if(nums.length < 2) {\n return nums.length;\n }\n \n int index = 1;\n \n for(int i = 1; i < nums.length; i++) {\n if(nums[i] != nums[i - 1]) {\n nums[index++] = nums[i];\n }\n }\n \n return index;\n }\n}\n"
},
{
"path": "company/facebook/RemoveInvalidParentheses.java",
"content": "// Remove the minimum number of invalid parentheses in order to make the input string valid. Return all possible results.\n\n// Note: The input string may contain letters other than the parentheses ( and ).\n\n// Examples:\n// \"()())()\" -> [\"()()()\", \"(())()\"]\n// \"(a)())()\" -> [\"(a)()()\", \"(a())()\"]\n// \")(\" -> [\"\"]\n\npublic class RemoveInvalidParentheses {\n public List removeInvalidParentheses(String s) {\n List result = new ArrayList<>();\n\n remove(s, result, 0, 0, new char[]{'(', ')'});\n\n return result;\n }\n\n public void remove(String s, List result, int last_i, int last_j, char[] par) {\n for (int stack = 0, i = last_i; i < s.length(); i++) {\n if (s.charAt(i) == par[0]) {\n stack++;\n }\n\n if (s.charAt(i) == par[1]) {\n stack--;\n }\n\n if (stack >= 0) {\n continue;\n }\n \n for (int j = last_j; j <= i; j++) {\n if (s.charAt(j) == par[1] && (j == last_j || s.charAt(j - 1) != par[1])) {\n remove(s.substring(0, j) + s.substring(j + 1, s.length()), result, i, j, par);\n }\n }\n\n return;\n }\n \n String reversed = new StringBuilder(s).reverse().toString();\n \n if (par[0] == '(') {\n // finished left to right\n remove(reversed, result, 0, 0, new char[]{')', '('});\n } else {\n // finished right to left\n result.add(reversed);\n }\n }\n}\n"
},
{
"path": "company/facebook/ReverseLinkedList.java",
"content": "// Reverse a singly linked list.\n\n/**\n * Definition for singly-linked list.\n * public class ListNode {\n * int val;\n * ListNode next;\n * ListNode(int x) { val = x; }\n * }\n */\npublic class ReverseLinkedList {\n public ListNode reverseList(ListNode head) {\n if(head == null) {\n return head;\n }\n \n ListNode newHead = null;\n \n while(head != null) {\n ListNode next = head.next;\n head.next = newHead;\n newHead = head;\n head = next;\n }\n \n return newHead;\n }\n}\n"
},
{
"path": "company/facebook/RomanToInteger.java",
"content": "// Given a roman numeral, convert it to an integer.\n\n// Input is guaranteed to be within the range from 1 to 3999\n\npublic class RomanToInteger {\n public int romanToInt(String s) {\n HashMap map = new HashMap();\n \n map.put('I', 1);\n map.put('V', 5);\n map.put('X', 10);\n map.put('L', 50);\n map.put('C', 100);\n map.put('D', 500);\n map.put('M', 1000);\n \n int total = 0;\n\n for(int i = 0; i < s.length() - 1; i++) {\n if(map.get(s.charAt(i)) < map.get(s.charAt(i + 1))) {\n total -= map.get(s.charAt(i));\n } else {\n total += map.get(s.charAt(i));\n }\n }\n \n total += map.get(s.charAt(s.length() - 1));\n \n return total;\n }\n}\n"
},
{
"path": "company/facebook/SearchInRotatedSortedArray.java",
"content": "// Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.\n\n// (i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2).\n\n// You are given a target value to search. If found in the array return its index, otherwise return -1.\n\n// You may assume no duplicate exists in the array.\n\npublic class SearchInRotatedSortedArray {\n public int search(int[] nums, int target) {\n int left = 0;\n int right = nums.length - 1;\n \n while(left <= right) {\n int mid = left + (right - left) / 2;\n \n if(nums[mid] == target) {\n return mid;\n }\n \n if(nums[left] <= nums[mid]) {\n if(target < nums[mid] && target >= nums[left]) {\n right = mid - 1;\n } else {\n left = mid + 1;\n }\n }\n \n if(nums[mid] <= nums[right]) {\n if(target > nums[mid] && target <= nums[right]) {\n left = mid + 1;\n } else {\n right = mid - 1;\n }\n }\n }\n \n return -1;\n }\n}\n"
},
{
"path": "company/facebook/SortColors.java",
"content": "// Given an array with n objects colored red, white or blue, sort them so that objects of the same color are adjacent, with the colors in the order red, white and blue.\n\n// Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.\n\n// Note:\n // You are not suppose to use the library's sort function for this problem.\n\npublic class SortColors {\n public void sortColors(int[] nums) {\n int wall = 0;\n \n for(int i = 0; i < nums.length; i++) {\n if(nums[i] < 1) {\n int temp = nums[i];\n nums[i] = nums[wall];\n nums[wall] = temp;\n wall++;\n }\n }\n \n for(int i = 0; i < nums.length; i++) {\n if(nums[i] == 1) {\n int temp = nums[i];\n nums[i] = nums[wall];\n nums[wall] = temp;\n wall++;\n }\n }\n }\n}\n"
},
{
"path": "company/facebook/SparseMatrixMultiplication.java",
"content": "// Given two sparse matrices A and B, return the result of AB.\n\n// You may assume that A's column number is equal to B's row number.\n\n// Example:\n\n// A = [\n// [ 1, 0, 0],\n// [-1, 0, 3]\n// ]\n\n// B = [\n// [ 7, 0, 0 ],\n// [ 0, 0, 0 ],\n// [ 0, 0, 1 ]\n// ]\n\n\n// | 1 0 0 | | 7 0 0 | | 7 0 0 |\n// AB = | -1 0 3 | x | 0 0 0 | = | -7 0 3 |\n// | 0 0 1 |\n\npublic class SparseMatrixMultiplication {\n public int[][] multiply(int[][] A, int[][] B) {\n int m = A.length;\n int n = A[0].length;\n int nB = B[0].length;\n int[][] C = new int[m][nB];\n \n for(int i = 0; i < m; i++) {\n for(int j = 0; j < n; j++) {\n if(A[i][j] != 0) {\n for(int k = 0; k < nB; k++) {\n if(B[j][k] != 0) {\n C[i][k] += A[i][j] * B[j][k];\n }\n }\n }\n }\n }\n \n return C;\n }\n}\n"
},
{
"path": "company/facebook/SquareRootX.java",
"content": "// Implement int sqrt(int x).\n\n// Compute and return the square root of x.\n\npublic class SquareRootX {\n public int mySqrt(int x) {\n if(x == 0) {\n return 0;\n }\n \n int left = 1;\n int right = x;\n \n while(left <= right) {\n int mid = left + (right - left) / 2;\n\n if(mid == x / mid) {\n return mid;\n } else if(mid > x / mid) {\n right = mid - 1;\n } else if(mid < x / mid) {\n left = mid + 1;\n }\n }\n \n return right;\n }\n}\n"
},
{
"path": "company/facebook/Subsets.java",
"content": "// Given a set of distinct integers, nums, return all possible subsets.\n\n// Note: The solution set must not contain duplicate subsets.\n\n// For example,\n// If nums = [1,2,3], a solution is:\n\n// [\n// [3],\n// [1],\n// [2],\n// [1,2,3],\n// [1,3],\n// [2,3],\n// [1,2],\n// []\n// ]\n\npublic class Subsets {\n public List> subsets(int[] nums) {\n List> result = new ArrayList<>();\n \n recurse(result, nums, new Stack<>(), 0);\n \n return result;\n }\n \n \n private void recurse(List> result, int[] nums, Stack path, int position) {\n if(position == nums.length) {\n result.add(new ArrayList<>(path));\n\n return;\n }\n \n path.push(nums[position]);\n\n recurse(result, nums, path, position + 1);\n \n path.pop();\n \n recurse(result, nums, path, position + 1);\n }\n}\n"
},
{
"path": "company/facebook/SubsetsII.java",
"content": " // Given a collection of integers that might contain duplicates, nums, return all possible subsets.\n\n// Note: The solution set must not contain duplicate subsets.\n\n// For example,\n// If nums = [1,2,2], a solution is:\n\n// [\n// [2],\n// [1],\n// [1,2,2],\n// [2,2],\n// [1,2],\n// []\n// ]\n\npublic class SubsetsII {\n public List> subsetsWithDup(int[] nums) {\n Arrays.sort(nums);\n \n List> result = new ArrayList>();\n \n if(nums.length == 0 || nums == null) {\n return result;\n }\n \n helper(nums, new ArrayList(), 0, result);\n \n return result;\n }\n \n \n public void helper(int[] nums, ArrayList current, int index, List> result) {\n result.add(current);\n \n for(int i = index; i < nums.length; i++) {\n if(i > index && nums[i] == nums[i - 1]) {\n continue;\n }\n \n ArrayList newCurrent = new ArrayList(current);\n\n newCurrent.add(nums[i]);\n\n helper(nums, newCurrent, i + 1, result);\n }\n }\n}\n"
},
{
"path": "company/facebook/SumOfLeftLeaves.java",
"content": "// Find the sum of all left leaves in a given binary tree.\n\n// Example:\n\n// 3\n// / \\\n// 9 20\n// / \\\n// 15 7\n\n// There are two left leaves in the binary tree, with values 9 and 15 respectively. Return 24.\n\n/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) { val = x; }\n * }\n */\npublic class SumOfLeftLeaves {\n public int sumOfLeftLeaves(TreeNode root) {\n if(root == null) {\n return 0;\n }\n \n int total = 0;\n \n if(root.left != null) {\n if(root.left.left == null && root.left.right == null) {\n total += root.left.val;\n } else {\n total += sumOfLeftLeaves(root.left);\n }\n }\n \n total += sumOfLeftLeaves(root.right);\n \n return total;\n }\n}\n"
},
{
"path": "company/facebook/TwoSum.java",
"content": "// Given an array of integers, return indices of the two numbers such that they add up to a specific target.\n\n// You may assume that each input would have exactly one solution, and you may not use the same element twice.\n\n// Example:\n// Given nums = [2, 7, 11, 15], target = 9,\n\n// Because nums[0] + nums[1] = 2 + 7 = 9,\n// return [0, 1].\n\npublic class TwoSum {\n public int[] twoSum(int[] nums, int target) {\n int[] result = new int[2];\n \n HashMap map = new HashMap<>();\n \n for(int i = 0; i < nums.length; i++) {\n if(map.containsKey(target - nums[i])) {\n result[1] = i;\n result[0] = map.get(target - nums[i]);\n\n return result;\n }\n \n map.put(nums[i], i);\n }\n \n return result;\n }\n}\n"
},
{
"path": "company/facebook/ValidPalindrome.java",
"content": "public class ValidPalindrome {\n public boolean isPalindrome(String s) {\n int left = 0;\n int right = s.length() - 1;\n \n while(left < right) {\n while(!Character.isLetterOrDigit(s.charAt(left)) && left < right) {\n left++;\n }\n\n while(!Character.isLetterOrDigit(s.charAt(right)) && right > left) {\n right--;\n }\n \n if(Character.toLowerCase(s.charAt(left)) != Character.toLowerCase(s.charAt(right))) {\n return false;\n }\n \n left++;\n right--;\n }\n \n return true;\n }\n}\n"
},
{
"path": "company/facebook/ValidParentheses.java",
"content": "// Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.\n\n// The brackets must close in the correct order, \"()\" and \"()[]{}\" are all valid but \"(]\" and \"([)]\" are not.\n\npublic class ValidParentheses {\n public boolean isValid(String s) {\n if(s.length() % 2 == 1) {\n return false;\n }\n \n Stack stack = new Stack();\n \n for(int i = 0; i < s.length(); i++) {\n if(s.charAt(i) == '(' || s.charAt(i) == '[' || s.charAt(i) == '{') {\n stack.push(s.charAt(i));\n } else if(s.charAt(i) == ')' && !stack.isEmpty() && stack.peek() == ')') {\n stack.pop();\n } else if(s.charAt(i) == ']' && !stack.isEmpty() && stack.peek() == ']') {\n stack.pop();\n } else if(s.charAt(i) == '}' && !stack.isEmpty() && stack.peek() == '}') {\n stack.pop();\n } else {\n return false;\n }\n }\n \n return stack.isEmpty();\n }\n}\n"
},
{
"path": "company/facebook/ValidateBinarySearchTree.java",
"content": "// Given a binary tree, determine if it is a valid binary search tree (BST).\n\n// Assume a BST is defined as follows:\n\n// The left subtree of a node contains only nodes with keys less than the node's key.\n// The right subtree of a node contains only nodes with keys greater than the node's key.\n// Both the left and right subtrees must also be binary search trees.\n// Example 1:\n// 2\n// / \\\n// 1 3\n// Binary tree [2,1,3], return true.\n// Example 2:\n// 1\n// / \\\n// 2 3\n// Binary tree [1,2,3], return false.\n\n/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) { val = x; }\n * }\n */\npublic class ValidateBinarySearchTree {\n public boolean isValidBST(TreeNode root) {\n if(root == null) {\n return true;\n }\n \n return validBSTRecursive(root, Long.MIN_VALUE, Long.MAX_VALUE);\n }\n \n public boolean validBSTRecursive(TreeNode root, long minValue, long maxValue) {\n if(root == null) {\n return true;\n } else if(root.val >= maxValue || root.val <= minValue) {\n return false;\n } else {\n return validBSTRecursive(root.left, minValue, root.val) && validBSTRecursive(root.right, root.val, maxValue);\n }\n }\n}\n"
},
{
"path": "company/facebook/WallsAndGates.java",
"content": "// You are given a m x n 2D grid initialized with these three possible values.\n\n// -1 - A wall or an obstacle.\n// 0 - A gate.\n// 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.\n// 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.\n\n// For example, given the 2D grid:\n// INF -1 0 INF\n// INF INF INF -1\n// INF -1 INF -1\n// 0 -1 INF INF\n// After running your function, the 2D grid should be:\n// 3 -1 0 1\n// 2 2 1 -1\n// 1 -1 2 -1\n// 0 -1 3 4\n\npublic class WallsAndGates {\n public void wallsAndGates(int[][] rooms) {\n //iterate through the matrix calling dfs on all indices that contain a zero\n for(int i = 0; i < rooms.length; i++) {\n for(int j = 0; j < rooms[0].length; j++) {\n if(rooms[i][j] == 0) {\n dfs(rooms, i, j, 0);\n }\n }\n }\n } \n\n void dfs(int[][] rooms, int i, int j, int distance) {\n //if you have gone out of the bounds of the array or you have run into a wall/obstacle, return\n // room[i][j] < distance also ensure that we do not overwrite any previously determined distance if it is shorter than our current distance\n if(i < 0 || i >= rooms.length || j < 0 || j >= rooms[0].length || rooms[i][j] < distance) {\n return;\n }\n \n //set current index's distance to distance\n rooms[i][j] = distance;\n \n //recurse on all adjacent neighbors of rooms[i][j]\n dfs(rooms, i + 1, j, distance + 1);\n dfs(rooms, i - 1, j, distance + 1);\n dfs(rooms, i, j + 1, distance + 1);\n dfs(rooms, i, j - 1, distance + 1);\n }\n}\n"
},
{
"path": "company/facebook/WordBreak.java",
"content": "// Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, determine if s can be segmented into a space-separated sequence of one or more dictionary words. You may assume the dictionary does not contain duplicate words.\n\n// For example, given\n// s = \"leetcode\",\n// dict = [\"leet\", \"code\"].\n\n// Return true because \"leetcode\" can be segmented as \"leet code\".\n\npublic class WordBreak {\n public boolean wordBreak(String s, Set wordDict) {\n boolean[] dp = new boolean[s.length() + 1];\n \n dp[0] = true;\n \n for(int i = 1; i <= s.length(); i++) {\n for(int j = 0; j < i; j++) {\n if(dp[j] && wordDict.contains(s.substring(j, i))) {\n dp[i] = true;\n break;\n }\n }\n }\n \n return dp[s.length()];\n }\n}\n"
},
{
"path": "company/facebook/WordSearch.java",
"content": "// Given a 2D board and a word, find if the word exists in the grid.\n\n// The word can 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.\n\n// For example,\n// Given board =\n\n// [\n// ['A','B','C','E'],\n// ['S','F','C','S'],\n// ['A','D','E','E']\n// ]\n// word = \"ABCCED\", -> returns true,\n// word = \"SEE\", -> returns true,\n// word = \"ABCB\", -> returns false.\n\npublic class WordSearch {\n public boolean exist(char[][] board, String word) {\n char[] w = word.toCharArray();\n \n for(int i = 0; i < board.length; i++) {\n for(int j = 0; j < board[0].length; j++) {\n if(search(board, i, j, w, 0)) {\n return true;\n }\n }\n }\n \n return false;\n }\n \n \n public boolean search(char[][] board, int i, int j, char[] w, int index) {\n if(index == w.length) {\n return true;\n }\n \n if(i < 0 || i >= board.length || j < 0 || j >= board[0].length) {\n return false;\n }\n\n if(board[i][j] != w[index]) {\n return false;\n }\n \n board[i][j] ^= 256;\n\n boolean exist = search(board, i + 1, j, w, index + 1) ||\n search(board, i - 1, j, w, index + 1) ||\n search(board, i, j + 1, w, index + 1) ||\n search(board, i, j - 1, w, index + 1);\n board[i][j] ^= 256;\n\n return exist;\n }\n}\n"
},
{
"path": "company/google/3SumSmaller.java",
"content": "// Given an array of n integers nums and a target, find the number of index triplets i, j, k with 0 <= i < j < k < n that satisfy the condition nums[i] + nums[j] + nums[k] < target.\n\n// For example, given nums = [-2, 0, 1, 3], and target = 2.\n\n// Return 2. Because there are two triplets which sums are less than 2:\n\n// [-2, 0, 1]\n// [-2, 0, 3]\n\n// Follow up:\n // Could you solve it in O(n2) runtime?\n\npublic class 3SumSmaller {\n public int threeSumSmaller(int[] nums, int target) {\n //initialize total count to zero\n int count = 0;\n \n //sort the array\n Arrays.sort(nums);\n \n //loop through entire array\n for(int i = 0; i < nums.length - 2; i++) {\n //set left to i + 1\n int left = i + 1;\n //set right to end of array\n int right = nums.length - 1;\n \n //while left index < right index\n while(left < right) {\n //if the 3 indices add to less than the target increment count\n if(nums[i] + nums[left] + nums[right] < target) {\n //increment the count by the distance between left and right because the array is sorted\n count += right - left;\n \n //increment left pointer\n left++;\n } else {\n //if they sum to a value greater than target...\n //decrement right pointer\n right--;\n }\n }\n }\n \n return count;\n }\n}\n"
},
{
"path": "company/google/AndroidUnlockPatterns.java",
"content": "// Given an Android 3x3 key lock screen and two integers m and n, where 1 ≤ m ≤ n ≤ 9, count the total number of unlock patterns of the Android lock screen, which consist of minimum of m keys and maximum n keys.\n\n// Rules for a valid pattern:\n // Each pattern must connect at least m keys and at most n keys.\n // All the keys must be distinct.\n // If the line connecting two consecutive keys in the pattern passes through any other keys, the other keys must have previously selected in the pattern. No jumps through non selected key is allowed.\n // The order of keys used matters.\n\n// Explanation:\n// | 1 | 2 | 3 |\n// | 4 | 5 | 6 |\n// | 7 | 8 | 9 |\n// Invalid move: 4 - 1 - 3 - 6 \n// Line 1 - 3 passes through key 2 which had not been selected in the pattern.\n\n// Invalid move: 4 - 1 - 9 - 2\n// Line 1 - 9 passes through key 5 which had not been selected in the pattern.\n\n// Valid move: 2 - 4 - 1 - 3 - 6\n// Line 1 - 3 is valid because it passes through key 2, which had been selected in the pattern\n\n// Valid move: 6 - 5 - 4 - 1 - 9 - 2\n// Line 1 - 9 is valid because it passes through key 5, which had been selected in the pattern.\n\n// Example:\n// Given m = 1, n = 1, return 9.\n\npublic class AndroidUnlockPatterns {\n public int numberOfPatterns(int m, int n) {\n //initialize a 10x10 matrix\n int skip[][] = new int[10][10];\n \n //initialize indices of skip matrix (all other indices in matrix are 0 by default)\n skip[1][3] = skip[3][1] = 2;\n skip[1][7] = skip[7][1] = 4;\n skip[3][9] = skip[9][3] = 6;\n skip[7][9] = skip[9][7] = 8;\n skip[1][9] = skip[9][1] = skip[2][8] = skip[8][2] = skip[3][7] = skip [7][3] = skip[6][4] = skip[4][6] = 5;\n \n //initialize visited array\n boolean visited[] = new boolean[10];\n \n //initialize total number to 0\n int totalNumber = 0;\n \n //run DFS for each length from m to n\n for(int i = m; i <= n; ++i) {\n totalNumber += DFS(visited, skip, 1, i - 1) * 4; //1, 3, 7, and 9 are symmetric so multiply this result by 4\n totalNumber += DFS(visited, skip, 2, i - 1) * 4; //2, 4, 6, and 8 are symmetric so multiply this result by 4\n totalNumber += DFS(visited, skip, 5, i - 1); //do not multiply by 4 because 5 is unique \n }\n \n return totalNumber;\n }\n \n int DFS(boolean visited[], int[][] skip, int current, int remaining) {\n //base cases\n if(remaining < 0) {\n return 0;\n }\n\n if(remaining == 0) {\n return 1;\n }\n \n //mark the current node as visited\n visited[current] = true;\n \n //initialize total number to 0\n int totalNumber = 0;\n \n for(int i = 1; i <= 9; ++i) {\n //if the current node has not been visited and (two numbers are adjacent or skip number has already been visited)\n if(!visited[i] && (skip[current][i] == 0 || visited[skip[current][i]])) {\n totalNumber += DFS(visited, skip, i, remaining - 1);\n }\n }\n \n //mark the current node as not visited\n visited[current] = false;\n \n //return total number\n return totalNumber;\n }\n}\n"
},
{
"path": "company/google/BinarySearchTreeIterator.java",
"content": "// Implement an iterator over a binary search tree (BST). Your iterator will be initialized with the root node of a BST.\n\n// Calling next() will return the next smallest number in the BST.\n\n// Note: next() and hasNext() should run in average O(1) time and uses O(h) memory, where h is the height of the tree.\n\n/**\n * Definition for binary tree\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) { val = x; }\n * }\n */\n\npublic class BinarySearchTreeIterator {\n Stack stack;\n\n public BSTIterator(TreeNode root) {\n stack = new Stack();\n \n while(root != null) {\n stack.push(root);\n root = root.left;\n }\n }\n\n /** @return whether we have a next smallest number */\n public boolean hasNext() {\n return stack.isEmpty() ? false : true;\n }\n\n /** @return the next smallest number */\n public int next() {\n TreeNode nextSmallest = stack.pop();\n \n TreeNode addToStack = nextSmallest.right;\n \n while(addToStack != null) {\n stack.add(addToStack);\n addToStack = addToStack.left;\n }\n \n return nextSmallest.val;\n }\n}\n\n/**\n * Your BSTIterator will be called like this:\n * BSTIterator i = new BSTIterator(root);\n * while (i.hasNext()) v[f()] = i.next();\n */\n"
},
{
"path": "company/google/BinaryTreePaths.java",
"content": "// Given a binary tree, return all root-to-leaf paths.\n\n// For example, given the following binary tree:\n\n// 1\n// / \\\n// 2 3\n// \\\n// 5\n// All root-to-leaf paths are:\n\n// [\"1->2->5\", \"1->3\"]\n\n/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) { val = x; }\n * }\n */\npublic class BinaryTreePaths {\n public List binaryTreePaths(TreeNode root) {\n List result = new ArrayList();\n \n if(root == null) {\n return result;\n }\n \n helper(new String(), root, result);\n \n return result;\n }\n \n public void helper(String current, TreeNode root, List result) {\n if(root.left == null && root.right == null) {\n result.add(current + root.val);\n }\n\n if(root.left != null) {\n helper(current + root.val + \"->\", root.left, result);\n }\n\n if(root.right != null) {\n helper(current + root.val + \"->\", root.right, result);\n }\n }\n}\n"
},
{
"path": "company/google/BinaryTreeVerticalOrderTraversal.java",
"content": "// Given a binary tree, return the vertical order traversal of its nodes' values. (ie, from top to bottom, column by column).\n\n// If two nodes are in the same row and column, the order should be from left to right.\n\n// Examples:\n\n// Given binary tree [3,9,20,null,null,15,7],\n// 3\n// /\\\n// / \\\n// 9 20\n// /\\\n// / \\\n// 15 7\n// return its vertical order traversal as:\n// [\n// [9],\n// [3,15],\n// [20],\n// [7]\n// ]\n// Given binary tree [3,9,8,4,0,1,7],\n// 3\n// /\\\n// / \\\n// 9 8\n// /\\ /\\\n// / \\/ \\\n// 4 01 7\n// return its vertical order traversal as:\n// [\n// [4],\n// [9],\n// [3,0,1],\n// [8],\n// [7]\n// ]\n// Given binary tree [3,9,8,4,0,1,7,null,null,null,2,5] (0's right child is 2 and 1's left child is 5),\n// 3\n// /\\\n// / \\\n// 9 8\n// /\\ /\\\n// / \\/ \\\n// 4 01 7\n// /\\\n// / \\\n// 5 2\n// return its vertical order traversal as:\n// [\n// [4],\n// [9,5],\n// [3,0,1],\n// [8,2],\n// [7]\n// ]\n\n/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) { val = x; }\n * }\n */\npublic class BinaryTreeVerticalOrderTraversal {\n public List> verticalOrder(TreeNode root) {\n List> result = new ArrayList<>();\n \n if(root == null) {\n return result;\n }\n \n Map> map = new HashMap<>();\n Queue q = new LinkedList<>();\n Queue cols = new LinkedList<>();\n \n q.add(root);\n cols.add(0);\n \n int min = 0;\n int max = 0;\n \n while(!q.isEmpty()) {\n TreeNode node = q.poll();\n int col = cols.poll();\n \n if(!map.containsKey(col)) {\n map.put(col, new ArrayList());\n }\n \n map.get(col).add(node.val);\n \n if(node.left != null) {\n q.add(node.left);\n cols.add(col - 1);\n min = Math.min(min, col - 1);\n }\n \n if(node.right != null) {\n q.add(node.right);\n cols.add(col + 1);\n max = Math.max(max, col + 1);\n }\n }\n \n for(int i = min; i <= max; i++) {\n result.add(map.get(i));\n }\n \n return result;\n }\n}\n"
},
{
"path": "company/google/BinaryWatch.java",
"content": "// A binary watch has 4 LEDs on the top which represent the hours (0-11), and the 6 LEDs on the bottom represent the minutes (0-59).\n\n// Each LED represents a zero or one, with the least significant bit on the right.\n\n// For example, the above binary watch reads \"3:25\".\n\n// Given a non-negative integer n which represents the number of LEDs that are currently on, return all possible times the watch could represent.\n\n// Example:\n\n// Input: n = 1\n// Return: [\"1:00\", \"2:00\", \"4:00\", \"8:00\", \"0:01\", \"0:02\", \"0:04\", \"0:08\", \"0:16\", \"0:32\"]\n// Note:\n// The order of output does not matter.\n// The hour must not contain a leading zero, for example \"01:00\" is not valid, it should be \"1:00\".\n// The minute must be consist of two digits and may contain a leading zero, for example \"10:2\" is not valid, it should be \"10:02\".\n\npublic class BinaryWatch {\n public List readBinaryWatch(int num) {\n ArrayList allTimes = new ArrayList();\n \n //iterate through all possible time combinations\n for(int i = 0; i < 12; i++) {\n for(int j = 0; j < 60; j++) {\n //if the current number and n have the same number of bits the time is possible\n if(Integer.bitCount(i * 64 + j) == num) {\n //add the current time to all times arraylist\n allTimes.add(String.format(\"%d:%02d\", i, j));\n }\n }\n }\n \n return allTimes;\n }\n}\n"
},
{
"path": "company/google/BombEnemy.java",
"content": "// Given a 2D grid, each cell is either a wall 'W', an enemy 'E' or empty '0' (the number zero), return the maximum enemies you can kill using one bomb.\n// The bomb kills all the enemies in the same row and column from the planted point until it hits the wall since the wall is too strong to be destroyed.\n// Note that you can only put the bomb at an empty cell.\n\n// Example:\n// For the given grid\n\n// 0 E 0 0\n// E 0 W E\n// 0 E 0 0\n\n// return 3. (Placing a bomb at (1,1) kills 3 enemies)\n\n public class BombEnemy {\n public int maxKilledEnemies(char[][] grid) {\n if(grid == null || grid.length == 0 || grid[0].length == 0) {\n return 0;\n }\n\n int max = 0;\n int row = 0;\n int[] col = new int[grid[0].length];\n\n for(int i = 0; i max) ? row + col[j] : max;\n }\n }\n }\n \n return max;\n }\n\n //calculate killed enemies for row i from column j\n private int killedEnemiesRow(char[][] grid, int i, int j) {\n int num = 0;\n\n while(j <= grid[0].length-1 && grid[i][j] != 'W') {\n if(grid[i][j] == 'E') {\n num++;\n }\n\n j++;\n }\n\n return num;\n }\n\n //calculate killed enemies for column j from row i\n private int killedEnemiesCol(char[][] grid, int i, int j) {\n int num = 0;\n\n while(i <= grid.length -1 && grid[i][j] != 'W'){\n if(grid[i][j] == 'E') {\n num++;\n }\n\n i++;\n }\n\n return num;\n }\n}\n"
},
{
"path": "company/google/BullsAndCows.java",
"content": "//You are playing the following Bulls and Cows game with your friend: You write down a number and ask your friend to guess what the number is. Each time your friend makes a guess, you provide a hint that indicates how many digits in said guess match your secret number exactly in both digit and position (called \"bulls\") and how many digits match the secret number but locate in the wrong position (called \"cows\"). Your friend will use successive guesses and hints to eventually derive the secret number.\n//\n//Write a function to return a hint according to the secret number and friend's guess, use A to indicate the bulls and B to indicate the cows. \n//\n//Please note that both secret number and friend's guess may contain duplicate digits.\n//\n//Example 1:\n//\n//Input: secret = \"1807\", guess = \"7810\"\n//\n//Output: \"1A3B\"\n//\n//Explanation: 1 bull and 3 cows. The bull is 8, the cows are 0, 1 and 7.\n//Example 2:\n//\n//Input: secret = \"1123\", guess = \"0111\"\n//\n//Output: \"1A1B\"\n//\n//Explanation: The 1st 1 in friend's guess is a bull, the 2nd or 3rd 1 is a cow.\n//Note: You may assume that the secret number and your friend's guess only contain digits, and their lengths are always equal.\n\nclass BullsAndCows {\n public String getHint(String secret, String guess) {\n int bulls = 0;\n int cows = 0;\n int[] counts = new int[10];\n for(int i = 0; i < secret.length(); i++) {\n if(secret.charAt(i) == guess.charAt(i)) {\n bulls++;\n } else {\n if(counts[secret.charAt(i) - '0']++ < 0) {\n cows++;\n }\n if(counts[guess.charAt(i) - '0']-- > 0) {\n cows++;\n }\n }\n }\n \n return bulls + \"A\" + cows + \"B\";\n }\n}\n"
},
{
"path": "company/google/CloneGraph.java",
"content": "// Clone an undirected graph. Each node in the graph contains a label and a list of its neighbors.\n\n// OJ's undirected graph serialization:\n// Nodes are labeled uniquely.\n\n// We use # as a separator for each node, and , as a separator for node label and each neighbor of the node.\n// As an example, consider the serialized graph {0,1,2#1,2#2,2}.\n\n// The graph has a total of three nodes, and therefore contains three parts as separated by #.\n\n// First node is labeled as 0. Connect node 0 to both nodes 1 and 2.\n// Second node is labeled as 1. Connect node 1 to node 2.\n// Third node is labeled as 2. Connect node 2 to node 2 (itself), thus forming a self-cycle.\n// Visually, the graph looks like the following:\n\n// 1\n// / \\\n// / \\\n// 0 --- 2\n// / \\\n// \\_/\n\n/**\n * Definition for undirected graph.\n * class UndirectedGraphNode {\n * int label;\n * List neighbors;\n * UndirectedGraphNode(int x) { label = x; neighbors = new ArrayList(); }\n * };\n */\npublic class CloneGraph {\n public HashMap map = new HashMap();\n \n public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {\n if(node == null) {\n return null;\n }\n \n if(map.containsKey(node.label)) {\n return map.get(node.label);\n }\n \n UndirectedGraphNode newNode = new UndirectedGraphNode(node.label);\n map.put(newNode.label, newNode);\n \n for(UndirectedGraphNode neighbor : node.neighbors) {\n newNode.neighbors.add(cloneGraph(neighbor));\n }\n \n return newNode;\n }\n}\n"
},
{
"path": "company/google/ClosestBinarySearchTreeValue.java",
"content": "// Given a non-empty binary search tree and a target value, find the value in the BST that is closest to the target.\n\n// Note:\n\t// Given target value is a floating point.\n\t// You are guaranteed to have only one unique value in the BST that is closest to the target.\n\n/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) { val = x; }\n * }\n */\npublic class ClosestBinarySearchTreeValue {\n public int closestValue(TreeNode root, double target) {\n int value = root.val;\n TreeNode child = root.val < target ? root.right : root.left;\n\n if(child == null) {\n return value;\n }\n\n int childValue = closestValue(child, target);\n \n return Math.abs(value - target) < Math.abs(childValue - target) ? value : childValue;\n }\n}\n"
},
{
"path": "company/google/CombinationSumIV.java",
"content": "// Given an integer array with all positive numbers and no duplicates, find the number of possible combinations that add up to a positive integer target.\n\n// Example:\n\n// nums = [1, 2, 3]\n// target = 4\n\n// The possible combination ways are:\n// (1, 1, 1, 1)\n// (1, 1, 2)\n// (1, 2, 1)\n// (1, 3)\n// (2, 1, 1)\n// (2, 2)\n// (3, 1)\n\n// Note that different sequences are counted as different combinations.\n\n// Therefore the output is 7.\n\n// Follow up:\n // What if negative numbers are allowed in the given array?\n // How does it change the problem?\n // What limitation we need to add to the question to allow negative numbers?\n\npublic class CombinationSumIV {\n public int combinationSum4(int[] nums, int target) {\n int[] dp = new int[target + 1];\n dp[0] = 1;\n \n for(int i = 1; i < dp.length; i++) {\n for(int j = 0; j < nums.length; j++) {\n if(i - nums[j] >= 0) {\n dp[i] += dp[i - nums[j]];\n }\n }\n }\n \n return dp[target];\n }\n}\n"
},
{
"path": "company/google/DailyTemperatures.java",
"content": "//Given a list of daily temperatures, produce a list that, for each day in the input, tells you how many days you would have to wait until a warmer temperature. If there is no future day for which this is possible, put 0 instead.\n//\n//For example, given the list temperatures = [73, 74, 75, 71, 69, 72, 76, 73], your output should be [1, 1, 4, 2, 1, 1, 0, 0].\n//\n//Note: The length of temperatures will be in the range [1, 30000]. Each temperature will be an integer in the range [30, 100].\n\nclass DailyTemperatures {\n public int[] dailyTemperatures(int[] temperatures) {\n int[] result = new int[temperatures.length];\n Stack stack = new Stack();\n for(int i = 0; i < temperatures.length; i++) {\n while(!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]) {\n int index = stack.pop();\n result[index] = i - index;\n }\n stack.push(i);\n }\n \n return result;\n }\n}\n"
},
{
"path": "company/google/DecodeString.java",
"content": "// Given an encoded string, return it's decoded string.\n\n// The encoding rule is: k[encoded_string], where the encoded_string inside the square brackets is being repeated exactly k times. Note that k is guaranteed to be a positive integer.\n\n// You may assume that the input string is always valid; No extra white spaces, square brackets are well-formed, etc.\n\n// Furthermore, you may assume that the original data does not contain any digits and that digits are only for those repeat numbers, k. For example, there won't be input like 3a or 2[4].\n\npublic class DecodeString {\n public String decodeString(String s) {\n //declare empty string\n String decoded = \"\";\n \n //initialize stack to hold counts\n Stack countStack = new Stack();\n \n //initalize stack to hold decoded string\n Stack decodedStack = new Stack();\n \n //initialize index to zero\n int index = 0;\n \n //iterate through entire string\n while(index < s.length()) {\n //if the current character is numeric...\n if(Character.isDigit(s.charAt(index))) {\n int count = 0;\n \n //determine the number\n while(Character.isDigit(s.charAt(index))) {\n count = 10 * count + (s.charAt(index) - '0');\n index++;\n }\n\n //push the number onto the count stack\n countStack.push(count);\n } else if(s.charAt(index) == '[') {\n //if the current character is an opening bracket\n decodedStack.push(decoded);\n decoded = \"\";\n index++;\n } else if(s.charAt(index) == ']') {\n //if the current character is a closing bracket\n StringBuilder temp = new StringBuilder(decodedStack.pop());\n \n int repeatTimes = countStack.pop();\n \n for(int i = 0; i < repeatTimes; i++) {\n temp.append(decoded);\n }\n \n decoded = temp.toString();\n index++;\n } else {\n //otherwise, append the current character to the decoded string\n decoded += s.charAt(index);\n index++;\n }\n }\n \n //return the decoded string\n return decoded;\n }\n}\n"
},
{
"path": "company/google/EncodeAndDecodeTinyURL.java",
"content": "//TinyURL is a URL shortening service where you enter a URL such as https://leetcode.com/problems/design-tinyurl \n//and it returns a short URL such as http://tinyurl.com/4e9iAk.\n//\n//Design the encode and decode methods for the TinyURL service. There is no restriction on how your \n//encode/decode algorithm should work. You just need to ensure that a URL can be encoded to a tiny URL \n//and the tiny URL can be decoded to the original URL.\n\npublic class EncodeAndDecodeTinyURL {\n HashMap map = new HashMap();\n String characters = \"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\";\n int count = 1;\n\n public String getKey() {\n String key = \"\";\n while(count > 0) {\n count--;\n key += characters.charAt(count);\n count /= characters.length();\n }\n \n return key;\n }\n \n // Encodes a URL to a shortened URL.\n public String encode(String longUrl) {\n String key = getKey();\n map.put(key, longUrl);\n count++;\n \n return \"http://tinyurl.com/\" + key;\n }\n\n // Decodes a shortened URL to its original URL.\n public String decode(String shortUrl) {\n return map.get(shortUrl.replace(\"http://tinyurl.com/\", \"\"));\n }\n}\n\n// Your Codec object will be instantiated and called as such:\n// Codec codec = new Codec();\n// codec.decode(codec.encode(url));\n"
},
{
"path": "company/google/ExpressionAddOperators.java",
"content": "// Given a string that contains only digits 0-9 and a target value, return all possibilities to add binary operators (not unary) +, -, or * between the digits so they evaluate to the target value.\n\n// Examples: \n// \"123\", 6 -> [\"1+2+3\", \"1*2*3\"] \n// \"232\", 8 -> [\"2*3+2\", \"2+3*2\"]\n// \"105\", 5 -> [\"1*0+5\",\"10-5\"]\n// \"00\", 0 -> [\"0+0\", \"0-0\", \"0*0\"]\n// \"3456237490\", 9191 -> []\n\npublic class ExpressionAddOperator {\n public List addOperators(String num, int target) {\n List result = new ArrayList();\n\n if(num == null || num.length() == 0) {\n return result;\n }\n\n helper(result, \"\", num, target, 0, 0, 0);\n\n return result;\n }\n \n public void helper(List result, String path, String num, int target, int pos, long eval, long multed) {\n if(pos == num.length()) {\n if(eval == target) {\n result.add(path);\n }\n \n return;\n }\n \n for(int i = pos; i < num.length(); i++) {\n if(i != pos && num.charAt(pos) == '0') {\n break;\n }\n\n long cur = Long.parseLong(num.substring(pos, i + 1));\n\n if(pos == 0) {\n helper(result, path + cur, num, target, i + 1, cur, cur);\n } else {\n helper(result, path + \"+\" + cur, num, target, i + 1, eval + cur, cur);\n helper(result, path + \"-\" + cur, num, target, i + 1, eval - cur, -cur);\n helper(result, path + \"*\" + cur, num, target, i + 1, eval - multed + multed * cur, multed * cur);\n }\n }\n }\n}\n"
},
{
"path": "company/google/FindAllNumbersDisappearedInAnArray.java",
"content": "//Given an array of integers where 1 ≤ a[i] ≤ n (n = size of array), some elements appear twice and others appear once.\n//\n//Find all the elements of [1, n] inclusive that do not appear in this array.\n//\n//Could you do it without extra space and in O(n) runtime? You may assume the returned list does not count as extra space.\n//\n//Example:\n//\n//Input:\n//[4,3,2,7,8,2,3,1]\n//\n//Output:\n//[5,6]\n\nclass FindAllNumbersDisappearedInAnArray {\n public List findDisappearedNumbers(int[] nums) {\n List result = new ArrayList();\n HashMap map = new HashMap();\n for(int i = 1; i <= nums.length; i++) {\n map.put(i, 1);\n }\n \n for(int i = 0; i < nums.length; i++) {\n if(map.containsKey(nums[i])) {\n map.put(nums[i], -1);\n }\n }\n \n for(int i: map.keySet()) {\n if(map.get(i) != -1) {\n result.add(i);\n }\n }\n \n return result;\n }\n}\n"
},
{
"path": "company/google/FindTheDifference.java",
"content": "// Given two strings s and t which consist of only lowercase letters.\n\n// String t is generated by random shuffling string s and then add one more letter at a random position.\n\n// Find the letter that was added in t.\n\n// Example:\n\n// Input:\n// s = \"abcd\"\n// t = \"abcde\"\n\n// Output:\n// e\n\n// Explanation:\n// 'e' is the letter that was added.\n\npublic class FindTheDifference {\n public char findTheDifference(String s, String t) {\n int charCodeS = 0;\n int charCodeT = 0;\n \n for(int i = 0; i < s.length(); i++) {\n charCodeS += (int)(s.charAt(i));\n }\n \n for(int i = 0; i < t.length(); i++) {\n charCodeT += (int)(t.charAt(i));\n }\n \n return (char)(charCodeT - charCodeS);\n }\n}\n"
},
{
"path": "company/google/FirstUniqueCharacterInAString.java",
"content": "//Given a string, find the first non-repeating character in it and return it's index. If it doesn't exist, return -1.\n//\n//Examples:\n//\n//s = \"leetcode\"\n//return 0.\n//\n//s = \"loveleetcode\",\n//return 2.\n//Note: You may assume the string contain only lowercase letters.\n\nclass FirstUniqueCharacterInAString {\n public int firstUniqChar(String s) {\n HashMap characters = new HashMap();\n for(int i = 0; i < s.length(); i++) {\n char current = s.charAt(i);\n if(characters.containsKey(current)) {\n characters.put(current, -1);\n } else {\n characters.put(current, i);\n }\n }\n \n int min = Integer.MAX_VALUE;\n for(char c: characters.keySet()) {\n if(characters.get(c) > -1 && characters.get(c) < min) {\n min = characters.get(c);\n }\n }\n \n return min == Integer.MAX_VALUE ? -1 : min;\n \n }\n}\n"
},
{
"path": "company/google/FlattenNestedListIterator.java",
"content": "// Given a nested list of integers, implement an iterator to flatten it.\n\n// Each element is either an integer, or a list -- whose elements may also be integers or other lists.\n\n// Example 1:\n// Given the list [[1,1],2,[1,1]],\n\n// By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,1,2,1,1].\n\n// Example 2:\n// Given the list [1,[4,[6]]],\n\n// By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,4,6].\n\n/**\n * // This is the interface that allows for creating nested lists.\n * // You should not implement it, or speculate about its implementation\n * public interface NestedInteger {\n *\n * // @return true if this NestedInteger holds a single integer, rather than a nested list.\n * public boolean isInteger();\n *\n * // @return the single integer that this NestedInteger holds, if it holds a single integer\n * // Return null if this NestedInteger holds a nested list\n * public Integer getInteger();\n *\n * // @return the nested list that this NestedInteger holds, if it holds a nested list\n * // Return null if this NestedInteger holds a single integer\n * public List getList();\n * }\n */\npublic class FlattenNestedListIterator implements Iterator {\n Stack stack = new Stack();\n\n public NestedIterator(List nestedList) {\n for(int i = nestedList.size() - 1; i >= 0; i--) {\n stack.push(nestedList.get(i));\n }\n }\n\n @Override\n public Integer next() {\n return stack.pop().getInteger();\n }\n\n @Override\n public boolean hasNext() {\n while(!stack.isEmpty()) {\n NestedInteger current = stack.peek();\n\n if(current.isInteger()) {\n return true;\n }\n\n stack.pop();\n\n for(int i = current.getList().size() - 1; i >= 0; i--) {\n stack.push(current.getList().get(i));\n }\n }\n \n return false;\n }\n}\n\n/**\n * Your NestedIterator object will be instantiated and called as such:\n * NestedIterator i = new NestedIterator(nestedList);\n * while (i.hasNext()) v[f()] = i.next();\n */\n"
},
{
"path": "company/google/GameOfLife.java",
"content": "// According to the Wikipedia's article: \"The Game of Life, also known simply as Life, is a cellular automaton devised by the British mathematician John Horton Conway in 1970.\"\n\n// Given a board with m by n cells, each cell has an initial state live (1) or dead (0). Each cell interacts with its eight neighbors (horizontal, vertical, diagonal) using the following four rules (taken from the above Wikipedia article):\n\n // Any live cell with fewer than two live neighbors dies, as if caused by under-population.\n // Any live cell with two or three live neighbors lives on to the next generation.\n // Any live cell with more than three live neighbors dies, as if by over-population..\n // Any dead cell with exactly three live neighbors becomes a live cell, as if by reproduction.\n // Write a function to compute the next state (after one update) of the board given its current state.\n\n// Follow up: \n// Could you solve it in-place? Remember that the board needs to be updated at the same time: You cannot update some cells first and then use their updated values to update other cells.\n// In this question, we represent the board using a 2D array. In principle, the board is infinite, which would cause problems when the active area encroaches the border of the array. How would you address these problems?\n\npublic class GameOfLife {\n public void gameOfLife(int[][] board) {\n if(board == null || board.length == 0) {\n return;\n }\n \n int m = board.length;\n int n = board[0].length;\n \n for(int i = 0; i < m; i++) {\n for(int j = 0; j < n; j++) {\n int lives = liveNeighbors(board, m, n, i, j);\n\n if(board[i][j] == 1 && lives >= 2 && lives <= 3) {\n board[i][j] = 3;\n }\n \n if(board[i][j] == 0 && lives == 3) {\n board[i][j] = 2;\n }\n }\n }\n \n for(int i = 0; i < m; i++) {\n for(int j = 0; j < n; j++) {\n board[i][j] >>= 1;\n }\n }\n }\n \n private int liveNeighbors(int[][] board, int m, int n, int i, int j) {\n int lives = 0;\n \n for(int x = Math.max(i - 1, 0); x <= Math.min(i + 1, m - 1); x++) {\n for(int y = Math.max(j - 1, 0); y <= Math.min(j + 1, n - 1); y++) {\n lives += board[x][y] & 1;\n }\n }\n \n lives -= board[i][j] & 1;\n \n return lives;\n }\n}\n"
},
{
"path": "company/google/GeneralizedAbbreviation.java",
"content": "// Write a function to generate the generalized abbreviations of a word.\n\n// Example:\n// Given word = \"word\", return the following list (order does not matter):\n// [\"word\", \"1ord\", \"w1rd\", \"wo1d\", \"wor1\", \"2rd\", \"w2d\", \"wo2\", \"1o1d\", \"1or1\", \"w1r1\", \"1o2\", \"2r1\", \"3d\", \"w3\", \"4\"]\n\npublic class GeneralizedAbbreviation {\n public List generateAbbreviations(String word) {\n List result = new ArrayList();\n \n backtrack(result, word, 0, \"\", 0);\n \n return result;\n }\n \n void backtrack(List result, String word, int position, String current, int count) {\n if(position == word.length()) {\n if(count > 0) {\n current += count; \n }\n\n result.add(current);\n } else {\n backtrack(result, word, position + 1, current, count + 1);\n backtrack(result, word, position + 1, current + (count > 0 ? count : \"\") + word.charAt(position), 0);\n }\n } \n}\n"
},
{
"path": "company/google/GenerateParentheses.java",
"content": "//Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.\n//\n//For example, given n = 3, a solution set is:\n//\n//[\n //\"((()))\",\n //\"(()())\",\n //\"(())()\",\n //\"()(())\",\n //\"()()()\"\n//]\n\nclass GenerateParentheses {\n public List generateParenthesis(int n) {\n List result = new ArrayList();\n generateParenthesisRecursive(result, \"\", 0, 0, n);\n \n return result;\n }\n \n public void generateParenthesisRecursive(List result, String current, int open, int close, int n) {\n if(current.length() == n * 2) {\n result.add(current);\n return;\n }\n \n if(open < n) {\n generateParenthesisRecursive(result, current + \"(\", open + 1, close, n);\n }\n \n if(close < open) {\n generateParenthesisRecursive(result, current + \")\", open, close + 1, n);\n }\n }\n}\n"
},
{
"path": "company/google/GroupShiftedStrings.java",
"content": "// Given a string, we can \"shift\" each of its letter to its successive letter, for example: \"abc\" -> \"bcd\". We can keep \"shifting\" which forms the sequence:\n\n// \"abc\" -> \"bcd\" -> ... -> \"xyz\"\n// Given a list of strings which contains only lowercase alphabets, group all strings that belong to the same shifting sequence.\n\n// For example, given: [\"abc\", \"bcd\", \"acef\", \"xyz\", \"az\", \"ba\", \"a\", \"z\"], \n// A solution is:\n\n// [\n// [\"abc\",\"bcd\",\"xyz\"],\n// [\"az\",\"ba\"],\n// [\"acef\"],\n// [\"a\",\"z\"]\n// ]\n\npublic class GroupShiftedStrings {\n public List> groupStrings(String[] strings) {\n List> result = new ArrayList>();\n \n HashMap> map = new HashMap>();\n \n for(String s : strings) {\n int offset = s.charAt(0) - 'a';\n String key = \"\";\n\n for(int i = 0; i < s.length(); i++) {\n char current = (char)(s.charAt(i) - offset);\n \n if(current < 'a') {\n current += 26;\n }\n \n key += current;\n }\n \n if(!map.containsKey(key)) {\n List list = new ArrayList();\n map.put(key, list);\n }\n \n map.get(key).add(s);\n }\n \n for(String key : map.keySet()) {\n List list = map.get(key);\n \n Collections.sort(list);\n \n result.add(list); \n }\n \n return result;\n }\n}\n"
},
{
"path": "company/google/GuessNumberHigherOrLower.java",
"content": "// We are playing the Guess Game. The game is as follows:\n\n// I pick a number from 1 to n. You have to guess which number I picked.\n\n// Every time you guess wrong, I'll tell you whether the number is higher or lower.\n\n// You call a pre-defined API guess(int num) which returns 3 possible results (-1, 1, or 0):\n\n// -1 : My number is lower\n// 1 : My number is higher\n// 0 : Congrats! You got it!\n// Example:\n// n = 10, I pick 6.\n\n// Return 6.\n\n/* The guess API is defined in the parent class GuessGame.\n @param num, your guess\n @return -1 if my number is lower, 1 if my number is higher, otherwise return 0\n int guess(int num); */\n\npublic class GuessNumberHigherOrLower extends GuessGame {\n public int guessNumber(int n) {\n int left = 1;\n int right = n;\n while(left <= right) {\n int mid = left + (right - left) / 2;\n if(guess(mid) == 0) {\n return mid;\n } else if(guess(mid) > 0) {\n left = mid + 1;\n } else {\n right = mid;\n }\n }\n \n return -1;\n }\n}\n"
},
{
"path": "company/google/ImplementTrie.java",
"content": "// Implement a trie with insert, search, and startsWith methods.\n\n// Note:\n// You may assume that all inputs are consist of lowercase letters a-z.\n\n// Your Trie object will be instantiated and called as such:\n// Trie trie = new Trie();\n// trie.insert(\"somestring\");\n// trie.search(\"key\");\n\nclass TrieNode {\n HashMap map;\n char character;\n boolean last;\n \n // Initialize your data structure here.\n public TrieNode(char character) {\n this.map = new HashMap();\n this.character = character;\n this.last = false;\n }\n}\n\npublic class Trie {\n private TrieNode root;\n\n public Trie() {\n root = new TrieNode(' ');\n }\n\n // Inserts a word into the trie.\n public void insert(String word) {\n TrieNode current = root;\n \n for(char c : word.toCharArray()) {\n if(!current.map.containsKey(c)) {\n current.map.put(c, new TrieNode(c));\n }\n \n current = current.map.get(c);\n }\n \n current.last = true;\n }\n\n // Returns if the word is in the trie.\n public boolean search(String word) {\n TrieNode current = root;\n \n for(char c : word.toCharArray()) {\n if(!current.map.containsKey(c)) {\n return false;\n }\n\n current = current.map.get(c);\n }\n \n if(current.last == true) {\n return true;\n } else {\n return false;\n }\n }\n\n // Returns if there is any word in the trie\n // that starts with the given prefix.\n public boolean startsWith(String prefix) {\n TrieNode current = root;\n \n for(char c : prefix.toCharArray()) {\n if(!current.map.containsKey(c)) {\n return false;\n }\n \n current = current.map.get(c);\n }\n \n return true;\n }\n}\n\n"
},
{
"path": "company/google/InsertDeleteGetRandomO1.java",
"content": "//Design a data structure that supports all following operations in average O(1) time.\n\n//insert(val): Inserts an item val to the set if not already present.\n//remove(val): Removes an item val from the set if present.\n//getRandom: Returns a random element from current set of elements. Each element must have the same probability of being returned.\n\n//Example:\n// Init an empty set.\n//RandomizedSet randomSet = new RandomizedSet();\n\n// Inserts 1 to the set. Returns true as 1 was inserted successfully.\n//randomSet.insert(1);\n\n// Returns false as 2 does not exist in the set.\n//randomSet.remove(2);\n\n// Inserts 2 to the set, returns true. Set now contains [1,2].\n//randomSet.insert(2);\n\n// getRandom should return either 1 or 2 randomly.\n//randomSet.getRandom();\n\n// Removes 1 from the set, returns true. Set now contains [2].\n//randomSet.remove(1);\n\n// 2 was already in the set, so return false.\n//randomSet.insert(2);\n\n// Since 2 is the only number in the set, getRandom always return 2.\n//randomSet.getRandom();\n\nclass RandomizedSet {\n HashMap map;\n ArrayList values;\n\n /** Initialize your data structure here. */\n public RandomizedSet() {\n map = new HashMap();\n values = new ArrayList();\n }\n \n /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */\n public boolean insert(int val) {\n if(!map.containsKey(val)) {\n map.put(val, val);\n values.add(val);\n return true;\n }\n else {\n return false;\n }\n }\n \n /** Removes a value from the set. Returns true if the set contained the specified element. */\n public boolean remove(int val) {\n if(map.containsKey(val)) {\n map.remove(val);\n values.remove(values.indexOf(val));\n return true;\n }\n return false;\n }\n \n /** Get a random element from the set. */\n public int getRandom() {\n int random = (int)(Math.random() * values.size());\n int valueToReturn = values.get(random);\n return map.get(valueToReturn);\n }\n}\n\n/**\n * Your RandomizedSet object will be instantiated and called as such:\n * RandomizedSet obj = new RandomizedSet();\n * boolean param_1 = obj.insert(val);\n * boolean param_2 = obj.remove(val);\n * int param_3 = obj.getRandom();\n */\n"
},
{
"path": "company/google/InsertInterval.java",
"content": "// Given a set of non-overlapping intervals, insert a new interval into the intervals (merge if necessary).\n\n// You may assume that the intervals were initially sorted according to their start times.\n\n// Example 1:\n// Given intervals [1,3],[6,9], insert and merge [2,5] in as [1,5],[6,9].\n\n// Example 2:\n// Given [1,2],[3,5],[6,7],[8,10],[12,16], insert and merge [4,9] in as [1,2],[3,10],[12,16].\n\n// This is because the new interval [4,9] overlaps with [3,5],[6,7],[8,10].\n\n/**\n * Definition for an interval.\n * public class Interval {\n * int start;\n * int end;\n * Interval() { start = 0; end = 0; }\n * Interval(int s, int e) { start = s; end = e; }\n * }\n */\npublic class InsertInterval {\n public List insert(List intervals, Interval newInterval) {\n int i = 0;\n\n while(i < intervals.size() && intervals.get(i).end < newInterval.start) {\n i++;\n }\n\n while(i < intervals.size() && intervals.get(i).start <= newInterval.end) {\n newInterval = new Interval(Math.min(intervals.get(i).start, newInterval.start), Math.max(intervals.get(i).end, newInterval.end));\n intervals.remove(i);\n }\n \n intervals.add(i, newInterval);\n\n return intervals;\n }\n}\n"
},
{
"path": "company/google/IslandPerimeter.java",
"content": "// You are given a map in form of a two-dimensional integer grid where 1 represents land and 0 represents water. Grid cells are connected horizontally/vertically (not diagonally). The grid is completely surrounded by water, and there is exactly one island (i.e., one or more connected land cells). The island doesn't have \"lakes\" (water inside that isn't connected to the water around the island). One cell is a square with side length 1. The grid is rectangular, width and height don't exceed 100. Determine the perimeter of the island.\n\n// Example:\n\n// [[0,1,0,0],\n// [1,1,1,0],\n// [0,1,0,0],\n// [1,1,0,0]]\n\n// Answer: 16\n\nclass IslandPerimeter {\n public int islandPerimeter(int[][] grid) {\n int perimeter = 0;\n if(grid == null || grid.length == 0) {\n return perimeter;\n }\n\n for(int i = 0; i < grid.length; i++) {\n for(int j = 0; j < grid[i].length; j++) {\n if(grid[i][j] == 1) {\n perimeter += numNeighbors(grid, i, j);\n return perimeter;\n }\n }\n }\n\n return perimeter;\n }\n\n public int numNeighbors(int[][] grid, int x, int y) {\n if(x < 0 || x >= grid.length || y < 0 || y >= grid[x].length || grid[x][y] == 0) {\n return 1;\n }\n\n if(grid[x][y] == -1) {\n return 0;\n }\n\n grid[x][y] = -1;\n return numNeighbors(grid, x + 1, y) + \n numNeighbors(grid, x - 1, y) + \n numNeighbors(grid, x, y + 1) + \n numNeighbors(grid, x, y - 1);\n }\n}\n"
},
{
"path": "company/google/JudgeRouteCircle.java",
"content": "//Initially, there is a Robot at position (0, 0). Given a sequence of its moves, judge if this robot makes a circle, which means it moves back to the original place.\n//\n//The move sequence is represented by a string. And each move is represent by a character. The valid robot moves are R (Right), L (Left), U (Up) and D (down). The output should be true or false representing whether the robot makes a circle.\n//\n//Example 1:\n//Input: \"UD\"\n//Output: true\n//Example 2:\n//Input: \"LL\"\n//Output: false\n\nclass JudgeRouteCircle {\n public boolean judgeCircle(String moves) {\n int UD = 0;\n int LR = 0;\n for(int i = 0; i < moves.length(); i++) {\n if(moves.charAt(i) == 'U') {\n UD++;\n } else if(moves.charAt(i) == 'D') {\n UD--;\n } else if(moves.charAt(i) == 'L') {\n LR++;\n } else if(moves.charAt(i) == 'R') {\n LR--;\n }\n }\n \n return UD == 0 && LR == 0;\n }\n}\n"
},
{
"path": "company/google/LetterCombinationsOfAPhoneNumber.java",
"content": "// Given a digit string, return all possible letter combinations that the number could represent.\n\n// A mapping of digit to letters (just like on the telephone buttons) is given below.\n\n// 2 - abc\n// 3 - def\n// 4 - ghi\n// 5 - jkl\n// 6 - mno\n// 7 - pqrs\n// 8 - tuv\n// 9 - wxyz\n\n// Input:Digit string \"23\"\n// Output: [\"ad\", \"ae\", \"af\", \"bd\", \"be\", \"bf\", \"cd\", \"ce\", \"cf\"].\n\nclass LetterCombinationsOfAPhoneNumber {\n public List letterCombinations(String digits) {\n List result = new ArrayList();\n \n if(digits == null || digits.length() == 0) {\n return result;\n }\n \n String[] mapping = {\n \"0\",\n \"1\",\n \"abc\",\n \"def\",\n \"ghi\",\n \"jkl\",\n \"mno\",\n \"pqrs\",\n \"tuv\",\n \"wxyz\"\n };\n \n letterCombinationsRecursive(result, digits, \"\", 0, mapping);\n \n return result;\n }\n \n public void letterCombinationsRecursive(List result, String digits, String current, int index, String[] mapping) {\n if(index == digits.length()) {\n result.add(current);\n return;\n }\n \n String letters = mapping[digits.charAt(index) - '0'];\n for(int i = 0; i < letters.length(); i++) {\n letterCombinationsRecursive(result, digits, current + letters.charAt(i), index + 1, mapping);\n }\n }\n}\n"
},
{
"path": "company/google/LoggerRateLimiter.java",
"content": "// Design a logger system that receive stream of messages along with its timestamps, each message should be printed if and only if it is not printed in the last 10 seconds.\n\n// Given a message and a timestamp (in seconds granularity), return true if the message should be printed in the given timestamp, otherwise returns false.\n\n// It is possible that several messages arrive roughly at the same time.\n\n// Example:\n\n// Logger logger = new Logger();\n\n// // logging string \"foo\" at timestamp 1\n// logger.shouldPrintMessage(1, \"foo\"); returns true; \n\n// // logging string \"bar\" at timestamp 2\n// logger.shouldPrintMessage(2,\"bar\"); returns true;\n\n// // logging string \"foo\" at timestamp 3\n// logger.shouldPrintMessage(3,\"foo\"); returns false;\n\n// // logging string \"bar\" at timestamp 8\n// logger.shouldPrintMessage(8,\"bar\"); returns false;\n\n// // logging string \"foo\" at timestamp 10\n// logger.shouldPrintMessage(10,\"foo\"); returns false;\n\n// // logging string \"foo\" at timestamp 11\n// logger.shouldPrintMessage(11,\"foo\"); returns true;\n\npublic class LoggerRateLimiter {\n HashMap messages;\n\n /** Initialize your data structure here. */\n public Logger() {\n this.messages = new HashMap(); \n }\n \n /** Returns true if the message should be printed in the given timestamp, otherwise returns false.\n If this method returns false, the message will not be printed.\n The timestamp is in seconds granularity. */\n public boolean shouldPrintMessage(int timestamp, String message) {\n if(messages.containsKey(message)) {\n if(timestamp - messages.get(message) >= 10) {\n messages.put(message, timestamp);\n\n return true;\n } else {\n return false;\n }\n } else {\n messages.put(message, timestamp);\n\n return true;\n }\n }\n}\n\n/**\n * Your Logger object will be instantiated and called as such:\n * Logger obj = new Logger();\n * boolean param_1 = obj.shouldPrintMessage(timestamp,message);\n */\n"
},
{
"path": "company/google/LongestConsecutiveSequence.java",
"content": "// Given an unsorted array of integers, find the length of the longest consecutive elements sequence.\n\n// For example,\n// Given [100, 4, 200, 1, 3, 2],\n// The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length: 4.\n\n// Your algorithm should run in O(n) complexity.\n\nclass LongestConsecutiveSequence {\n public int longestConsecutive(int[] nums) {\n if(nums == null || nums.length == 0) {\n return 0;\n }\n \n Set set = new HashSet();\n for(int n: nums) {\n set.add(n);\n }\n \n int maxLength = 0;\n for(int n: set) {\n if(!set.contains(n - 1)) {\n int current = n;\n int currentMax = 1;\n \n while(set.contains(n + 1)) {\n currentMax++;\n n++;\n }\n \n maxLength = Math.max(maxLength, currentMax);\n }\n }\n \n return maxLength;\n }\n}\n"
},
{
"path": "company/google/LongestSubstringWithAtMostKDistinctCharacters.java",
"content": "// Given a string, find the length of the longest substring T that contains at most k distinct characters.\n\n// For example, Given s = “eceba” and k = 2,\n\n// T is \"ece\" which its length is 3.\n\npublic class LongestSubstringWithAtMostKDistinctCharacters {\n public int lengthOfLongestSubstringKDistinct(String s, int k) {\n int[] count = new int[256]; // there are 256 ASCII characters in the world\n\n int i = 0; // i will be behind j\n int num = 0;\n int res = 0;\n\n for (int j = 0; j < s.length(); j++) {\n if (count[s.charAt(j)] == 0) { // if count[s.charAt(j)] == 0, we know that it is a distinct character\n num++;\n }\n\n count[s.charAt(j)]++;\n\n while (num > k && i < s.length()) { // sliding window\n count[s.charAt(i)]--;\n\n if (count[s.charAt(i)] == 0){ \n num--;\n }\n\n i++;\n }\n\n res = Math.max(res, j - i + 1);\n }\n\n return res;\n }\n}\n"
},
{
"path": "company/google/MaximumProductOfWordLengths.java",
"content": "// Given a string array words, find the maximum value of length(word[i]) * length(word[j]) where the two words do not share common letters. You may assume that each word will contain only lower case letters. If no such two words exist, return 0.\n\n// Example 1:\n// Given [\"abcw\", \"baz\", \"foo\", \"bar\", \"xtfn\", \"abcdef\"]\n// Return 16\n// The two words can be \"abcw\", \"xtfn\".\n\n// Example 2:\n// Given [\"a\", \"ab\", \"abc\", \"d\", \"cd\", \"bcd\", \"abcd\"]\n// Return 4\n// The two words can be \"ab\", \"cd\".\n\n// Example 3:\n// Given [\"a\", \"aa\", \"aaa\", \"aaaa\"]\n// Return 0\n// No such pair of words.\n\npublic class MaximumProductOfWordLengths {\n public int maxProduct(String[] words) {\n if(words.length == 0 || words == null) {\n return 0;\n }\n \n int length = words.length;\n int[] value = new int[length];\n int max = 0;\n \n for(int i = 0; i < length; i++) {\n String temp = words[i];\n value[i] = 0;\n \n for(int j = 0; j < temp.length(); j++) {\n value[i] |= 1 << (temp.charAt(j) - 'a');\n }\n }\n \n for(int i = 0; i < length; i++) {\n for(int j = 1; j < length; j++) {\n if((value[i] & value[j]) == 0 && (words[i].length() * words[j].length()) > max) {\n max = words[i].length() * words[j].length();\n }\n }\n }\n \n return max;\n }\n}\n"
},
{
"path": "company/google/MergeIntervals.java",
"content": "// Given a collection of intervals, merge all overlapping intervals.\n\n// For example,\n// Given [1,3],[2,6],[8,10],[15,18],\n// return [1,6],[8,10],[15,18].\n\n/**\n * Definition for an interval.\n * public class Interval {\n * int start;\n * int end;\n * Interval() { start = 0; end = 0; }\n * Interval(int s, int e) { start = s; end = e; }\n * }\n */\nclass MergeIntervals {\n public List merge(List intervals) {\n List result = new ArrayList();\n if(intervals == null || intervals.size() == 0) {\n return result;\n }\n \n Interval[] allIntervals = intervals.toArray(new Interval[intervals.size()]);\n Arrays.sort(allIntervals, new Comparator() {\n public int compare(Interval a, Interval b) {\n if(a.start == b.start) {\n return a.end - b.end;\n }\n return a.start - b.start;\n } \n });\n \n for(Interval i: allIntervals) {\n if (result.size() == 0 || result.get(result.size() - 1).end < i.start) {\n result.add(i);\n } else {\n result.get(result.size() - 1).end = Math.max(result.get(result.size() - 1).end, i.end);\n }\n }\n \n return result;\n }\n}\n"
},
{
"path": "company/google/MinStack.java",
"content": "//Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.\n//push(x) -- Push element x onto stack.\n//pop() -- Removes the element on top of the stack.\n//top() -- Get the top element.\n//getMin() -- Retrieve the minimum element in the stack.\n\n/**\n * Your MinStack object will be instantiated and called as such:\n * MinStack obj = new MinStack();\n * obj.push(x);\n * obj.pop();\n * int param_3 = obj.top();\n * int param_4 = obj.getMin();\n */\nclass MinStack {\n class Node {\n int data;\n int min;\n Node next;\n \n public Node(int data, int min) {\n this.data = data;\n this.min = min;\n this.next = null;\n }\n }\n Node head;\n \n /** initialize your data structure here. */\n public MinStack() {\n \n }\n \n public void push(int x) {\n if(head == null) {\n head = new Node(x, x);\n } else {\n Node newNode = new Node(x, Math.min(x, head.min));\n newNode.next = head;\n head = newNode;\n }\n }\n \n public void pop() {\n head = head.next;\n }\n \n public int top() {\n return head.data;\n }\n \n public int getMin() {\n return head.min;\n }\n}\n"
},
{
"path": "company/google/MissingRanges.java",
"content": "// Given a sorted integer array where the range of elements are in the inclusive range [lower, upper], return its missing ranges.\n\n// For example, given [0, 1, 3, 50, 75], lower = 0 and upper = 99, return [\"2\", \"4->49\", \"51->74\", \"76->99\"].\n\npublic class MissingRanges {\n public List findMissingRanges(int[] nums, int lower, int upper) {\n ArrayList result = new ArrayList();\n \n for(int i = 0; i <= nums.length; i++) {\n long start = i == 0 ? lower : (long)nums[i - 1] + 1;\n long end = i == nums.length ? upper : (long)nums[i] - 1;\n\n addMissing(result, start, end);\n }\n \n return result;\n }\n \n void addMissing(ArrayList result, long start, long end) {\n if(start > end) {\n return;\n } else if(start == end) {\n result.add(start + \"\");\n } else {\n result.add(start + \"->\" + end);\n }\n }\n}\n"
},
{
"path": "company/google/MovingAverageFromDataStream.java",
"content": "// Given a stream of integers and a window size, calculate the moving average of all integers in the sliding window.\n\n// For example,\n// MovingAverage m = new MovingAverage(3);\n// m.next(1) = 1\n// m.next(10) = (1 + 10) / 2\n// m.next(3) = (1 + 10 + 3) / 3\n// m.next(5) = (10 + 3 + 5) / 3\n\n/**\n * Your MovingAverage object will be instantiated and called as such:\n * MovingAverage obj = new MovingAverage(size);\n * double param_1 = obj.next(val);\n */\n\npublic class MovingAverageFromDataStream {\n double previousSum = 0.0;\n int maxSize;\n Queue window;\n\n /** Initialize your data structure here. */\n public MovingAverage(int size) {\n this.maxSize = size;\n window = new LinkedList();\n }\n \n public double next(int val) {\n if(window.size() == maxSize) {\n previousSum -= window.remove();\n }\n \n window.add(val);\n previousSum += val;\n\n return previousSum / window.size();\n }\n}\n"
},
{
"path": "company/google/NumberOfIslands.java",
"content": "// Given a 2d grid map of '1's (land) and '0's (water), count the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.\n\n// Example 1:\n\n// 11110\n// 11010\n// 11000\n// 00000\n// Answer: 1\n\n// Example 2:\n\n// 11000\n// 11000\n// 00100\n// 00011\n// Answer: 3\n\npublic class NumberOfIslands {\n char[][] gridCopy;\n \n public int numIslands(char[][] grid) {\n //set grid copy to the current grid\n gridCopy = grid;\n \n //initialize number of islands to zero\n int numberOfIslands = 0;\n \n //iterate through every index of the grid\n for(int i = 0; i < grid.length; i++) {\n for(int j = 0; j < grid[0].length; j++) {\n //attempt to \"sink\" the current index of the grid\n numberOfIslands += sink(gridCopy, i, j);\n }\n }\n \n //return the total number of islands\n return numberOfIslands;\n }\n \n int sink(char[][] grid, int i, int j) {\n //check the bounds of i and j and if the current index is an island or not (1 or 0)\n if(i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] == '0') {\n return 0;\n }\n \n //set current index to 0\n grid[i][j] = '0';\n \n // sink all neighbors of current index\n sink(grid, i + 1, j);\n sink(grid, i - 1, j);\n sink(grid, i, j + 1);\n sink(grid, i, j - 1);\n \n //increment number of islands\n return 1;\n }\n}\n"
},
{
"path": "company/google/PacificAtlanticWaterFlow.java",
"content": "// Given an m x n matrix of non-negative integers representing the height of each unit cell in a continent, the \"Pacific ocean\" touches the left and top edges of the matrix and the \"Atlantic ocean\" touches the right and bottom edges.\n\n// Water can only flow in four directions (up, down, left, or right) from a cell to another one with height equal or lower.\n\n// Find the list of grid coordinates where water can flow to both the Pacific and Atlantic ocean.\n\n// Note:\n // The order of returned grid coordinates does not matter.\n // Both m and n are less than 150.\n\n// Example:\n\n// Given the following 5x5 matrix:\n\n// Pacific ~ ~ ~ ~ ~ \n// ~ 1 2 2 3 (5) *\n// ~ 3 2 3 (4) (4) *\n// ~ 2 4 (5) 3 1 *\n// ~ (6) (7) 1 4 5 *\n// ~ (5) 1 1 2 4 *\n// * * * * * Atlantic\n\n// Return:\n\n// [[0, 4], [1, 3], [1, 4], [2, 2], [3, 0], [3, 1], [4, 0]] (positions with parentheses in above matrix).\n\npublic class PacificAtlanticWaterFlow {\n public List pacificAtlantic(int[][] matrix) {\n List