\n * \t\t\t\t}\n * \t\t\t}\n * \t\t}\n * }\n **/\n"
},
{
"path": "coding_interviews/interviews/smartnews/countries.js",
"content": "function solution(A) {\n let countries = buildCountriesMapper(A);\n let countriesCount = 0;\n\n for (let row = 0; row < A.length; row++) {\n for (let col = 0; col < A[row].length; col++) {\n const country = A[row][col];\n if (!countries[row][col]) countriesCount++;\n verifyCountry(A, country, row, col, countries);\n }\n }\n\n return countriesCount;\n}\n\nfunction buildCountriesMapper(A) {\n const mapper = [];\n\n for (let row = 0; row < A.length; row++) {\n const line = [];\n\n for (let col = 0; col < A[row].length; col++) {\n line.push(false);\n }\n\n mapper.push(line);\n }\n\n return mapper;\n}\n\nfunction verifyCountry(A, country, row, col, countries) {\n if (\n row < 0 ||\n col < 0 ||\n row >= A.length ||\n col >= A[row].length ||\n countries[row][col] ||\n country !== A[row][col]\n )\n return;\n\n countries[row][col] = true;\n country = A[row][col];\n\n verifyCountry(A, country, row, col - 1, countries);\n verifyCountry(A, country, row, col + 1, countries);\n verifyCountry(A, country, row + 1, col, countries);\n}\n"
},
{
"path": "coding_interviews/interviews/smartnews/emiter.js",
"content": "/*\n Event Emiter\n 1. `on` & `emit`\n 2. `off`\n 3. `once`\n*/\n\nclass EventEmiter {\n events = {};\n\n on(eventName, fn) {\n if (!this.events[eventName]) {\n this.events[eventName] = [{ subscriber: 'on', fn }];\n } else {\n this.events[eventName].push({ subscriber: 'on', fn });\n }\n }\n\n emit(eventName, ...args) {\n if (this.events[eventName]) {\n for (let i = 0; i < this.events[eventName].length; i++) {\n this.events[eventName][i].fn(...args);\n\n if (this.events[eventName][i].subscriber === 'once') {\n this.off(eventName, this.events[eventName][i].fn);\n }\n }\n }\n }\n\n off(eventName, fn) {\n if (this.events[eventName]) {\n this.events[eventName] = this.events[eventName].filter(\n (event) => event.fn !== fn\n );\n }\n }\n\n once(eventName, fn) {\n if (!this.events[eventName]) {\n this.events[eventName] = [{ subscriber: 'once', fn }];\n } else {\n this.events[eventName].push({ subscriber: 'once', fn });\n }\n }\n}\n\nconst eventEmitet = new EventEmiter();\n\nconst fn1 = (param1, param2) => console.log('test 1', param1, param2);\n\neventEmitet.once('test', fn1);\neventEmitet.emit('test', 'param1', 'param2'); // log param1, param2\neventEmitet.emit('test', 'param1', 'param2'); // log nothing\n"
},
{
"path": "coding_interviews/interviews/smartnews/getTriplets.js",
"content": "// /**\n// * Given an array nums of n integers, are there elements a, b, c in nums such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.\n// *\n// * Note:\n// * The solution set must not contain duplicate triplets.\n// *\n// * Example:\n// * Given array nums = [-1, 0, 1, 2, -1, -4],\n// *\n// * A solution set is:\n// * [\n// * [-1, 0, 1],\n// * [-1, -1, 2]\n// * ]\n// */\n\nconst getTriplets = (nums) => {\n const triplets = [];\n const tripletMapper = {};\n const allNumbers = {};\n\n nums.forEach((num) => (allNumbers[num] = true));\n\n for (let i = 0; i < nums.length - 2; i++) {\n for (let j = i + 1; j < nums.length - 1; j++) {\n const firstTwoSum = nums[i] + nums[j];\n const targetNumber = 0 - firstTwoSum;\n\n if (allNumbers[targetNumber]) {\n const mapperKey = stringify([nums[i], nums[j], targetNumber]);\n if (!tripletMapper[mapperKey]) {\n tripletMapper[mapperKey] = true;\n triplets.push([nums[i], nums[j], targetNumber]);\n }\n }\n }\n }\n\n return triplets;\n};\n\nconst stringify = (nums) => nums[0] + '.' + nums[1] + '.' + nums[2];\n\nconsole.log(getTriplets([0, 0, 0]));\nconsole.log(getTriplets([-1, 0, 1, 2, -1, -4]));\nconsole.log(getTriplets([0, -1, 2]));\nconsole.log(getTriplets([0, -1, Infinity]));\n"
},
{
"path": "coding_interviews/interviews/uber/longest-words.js",
"content": "// console.log('Hello world');\n\n// I would like you to write a function which takes two arguments: a list of words, each separated by comma, and a list of letters. The function should output the longest words from which can be made using the letters in the list.\n\n// ---------\n// Inputs\n// ---------\n// Words: aab,cab,abba,abacus,scabs,scab,bacca,ab\n// Letters: aabbscb\n// aab, cab, abba\n\n// ----------------------\n// Expected Output\n// ----------------------\n// abba, scab\n\n// Algorithm Analysis\n// O(L + W * CW) => O(W * CW)\n// L = letters\n// W = words\n// CW = chars of word\n\nfunction buildCounter(letters) {\n let lettersCounter = {};\n\n for (let char of letters) {\n if (lettersCounter[char]) {\n lettersCounter[char]++;\n } else {\n lettersCounter[char] = 1;\n }\n }\n\n return lettersCounter;\n}\n\nfunction getLongestWords(words, letters) {\n let lettersCounter = buildCounter(letters);\n let longestLength = 0;\n let allValidWords = {};\n\n for (let word of words) {\n let lettersCounterCopy = { ...lettersCounter }; // O(L)\n let isValid = true;\n\n for (let char of word) {\n if (\n lettersCounterCopy[char] == undefined ||\n lettersCounterCopy[char] === 0\n ) {\n isValid = false;\n break;\n }\n\n lettersCounterCopy[char] -= 1;\n }\n\n if (isValid) {\n if (allValidWords[word.length]) {\n allValidWords[word.length].push(word);\n } else {\n allValidWords[word.length] = [word];\n }\n\n longestLength = Math.max(longestLength, word.length);\n }\n }\n\n return allValidWords[longestLength] || [];\n}\n\nconsole.log(\n getLongestWords(\n ['aab', 'cab', 'abba', 'abacus', 'scabs', 'scab', 'bacca', 'ab'],\n 'aabbscb'\n )\n);\nconsole.log(\n getLongestWords(\n ['aab', 'cab', 'abba', 'abacus', 'scabs', 'scab', 'bacca', 'ab'],\n ''\n )\n);\nconsole.log(\n getLongestWords(\n ['aab', 'cab', 'abba', 'abacus', 'scabs', 'scab', 'bacca', 'ab'],\n 'aabbscbsu'\n )\n);\nconsole.log(\n getLongestWords(\n ['aab', 'cab', 'abba', 'abacus', 'scabs', 'scab', 'bacca', 'ab'],\n 'aabbscbs'\n )\n);\nconsole.log(getLongestWords([''], 'batata'));\nconsole.log(getLongestWords(['batata'], 'batata'));\nconsole.log(getLongestWords(['aaaaaaaaaaaaaa'], 'aaaaaaaaaaaaaa'));\n"
},
{
"path": "coding_interviews/interviews/uber/maxFrequency.js",
"content": "export function maxFrequency(numbers) {\n let maxFrequencyNumber = -1;\n let result = -1;\n let numberToFrequencyMap = {};\n\n for (let num of numbers) {\n if (numberToFrequencyMap[num]) {\n numberToFrequencyMap[num]++;\n } else {\n numberToFrequencyMap[num] = 1;\n }\n }\n\n Object.entries(numberToFrequencyMap).forEach(([num, frequency]) => {\n if (frequency > maxFrequencyNumber) {\n maxFrequencyNumber = frequency;\n result = Number(num);\n }\n });\n\n return result;\n}\n"
},
{
"path": "coding_interviews/interviews/uber/permutations.js",
"content": "/*\n Input [2,3]\n Output: [\"AD\", \"BD\", \"CD\", \"AE\", \"BE\", \"CE\", \"AF\", \"BF\", \"CF\"], 9\n\n Input []\n Output: [], 0\n \n Input [1,2]\n Output: [\"A\", \"B\", \"C\"], 3\n \n Input [0,2]\n Output: [\"+A\", \"+B\", \"+C\"], 3\n \n Input [2,3,4]\n Output: [\"ADG\", \"ADH\", \"ADI\", \"AEG\", ...]\n*/\nlet numberToValues = {\n 0: '+',\n 1: ' ',\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\nfunction combine(permutations, chars) {\n let combination = [];\n\n for (let permutation of permutations) {\n for (let char of chars) {\n combination.push(permutation + char);\n }\n }\n\n return combination;\n}\n\nfunction permutations(numbers) {\n if (numbers.length === 0) {\n return [];\n }\n\n let allPermutations = [];\n let num = numbers[0];\n let chars = numberToValues[num];\n\n for (let char of chars) {\n allPermutations.push(char);\n }\n\n for (let index = 1; index < numbers.length; index++) {\n let num = numbers[index];\n let chars = numberToValues[num];\n allPermutations = combine(allPermutations, chars);\n }\n\n return allPermutations;\n}\n\nconsole.log(permutations([2, 3]));\nconsole.log(permutations([2, 3, 4]));\nconsole.log(permutations([1, 2, 3, 4]));\nconsole.log(permutations([0, 1, 2, 3, 4]));\n"
},
{
"path": "coding_interviews/interviews/uber/tests/maxFrequency.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport { maxFrequency } from '../maxFrequency';\n\ndescribe('maxFrequency', () => {\n it('', () => {\n expect(maxFrequency([2, 2, 2, 3, 3, 1])).toEqual(2);\n });\n\n it('', () => {\n expect(maxFrequency([1, 1, 2, 2, 3, 3])).toEqual(1);\n });\n\n it('', () => {\n expect(maxFrequency([])).toEqual(-1);\n });\n});\n"
},
{
"path": "coding_interviews/javascript/array/binary-search.js",
"content": "function getMiddle(start, end) {\n return Math.floor((start + end) / 2);\n}\n\nfunction binarySearch(numbers, target) {\n let start = 0;\n let end = numbers.length - 1;\n let middle = getMiddle(start, end);\n let found = false;\n\n while (start <= end && !found) {\n middle = getMiddle(start, end);\n const middleNumber = numbers[middle];\n\n if (middleNumber === target) found = true;\n if (middleNumber > target) end = middle - 1;\n if (middleNumber < target) start = middle + 1;\n }\n\n return found;\n}\n\nfunction logResult(list, target) {\n console.log(binarySearch(list, target));\n}\n\nlogResult([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 5); // true\nlogResult([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 11); // false\nlogResult([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], -1); // false\nlogResult([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 0); // false\nlogResult([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 9); // true\nlogResult([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 1); // true\n"
},
{
"path": "coding_interviews/javascript/array/slice.js",
"content": "const list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];\n\nlist.slice(0); // all elements: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\nlist.slice(0, 3); // first 3 elements: [1, 2, 3]\nlist.slice(1, 4); // from 2 to 4: [2, 3, 4]\n"
},
{
"path": "coding_interviews/javascript/array/subarrays.js",
"content": "function generateSubarrays(arr, start, end, result) {\n if (end == arr.length) return;\n else if (start > end) generateSubarrays(arr, 0, end + 1, result);\n else {\n result.push(arr.slice(start, end + 1));\n generateSubarrays(arr, start + 1, end, result);\n }\n}\n\nlet arr = [1, 2, 3];\nlet result = [];\n\ngenerateSubarrays(arr, 0, 0, result);\n\nconsole.log(result);\n"
},
{
"path": "coding_interviews/javascript/hashmap/iteration.js",
"content": "let hashmap = {};\nlet numbers = [1, 2, 3, 4, 5, 1, 6, 1, 7, 0, 8, 9, 10, 0, 1];\n\nfor (let number of numbers) {\n if (hashmap[number]) {\n hashmap[number]++;\n } else {\n hashmap[number] = 1;\n }\n}\n\n// if I need keys and values\nObject.entries(hashmap).forEach(([key, value]) => {\n console.log(`${key} -> ${value}`);\n});\n\n// if I need keys only\nObject.keys(hashmap).forEach((key) => {\n console.log(key);\n});\n\n// if I need values only\nObject.values(hashmap).forEach((value) => {\n console.log(value);\n});\n"
},
{
"path": "coding_interviews/javascript/hashmap/object.js",
"content": "// building a hashmap to count numbers\nlet hashmap = {};\nlet numbers = [1, 2, 3, 4, 5, 1, 6, 1, 7, 0, 8, 9, 10, 0, 1];\n\nfor (let number of numbers) {\n if (hashmap[number]) {\n hashmap[number]++;\n } else {\n hashmap[number] = 1;\n }\n}\n\nconsole.log(hashmap);\n"
},
{
"path": "coding_interviews/javascript/queue/queue.js",
"content": "let queue = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];\n\nfunction push(queue, value) {\n queue.push(value);\n}\n\nfunction pop(queue) {\n return queue.shift();\n}\n\nfunction front(queue) {\n return queue[0];\n}\n\nfunction isEmpty(queue) {\n return queue.length === 0;\n}\n\nconsole.log(queue); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n\npush(queue, 0);\nconsole.log(queue); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0]\n\npop(queue); // 1\nconsole.log(queue); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n\nfront(queue); // 2\nisEmpty(queue); // false\n\nwhile (!isEmpty(queue)) {\n queue.pop();\n}\n\nisEmpty(queue); // true\nconsole.log(queue);\n"
},
{
"path": "coding_interviews/javascript/stack/stack.js",
"content": "let stack = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];\n\nfunction push(stack, value) {\n stack.push(value);\n}\n\nfunction pop(stack) {\n return stack.pop();\n}\n\nfunction top(stack) {\n return stack[stack.length - 1];\n}\n\nfunction isEmpty(stack) {\n return stack.length === 0;\n}\n\nconsole.log(stack); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n\npush(stack, 11);\nconsole.log(stack); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]\n\npop(stack); // 11\nconsole.log(stack); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n\ntop(stack); // 10\nisEmpty(stack); // false\n\nwhile (!isEmpty(stack)) {\n stack.pop();\n}\n\nisEmpty(stack); // true\nconsole.log(stack);\n"
},
{
"path": "coding_interviews/javascript/string/alphabet.js",
"content": "// index to alphabet char\nconst alphabet = 'abcdefghijklmnopqrstuvwxyz';\n\nalphabet[0]; // a\nalphabet[1]; // b\n\n// -------------------- // --------------------\n\n// alphabet char to index\nfunction getIndexFromChar(char) {\n return char.charCodeAt() - 97;\n}\n\ngetIndexFromChar('a'); // 0\ngetIndexFromChar('b'); // 1\n"
},
{
"path": "coding_interviews/javascript/string/charCode.js",
"content": "'a'.charCodeAt() - 96; // 1\n'b'.charCodeAt() - 96; // 2\n"
},
{
"path": "coding_interviews/javascript/string/isString.js",
"content": "function isString(str) {\n return typeof str === 'string' || str instanceof String;\n}\n"
},
{
"path": "coding_interviews/javascript/string/methods.js",
"content": "const string = 'nihongo';\n\nstring.replace('n', 'N'); // 'Nihongo'\n\nstring.replaceAll('n', 'N'); // 'NihoNgo'\n\nstring.slice(2, 4); // 'ho'\n\nstring.toUpperCase(); // 'NIHONGO'\n\nstring.toUpperCase().toLowerCase(); // 'nihongo'\n\n' nihongo '.trim(); // 'nihongo'\n"
},
{
"path": "coding_interviews/javascript/string/sort.js",
"content": "function sort(string) {\n return [...string].sort((c1, c2) => c1.localeCompare(c2)).join('');\n}\n"
},
{
"path": "coding_interviews/javascript/tree/inorder.js",
"content": "/*\nTreeNode {\n value: int\n left: TreeNode | null\n right: TreeNode | null\n}\n*/\n\nfunction inorder(node) {\n if (!node) return;\n inorder(node.left);\n node.value;\n inorder(node.right);\n}\n"
},
{
"path": "coding_interviews/javascript/tree/postorder.js",
"content": "/*\nTreeNode {\n value: int\n left: TreeNode | null\n right: TreeNode | null\n}\n*/\n\nfunction postorder(node) {\n if (!node) return;\n postorder(node.left);\n postorder(node.right);\n node.value;\n}\n"
},
{
"path": "coding_interviews/javascript/tree/preorder.js",
"content": "/*\nTreeNode {\n value: int\n left: TreeNode | null\n right: TreeNode | null\n}\n*/\n\nfunction preorder(node) {\n if (!node) return;\n node.value;\n preorder(node.left);\n preorder(node.right);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/a-number-after-a-double-reversal/a-number-after-a-double-reversal.js",
"content": "function reverse(numString) {\n const stringArray = [];\n\n for (let i = numString.length - 1; i >= 0; i--) {\n stringArray.push(numString[i]);\n }\n\n return stringArray.join('');\n}\n\nfunction removeLeadingZeros(numString) {\n const numStringWithoutLeadingZeros = [];\n let foundFirstNonLeadingZero = false;\n\n for (let i = 0; i < numString.length; i++) {\n const digitChar = numString[i];\n\n if (\n (!foundFirstNonLeadingZero && digitChar !== '0') ||\n foundFirstNonLeadingZero\n ) {\n foundFirstNonLeadingZero = true;\n numStringWithoutLeadingZeros.push(digitChar);\n }\n }\n\n return numStringWithoutLeadingZeros.join('');\n}\n\nexport function isSameAfterReversals(num) {\n const numString = num.toString();\n\n if (numString.length === 1) {\n return true;\n }\n\n const reversedNumString = removeLeadingZeros(reverse(numString));\n\n return numString === reverse(reversedNumString);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/a-number-after-a-double-reversal/tests/a-number-after-a-double-reversal.test.js",
"content": "import { describe, it, expect } from 'vitest';\nimport { isSameAfterReversals } from '../a-number-after-a-double-reversal';\n\ndescribe('isSameAfterReversals', () => {\n it('', () => {\n expect(isSameAfterReversals(526)).toBeTruthy();\n });\n\n it('', () => {\n expect(isSameAfterReversals(1800)).toBeFalsy();\n });\n\n it('', () => {\n expect(isSameAfterReversals(0)).toBeTruthy();\n });\n\n it('', () => {\n expect(isSameAfterReversals(609576)).toBeTruthy();\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/easy/add-digits/add-digits.js",
"content": "/*\nGiven an integer num, repeatedly add all its digits until the result has only one digit, and return it.\n\nInput: num = 38\nOutput: 2\nExplanation: The process is\n38 --> 3 + 8 --> 11\n11 --> 1 + 1 --> 2 \nSince 2 has only one digit, return it.\n\nInput: num = 0\nOutput: 0\n*/\n\nfunction isSingleDigit(number) {\n return Math.floor(number / 10) === 0;\n}\n\nfunction addDigits(number) {\n let result = number;\n let sumOfDigits = 0;\n\n while (!isSingleDigit(result)) {\n while (result) {\n digit = result % 10;\n result = Math.floor(result / 10);\n sumOfDigits += digit;\n }\n\n result = sumOfDigits;\n sumOfDigits = 0;\n }\n\n return result;\n}\n\nconsole.log('addDigits', addDigits(38));\nconsole.log('addDigits', addDigits(0));\n"
},
{
"path": "coding_interviews/leetcode/easy/add-two-integers/index.js",
"content": "const sum = (num1, num2) => num1 + num2;\n"
},
{
"path": "coding_interviews/leetcode/easy/alternating-digit-sum/alternating-digit-sum.js",
"content": "function isEvent(num) {\n return num % 2 === 0;\n}\n\nfunction alternateDigitSum(n) {\n let output = 0;\n let nString = n.toString();\n\n for (let index = 0; index < nString.length; index++) {\n if (isEvent(index)) output += Number(nString[index]);\n else output += Number(nString[index]) * -1;\n }\n\n return output;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/apply-operations-to-an-array/apply-operations-to-an-array.js",
"content": "function applyOperations(nums) {\n for (let index = 0; index < nums.length - 1; index++) {\n if (nums[index] === nums[index + 1]) {\n nums[index] *= 2;\n nums[index + 1] = 0;\n }\n }\n\n let zeros = 0;\n\n for (let num of nums) {\n if (num === 0) zeros++;\n }\n\n let result = [];\n\n for (let num of nums) {\n if (num !== 0) {\n result.push(num);\n }\n }\n\n for (let index = 1; index <= zeros; index++) {\n result.push(0);\n }\n\n return result;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/arithmetic_progression/arithmetic_progression.py",
"content": "# https://leetcode.com/problems/can-make-arithmetic-progression-from-sequence\n\n\ndef can_make_arithmetic_progression(arr):\n sorted_arr, diff = sorted(arr), '-Inf'\n\n for index in range(len(sorted_arr) - 1):\n if diff == '-Inf':\n diff = sorted_arr[index + 1] - sorted_arr[index]\n\n if sorted_arr[index + 1] - sorted_arr[index] != diff:\n return False\n\n return True\n"
},
{
"path": "coding_interviews/leetcode/easy/array_partition.py",
"content": "'''\nhttps://leetcode.com/problems/array-partition-i/description/\n\nInput: [1,4,3,2]\nOutput: 4\n'''\n\ndef array_pair_sum(nums):\n return sum(sorted(nums)[::2])\n\nprint(array_pair_sum([1, 4, 3, 2]))\n"
},
{
"path": "coding_interviews/leetcode/easy/average-of-levels-in-binary-tree/average-of-levels-in-binary-tree.js",
"content": "function averageOfLevels(root) {\n const queue = [];\n const averageOfLevels = [];\n\n queue.push(root);\n\n while (queue.length) {\n let sumOfLevelNodes = 0;\n let levelNumberOfNodes = queue.length;\n\n for (let node of queue) {\n sumOfLevelNodes += node.val;\n }\n\n averageOfLevels.push(sumOfLevelNodes / queue.length);\n\n for (let index = 0; index < levelNumberOfNodes; index++) {\n const node = queue.shift();\n node.left && queue.push(node.left);\n node.right && queue.push(node.right);\n }\n }\n\n return averageOfLevels;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/average-salary-excluding-the-minimum-and-maximum-salary/average-salary-excluding-the-minimum-and-maximum-salary.js",
"content": "function average(salaries) {\n let min = Infinity;\n let max = -Infinity;\n let sum = 0;\n\n for (let salary of salaries) {\n min = Math.min(min, salary);\n max = Math.max(max, salary);\n sum += salary;\n }\n\n sum -= min + max;\n return sum / (salaries.length - 2);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/average-value-of-even-numbers-that-are-divisible-by-three/average-value-of-even-numbers-that-are-divisible-by-three.js",
"content": "// https://leetcode.com/problems/average-value-of-even-numbers-that-are-divisible-by-three\n\nfunction isEven(num) {\n return num % 2 === 0;\n}\n\nfunction isDividedBy3(num) {\n return num % 3 === 0;\n}\n\nfunction averageValue(nums) {\n let n = 0;\n let sum = 0;\n\n for (let num of nums) {\n if (isEven(num) && isDividedBy3(num)) {\n n++;\n sum += num;\n }\n }\n\n return n ? Math.floor(sum / n) : 0;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/backspace-string-compare/index.js",
"content": "function buildStack(string) {\n const stack = [];\n\n for (let index = 0; index < string.length; index++) {\n if (string[index] === '#') {\n stack.pop();\n } else {\n stack.push(string[index]);\n }\n }\n\n return stack;\n}\n\nfunction isEqual(stack1, stack2) {\n if (stack1.length !== stack2.length) {\n return false;\n }\n\n for (let index = 0; index < stack1.length; index++) {\n if (stack1[index] !== stack2[index]) {\n return false;\n }\n }\n\n return true;\n}\n\nexport function backspaceCompare(s, t) {\n const sStack = buildStack(s);\n const tStack = buildStack(t);\n return isEqual(sStack, tStack);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/backspace-string-compare/tests/index.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport { backspaceCompare } from '../';\n\ndescribe('backspaceCompare', () => {\n it('', () => {\n expect(backspaceCompare('ab#c', 'ad#c')).toBeTruthy();\n });\n\n it('', () => {\n expect(backspaceCompare('ab##', 'c#d#')).toBeTruthy();\n });\n\n it('', () => {\n expect(backspaceCompare('a#c', 'b')).toBeFalsy();\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/easy/baseball-game/baseball-game.js",
"content": "function calPoints(ops) {\n const record = [];\n\n for (let op of ops) {\n if (op === 'C') {\n record.pop();\n } else if (op === 'D') {\n const lastOp = record[record.length - 1];\n record.push(lastOp * 2);\n } else if (op === '+') {\n const lastOp = record[record.length - 1];\n const penultimateOp = record[record.length - 2];\n record.push(lastOp + penultimateOp);\n } else {\n record.push(Number(op));\n }\n }\n\n return record.reduce((recordItem, sum) => sum + recordItem, 0);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/best-poker-hand/best-poker-hand.js",
"content": "// https://leetcode.com/problems/best-poker-hand\n\nfunction buildMap(list) {\n let map = new Map();\n\n for (let item of list) {\n if (map.has(item)) map.set(item, map.get(item) + 1);\n else map.set(item, 1);\n }\n\n return map;\n}\n\nfunction bestHand(ranks, suits) {\n let suitsMap = buildMap(suits);\n\n for (let [_, count] of suitsMap.entries()) {\n if (count >= 5) return 'Flush';\n }\n\n let ranksMap = buildMap(ranks);\n let hasPair = false;\n\n for (let [_, count] of ranksMap.entries()) {\n if (count >= 3) return 'Three of a Kind';\n if (count >= 2) hasPair = true;\n }\n\n return hasPair ? 'Pair' : 'High Card';\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/best-time-to-buy-and-sell-stock/best-time-to-buy-and-sell-stock-tle.js",
"content": "function maxProfit(prices) {\n let max = 0;\n\n for (let index = 0; index < prices.length; index++) {\n for (\n let compareIndex = index + 1;\n compareIndex < prices.length;\n compareIndex++\n ) {\n max = Math.max(max, prices[compareIndex] - prices[index]);\n }\n }\n\n return max;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/best-time-to-buy-and-sell-stock/best-time-to-buy-and-sell-stock.js",
"content": "function maxProfit(prices) {\n let max = 0;\n let buy = 0;\n let sell = 1;\n\n while (sell < prices.length) {\n if (prices[buy] < prices[sell]) {\n let profit = prices[sell] - prices[buy];\n max = Math.max(max, profit);\n } else {\n buy = sell;\n }\n\n sell++;\n }\n\n return max;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/binary-number-with-alternating-bits/binary-number-with-alternating-bits.js",
"content": "function toBinary(n) {\n let binary = [];\n\n while (n) {\n binary.push((n % 2).toString());\n n = Math.floor(n / 2);\n }\n\n return binary.join('');\n}\n\nfunction isAlternating(binary) {\n let previous = binary[0];\n\n for (let index = 1; index < binary.length; index++) {\n let current = binary[index];\n if (previous === current) return false;\n previous = current;\n }\n\n return true;\n}\n\nfunction hasAlternatingBits(n) {\n return isAlternating(toBinary(n));\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/binary-search/binary-search.js",
"content": "function search(nums, target) {\n let start = 0;\n let end = nums.length - 1;\n let middle = Math.floor((end + start) / 2);\n let index = -1;\n let found = false;\n\n while (start <= end && !found) {\n if (target > nums[middle]) {\n start = middle + 1;\n middle = Math.floor((end + start) / 2);\n } else if (target < nums[middle]) {\n end = middle - 1;\n middle = Math.floor((end + start) / 2);\n } else {\n index = middle;\n found = true;\n }\n }\n\n return index;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/binary-tree-inorder-traversal/binary-tree-inorder-traversal.js",
"content": "function inorderTraversal(root) {\n if (!root) {\n return [];\n }\n\n return [\n ...inorderTraversal(root.left),\n root.val,\n ...inorderTraversal(root.right),\n ];\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/binary-tree-paths/binary-tree-paths.js",
"content": "function traversal(node, paths, path) {\n if (!node.left && !node.right) {\n paths.push(path.join('->'));\n }\n\n if (node.left) {\n traversal(node.left, paths, [...path, node.left.val]);\n }\n\n if (node.right) {\n traversal(node.right, paths, [...path, node.right.val]);\n }\n}\n\nfunction binaryTreePaths(root) {\n let paths = [];\n traversal(root, paths, [root.val]);\n return paths;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/binary-tree-postorder-traversal/binary-tree-postorder-traversal.js",
"content": "function postorderTraversal(root) {\n if (!root) {\n return [];\n }\n\n return [\n ...postorderTraversal(root.left),\n ...postorderTraversal(root.right),\n root.val,\n ];\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/binary-tree-preorder-traversal/binary-tree-preorder-traversal.js",
"content": "function preorderTraversal(root) {\n if (!root) {\n return [];\n }\n\n return [\n root.val,\n ...preorderTraversal(root.left),\n ...preorderTraversal(root.right),\n ];\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/binary-tree-tilt/binary-tree-tilt-optimized.js",
"content": "// https://leetcode.com/problems/binary-tree-tilt\n\n/**\n * Definition for a binary tree node.\n * function TreeNode(val, left, right) {\n * this.val = (val===undefined ? 0 : val)\n * this.left = (left===undefined ? null : left)\n * this.right = (right===undefined ? null : right)\n * }\n */\n\nlet sum;\n\nfunction sumNodes(node) {\n if (!node) return 0;\n\n let leftSum = sumNodes(node.left);\n let rightSum = sumNodes(node.right);\n\n sum += Math.abs(leftSum - rightSum);\n\n return node.val + leftSum + rightSum;\n}\n\nfunction findTilt(root) {\n sum = 0;\n sumNodes(root);\n return sum;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/binary-tree-tilt/binary-tree-tilt.js",
"content": "// https://leetcode.com/problems/binary-tree-tilt\n\n/**\n * Definition for a binary tree node.\n * function TreeNode(val, left, right) {\n * this.val = (val===undefined ? 0 : val)\n * this.left = (left===undefined ? null : left)\n * this.right = (right===undefined ? null : right)\n * }\n */\n\nfunction sumNodes(node) {\n if (!node) return 0;\n return node.val + sumNodes(node.left) + sumNodes(node.right);\n}\n\nfunction findTilt(root) {\n if (!root) return 0;\n return (\n Math.abs(sumNodes(root.left) - sumNodes(root.right)) +\n findTilt(root.left) +\n findTilt(root.right)\n );\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/binary_in_linked_list/binary_in_linked_list.py",
"content": "def get_decimal_value(head):\n numbers = [head.val]\n\n while head.next:\n head = head.next\n numbers.append(head.val)\n\n decimal_number = 0\n base = 1\n\n for index in range(len(numbers)):\n decimal_number += base * numbers[len(numbers) - index - 1]\n base *= 2\n\n return decimal_number\n"
},
{
"path": "coding_interviews/leetcode/easy/build_an_array_with_stack_operations/build_an_array_with_stack_operations.py",
"content": "# https://leetcode.com/problems/build-an-array-with-stack-operations\n\ndef build_array(target, n):\n hash = {}\n \n for num in target:\n hash[num] = True\n \n result = []\n \n for num in range(1, n + 1):\n if len(hash) == 0: break\n \n result.append('Push')\n \n if num in hash: del hash[num]\n else: result.append('Pop')\n \n return result\n\ndef build_array(target, n):\n s = set(target)\n result = []\n\n for index in range(1, target[-1] + 1):\n result.append('Push')\n if index not in s: result.append('Pop')\n \n return result\n"
},
{
"path": "coding_interviews/leetcode/easy/build_array_from_permutation/build_array_from_permutation.js",
"content": "// https://leetcode.com/problems/build-array-from-permutation\n\nconst buildArray = function (nums) {\n return nums.map((num) => nums[num]);\n};\n"
},
{
"path": "coding_interviews/leetcode/easy/buy-two-chocolates/buy-two-chocolates-on.js",
"content": "// https://leetcode.com/problems/buy-two-chocolates\n\nfunction buyChoco(prices, money) {\n let min1 = Infinity;\n let min2 = Infinity;\n\n for (let num of prices) {\n if (num < min1) {\n min2 = min1;\n min1 = num;\n } else if (num <= min2) {\n min2 = num;\n }\n }\n\n return money - min1 - min2 >= 0 ? money - min1 - min2 : money;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/buy-two-chocolates/buy-two-chocolates-sort.js",
"content": "// https://leetcode.com/problems/buy-two-chocolates\n\nfunction buyChoco(prices, money) {\n prices.sort((a, b) => a - b);\n const first = prices[0];\n const second = prices[1];\n const diff = money - first - second;\n return diff >= 0 ? diff : money;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/buy-two-chocolates/buy-two-chocolates.js",
"content": "// https://leetcode.com/problems/buy-two-chocolates\n\nfunction buyChocolate(prices, money) {\n let price = Infinity;\n let priceIndex = 0;\n\n for (let index = 0; index < prices.length; index++) {\n if (prices[index] <= money && prices[index] < price) {\n price = prices[index];\n priceIndex = index;\n }\n }\n\n prices[priceIndex] = Infinity;\n return money - price;\n}\n\nfunction buyChoco(prices, money) {\n let restMoney = buyChocolate(prices, buyChocolate(prices, money));\n return restMoney >= 0 ? restMoney : money;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/calculate-amount-paid-in-taxes/calculate-amount-paid-in-taxes.js",
"content": "// https://leetcode.com/problems/calculate-amount-paid-in-taxes\n\nfunction calculateTax(brackets, income) {\n let taxes = 0;\n let appliedIncome = 0;\n let moneyToApplyTax;\n let tax;\n\n for (let index = 0; index < brackets.length && income > 0; index++) {\n moneyToApplyTax = Math.min(income, brackets[index][0] - appliedIncome);\n appliedIncome += moneyToApplyTax;\n tax = moneyToApplyTax * (brackets[index][1] / 100);\n taxes += tax;\n income -= moneyToApplyTax;\n }\n\n return taxes;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/calculate-delayed-arrival-time/calculate-delayed-arrival-time.js",
"content": "// https://leetcode.com/problems/calculate-delayed-arrival-time\n\nfunction findDelayedArrivalTime(arrivalTime, delayedTime) {\n return (arrivalTime + delayedTime) % 24;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/calculate-digit-sum-of-a-string/calculate-digit-sum-of-a-string.js",
"content": "function buildSubsets(s, k) {\n const subsets = [];\n\n for (let index = 0; index < s.length; index += k) {\n subsets.push(s.substring(index, index + k));\n }\n\n return subsets;\n}\n\nfunction sumDigits(digits) {\n let sumOfDigits = 0;\n\n for (let digit of digits) {\n sumOfDigits += Number(digit);\n }\n\n return sumOfDigits;\n}\n\nfunction sumDigitsOfSubsets(subsets) {\n return subsets.map(sumDigits);\n}\n\nfunction digitSum(s, k) {\n if (s.length <= k) return s;\n\n const subsets = buildSubsets(s, k);\n const sumOfDigitsOfSubsets = sumDigitsOfSubsets(subsets);\n const newString = sumOfDigitsOfSubsets.join('');\n\n return digitSum(newString, k);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/calculate-money-in-leetcode-bank/calculate-money-in-leetcode-bank.js",
"content": "function totalMoney(n) {\n let monday = 0;\n let previousDay = monday;\n let counter = monday;\n\n for (let index = 0; index < n; index++) {\n if (index % 7 === 0) {\n monday++;\n counter += monday;\n previousDay = monday;\n } else {\n previousDay++;\n counter += previousDay;\n }\n }\n\n return counter;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/can-place-flowers/can-place-flowers.js",
"content": "function canPlaceFlowers(flowerbed, n) {\n let counter = 0;\n\n for (let index = 0; index < flowerbed.length; index++) {\n if (flowerbed[index] === 0) {\n let isLeftPlotEmpty = index === 0 || flowerbed[index - 1] === 0;\n let isRightPlotEmpty =\n index === flowerbed.length - 1 || flowerbed[index + 1] === 0;\n\n if (isLeftPlotEmpty && isRightPlotEmpty) {\n flowerbed[index] = 1;\n counter++;\n }\n }\n }\n\n return counter >= n;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/capitalize-the-title/capitalize-the-title.js",
"content": "function isUppercase(char) {\n return char.charCodeAt() >= 65 && char.charCodeAt() <= 90;\n}\n\nfunction isLowercase(char) {\n return char.charCodeAt() >= 97 && char.charCodeAt() <= 122;\n}\n\nfunction capitalizeChar(char) {\n return isUppercase(char) ? char : String.fromCharCode(char.charCodeAt() - 32);\n}\n\nfunction lowercaseChar(char) {\n return isLowercase(char) ? char : String.fromCharCode(char.charCodeAt() + 32);\n}\n\nfunction capitalize(string) {\n return capitalizeChar(string[0]) + lowercase(string.slice(1));\n}\n\nfunction lowercase(string) {\n return string.split('').map(lowercaseChar).join('');\n}\n\nfunction parse(string) {\n return string.length <= 2 ? lowercase(string) : capitalize(string);\n}\n\nfunction capitalizeTitle(title) {\n return title.split(' ').map(parse).join(' ');\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/cells-in-a-range-on-an-excel-sheet/cells-in-a-range-on-an-excel-sheet.js",
"content": "const alphabet = ' ABCDEFGHIJKLMNOPQRSTUVWXYZ';\n\nexport function cellsInRange(s) {\n const result = [];\n\n for (\n let alpha = alphabet.indexOf(s[0]);\n alpha <= alphabet.indexOf(s[3]);\n alpha++\n ) {\n for (let i = Number(s[1]); i <= Number(s[4]); i++) {\n result.push(alphabet[alpha] + i.toString());\n }\n }\n\n return result;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/cells-in-a-range-on-an-excel-sheet/tests/cells-in-a-range-on-an-excel-sheet.test.js",
"content": "import { describe, it, expect } from 'vitest';\nimport { cellsInRange } from '../cells-in-a-range-on-an-excel-sheet';\n\ndescribe('cellsInRange', () => {\n it('', () => {\n expect(cellsInRange('U7:X9')).toEqual([\n 'U7',\n 'U8',\n 'U9',\n 'V7',\n 'V8',\n 'V9',\n 'W7',\n 'W8',\n 'W9',\n 'X7',\n 'X8',\n 'X9',\n ]);\n });\n\n it('', () => {\n expect(cellsInRange('P7:Z7')).toEqual([\n 'P7',\n 'Q7',\n 'R7',\n 'S7',\n 'T7',\n 'U7',\n 'V7',\n 'W7',\n 'X7',\n 'Y7',\n 'Z7',\n ]);\n });\n\n it('', () => {\n expect(cellsInRange('K1:L2')).toEqual(['K1', 'K2', 'L1', 'L2']);\n });\n\n it('', () => {\n expect(cellsInRange('A1:F1')).toEqual(['A1', 'B1', 'C1', 'D1', 'E1', 'F1']);\n });\n\n it('', () => {\n expect(cellsInRange('K2:L3')).toEqual(['K2', 'K3', 'L2', 'L3']);\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/easy/check-array-formation-through-concatenation/check-array-formation-through-concatenation.js",
"content": "function buildMap(pieces) {\n let hashmap = new Map();\n\n for (let piece of pieces) {\n hashmap.set(piece[0], piece);\n }\n\n return hashmap;\n}\n\nfunction canFormArray(arr, pieces) {\n let index = 0;\n let hashmap = buildMap(pieces);\n let output = [];\n\n while (index < arr.length) {\n let num = arr[index];\n if (!hashmap.has(num)) return false;\n output = [...output, ...hashmap.get(num)];\n index += hashmap.get(num).length;\n }\n\n if (arr.length !== output.length) return false;\n\n for (let index = 0; index < arr.length; index++) {\n if (arr[index] !== output[index]) return false;\n }\n\n return true;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/check-distances-between-same-letters/check-distances-between-same-letters.js",
"content": "function getDistanceIndex(char) {\n return char.charCodeAt() - 97;\n}\n\nfunction checkDistances(string, distance) {\n const hashmap = new Map();\n\n for (let index = 0; index < string.length; index++) {\n const char = string[index];\n\n if (hashmap.has(char)) {\n const distanceIndex = getDistanceIndex(char);\n const charDistance = distance[distanceIndex];\n const previousIndex = hashmap.get(char);\n if (index - previousIndex - 1 !== charDistance) return false;\n } else {\n hashmap.set(char, index);\n }\n }\n\n return true;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/check-if-a-string-is-an-acronym-of-words/check-if-a-string-is-an-acronym-of-words.js",
"content": "// https://leetcode.com/problems/check-if-a-string-is-an-acronym-of-words\n\nfunction isAcronym(words, s) {\n if (words.length !== s.length) return false;\n\n for (let index = 0; index < s.length; index++) {\n if (words[index][0] !== s[index]) {\n return false;\n }\n }\n\n return true;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence/check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence.js",
"content": "function hasPrefix(word, searchWord) {\n if (searchWord.length > word.length) return false;\n\n for (let index = 0; index < searchWord.length; index++) {\n if (searchWord[index] !== word[index]) return false;\n }\n\n return true;\n}\n\nfunction isPrefixOfWord(sentence, searchWord) {\n const words = sentence.split(' ');\n\n for (let index = 0; index < words.length; index++) {\n if (hasPrefix(words[index], searchWord)) return index + 1;\n }\n\n return -1;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/check-if-all-as-appears-before-all-bs/check-if-all-as-appears-before-all-bs.js",
"content": "function checkString(s) {\n let gotFirstB = false;\n\n for (let char of s) {\n if (char === 'b' && !gotFirstB) {\n gotFirstB = true;\n }\n\n if (char === 'a' && gotFirstB) {\n return false;\n }\n }\n\n return true;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/check-if-matrix-is-x-matrix/check-if-matrix-is-x-matrix.js",
"content": "function isInGrid(grid, row, col) {\n return row >= 0 && col >= 0 && row < grid.length && col < grid.length;\n}\n\nconst DIAGONAL = -1;\n\nfunction getDiagonalFromLeftToRight(grid) {\n let row = 0;\n let col = 0;\n let values = [];\n\n while (isInGrid(grid, row, col)) {\n values.push(grid[row][col]);\n grid[row][col] = DIAGONAL;\n row++;\n col++;\n }\n\n return values;\n}\n\nfunction getDiagonalFromRightToLeft(grid) {\n let row = 0;\n let col = grid.length - 1;\n let values = [];\n\n while (isInGrid(grid, row, col)) {\n if (grid[row][col] !== DIAGONAL) {\n values.push(grid[row][col]);\n grid[row][col] = DIAGONAL;\n }\n\n row++;\n col--;\n }\n\n return values;\n}\n\nfunction isDiagonalNonZero(diagonal) {\n return diagonal.filter((value) => value === 0).length === 0;\n}\n\nfunction isOtherZero(grid) {\n for (let row = 0; row < grid.length; row++) {\n for (let col = 0; col < grid.length; col++) {\n if (grid[row][col] !== DIAGONAL && grid[row][col] !== 0) {\n return false;\n }\n }\n }\n\n return true;\n}\n\nfunction checkXMatrix(grid) {\n const fromLeftToRightDiagonalValues = getDiagonalFromLeftToRight(grid);\n const fromRightToLeftDiagonalValues = getDiagonalFromRightToLeft(grid);\n const isFromLeftToRightNonZero = isDiagonalNonZero(\n fromLeftToRightDiagonalValues\n );\n const isFromRightToLeftNonZero = isDiagonalNonZero(\n fromRightToLeftDiagonalValues\n );\n const isOtherElementsZero = isOtherZero(grid);\n\n return (\n isFromLeftToRightNonZero && isFromRightToLeftNonZero && isOtherElementsZero\n );\n}\n\nfunction checkXMatrix(grid) {\n const n = grid.length;\n\n for (let i = 0; i < grid.length; i++) {\n for (let j = 0; j < grid[0].length; j++) {\n if (i == j || i + j + 1 == n) {\n if (grid[i][j] == 0) return false;\n } else {\n if (grid[i][j] != 0) return false;\n }\n }\n }\n\n return true;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/check-if-number-has-equal-digit-count-and-digit-value/check-if-number-has-equal-digit-count-and-digit-value.js",
"content": "function digitCount(num) {\n let counter = new Map();\n\n for (let digit of num) {\n if (counter.has(digit)) {\n counter.set(digit, counter.get(digit) + 1);\n } else {\n counter.set(digit, 1);\n }\n }\n\n for (let index = 0; index < num.length; index++) {\n let digit = num[index];\n let indexString = index.toString();\n\n if (\n counter.has(indexString) &&\n counter.get(indexString) !== Number(digit)\n ) {\n return false;\n }\n\n if (!counter.has(indexString) && digit !== '0') {\n return false;\n }\n }\n\n return true;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/check-if-numbers-are-ascending-in-a-sentence/check-if-numbers-are-ascending-in-a-sentence.js",
"content": "function getNumbers(string) {\n const tokens = string.split(' ');\n const numbersStrings = tokens.filter((token) => !Number.isNaN(Number(token)));\n return numbersStrings.map((numberString) => Number(numberString));\n}\n\nfunction isIncreasing(numbers) {\n for (let index = 0; index < numbers.length - 1; index++) {\n if (numbers[index + 1] <= numbers[index]) return false;\n }\n\n return true;\n}\n\nfunction areNumbersAscending(string) {\n const numbers = getNumbers(string);\n return isIncreasing(numbers);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/check-if-the-sentence-is-pangram/check-if-the-sentence-is-pangram.py",
"content": "# https://leetcode.com/problems/check-if-the-sentence-is-pangram\n\ndef check_if_pangram(sentence):\n if len(sentence) < 26: return False\n \n unique_chars = set()\n \n for char in sentence:\n unique_chars.add(char)\n \n return len(unique_chars) == 26\n\ndef check_if_pangram(sentence):\n return len(set(sentence)) == 26\n"
},
{
"path": "coding_interviews/leetcode/easy/check-whether-two-strings-are-almost-equivalent/check-whether-two-strings-are-almost-equivalent.js",
"content": "function createCounter(word) {\n const counter = new Map();\n\n for (let char of word) {\n if (counter.has(char)) counter.set(char, counter.get(char) + 1);\n else counter.set(char, 1);\n }\n\n return counter;\n}\n\nfunction isSimilar(word, counter1, counter2) {\n for (let char of word) {\n const count1 = counter1.get(char);\n const count2 = (counter2.has(char) && counter2.get(char)) || 0;\n if (Math.abs(count1 - count2) > 3) return false;\n }\n\n return true;\n}\n\nfunction checkAlmostEquivalent(word1, word2) {\n const word1Counter = createCounter(word1);\n const word2Counter = createCounter(word2);\n return (\n isSimilar(word1, word1Counter, word2Counter) &&\n isSimilar(word2, word2Counter, word1Counter)\n );\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/check_if_all_characters_have_equal_number_of_occurrences/check_if_all_characters_have_equal_number_of_occurrences.js",
"content": "// https://leetcode.com/problems/check-if-all-characters-have-equal-number-of-occurrences\n\nconst areOccurrencesEqual = function (s) {\n const counter = {};\n\n for (let i = 0; i < s.length; i++) {\n if (s[i] in counter) counter[s[i]]++;\n else counter[s[i]] = 1;\n }\n\n return new Set(Object.values(counter)).size === 1;\n};\n"
},
{
"path": "coding_interviews/leetcode/easy/check_if_two_string_arrays_are_equivalent/check_if_two_string_arrays_are_equivalent.py",
"content": "# https://leetcode.com/problems/check-if-two-string-arrays-are-equivalent\n\n\ndef array_strings_are_equal(word1, word2):\n return ''.join(word1) == ''.join(word2)"
},
{
"path": "coding_interviews/leetcode/easy/circular-sentence/circular-sentence.js",
"content": "function isCircularSentence(sentence) {\n const words = sentence.split(' ');\n const lastWord = words[words.length - 1];\n const lastCharEqualFirstChar = lastWord[lastWord.length - 1] === words[0][0];\n\n if (!lastCharEqualFirstChar) return false;\n\n for (let index = 0; index < words.length - 1; index++) {\n const firstWord = words[index];\n const nextWord = words[index + 1];\n if (firstWord[firstWord.length - 1] !== nextWord[0]) return false;\n }\n\n return true;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/climbing-stairs/climbing-stairs.js",
"content": "function climbStairs(n) {\n let memo = [0, 1, 2, 3];\n\n for (let i = 4; i <= n; i++) {\n memo.push(memo[i - 1] + memo[i - 2]);\n }\n\n return memo[n];\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/climbing_stairs.py",
"content": "# https://leetcode.com/problems/climbing-stairs/description/\n\ndef climb_stairs(n):\n memo = [0, 1, 2, 3]\n\n for i in range(4, n + 1):\n memo.append(memo[i - 1] + memo[i - 2])\n\n return memo[n]\n\nprint climb_stairs(1)\nprint climb_stairs(2)\nprint climb_stairs(3)\nprint climb_stairs(4)\nprint climb_stairs(5)\nprint climb_stairs(6)\n"
},
{
"path": "coding_interviews/leetcode/easy/concatenation_of_array/concatenation_of_array.js",
"content": "const getConcatenation = function (nums) {\n nums.forEach((num) => nums.push(num));\n return nums;\n};\n\nconst getConcatenation = function (nums) {\n return [...nums, ...nums];\n};\n"
},
{
"path": "coding_interviews/leetcode/easy/consecutive-characters/consecutive-characters.js",
"content": "function maxPower(string) {\n let power = 1;\n let max = 1;\n let currentChar = string[0];\n\n for (let index = 1; index < string.length; index++) {\n let char = string[index];\n\n if (char === currentChar) max++;\n if (char !== currentChar || index === string.length - 1) {\n currentChar = char;\n power = Math.max(max, power);\n max = 1;\n }\n }\n\n return power;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/construct-string-from-binary-tree/construct-string-from-binary-tree.js",
"content": "// https://leetcode.com/problems/construct-string-from-binary-tree\n\n/**\n * Definition for a binary tree node.\n * function TreeNode(val, left, right) {\n * this.val = (val===undefined ? 0 : val)\n * this.left = (left===undefined ? null : left)\n * this.right = (right===undefined ? null : right)\n * }\n */\n\n// Time complexity : O(n). The preorder traversal is done over the n nodes of the given Binary Tree.\n// Space complexity : O(n). The depth of the recursion tree can go upto n in case of a skewed tree.\n\nfunction tree2str(root) {\n if (!root) return '';\n\n let left = tree2str(root.left);\n let right = tree2str(root.right);\n\n if (right) {\n return `${root.val}(${left})(${right})`;\n }\n\n if (left) {\n return `${root.val}(${left})`;\n }\n\n return root.val.toString();\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/contains-duplicate/contains-duplicate-hashmap.js",
"content": "/*\nnums = [1,2,3,4,4]\nnumToCounter = {\n 1: 1,\n 2: 1,\n 3: 1,\n 4: 2\n}\n*/\n\nfunction containsDuplicate(nums) {\n let numToCounter = {};\n let appearsAtLeastTwice = false;\n\n for (let num of nums) {\n if (numToCounter[num]) {\n numToCounter[num]++;\n } else {\n numToCounter[num] = 1;\n }\n }\n\n Object.values(numToCounter).forEach((num) => {\n if (num >= 2) {\n appearsAtLeastTwice = true;\n }\n });\n\n return appearsAtLeastTwice;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/contains-duplicate/contains-duplicate.js",
"content": "function containsDuplicate(nums) {\n return !(nums.length === new Set(nums).size);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/contains-duplicate/contains-duplicate.py",
"content": "# https://leetcode.com/problems/contains-duplicate-ii\n\ndef contains_nearby_duplicate(nums, k):\n for index in range(len(nums)):\n for comp_index in range(len(nums)):\n if index != comp_index and nums[index] == nums[comp_index] and abs(comp_index - index) <= k:\n return True\n return False\n\n\ndef contains_nearby_duplicate(nums, k):\n index_mapper = {}\n\n for index, num in enumerate(nums):\n if num in index_mapper and index - index_mapper[num] <= k: return True\n index_mapper[num] = index\n\n return False"
},
{
"path": "coding_interviews/leetcode/easy/convert-sorted-array-to-binary-search-tree/convert-sorted-array-to-binary-search-tree.js",
"content": "function sortedArrayToBST(nums) {\n if (nums.length === 0) return null;\n\n const middle = Math.floor(nums.length / 2);\n const num = nums[middle];\n const node = new TreeNode(num);\n\n node.left = sortedArrayToBST(nums.slice(0, middle));\n node.right = sortedArrayToBST(nums.slice(middle + 1, nums.length));\n\n return node;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/convert-the-temperature/convert-the-temperature.js",
"content": "function convertTemperature(celsius) {\n return [celsius + 273.15, celsius * 1.8 + 32.0];\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/count-asterisks/count-asterisks.js",
"content": "function toggleCanCount(canCount) {\n return !canCount;\n}\n\nfunction countAsterisks(s) {\n let asteristics = 0;\n let canCount = true;\n\n for (let char of s) {\n if (canCount && char === '*') {\n asteristics++;\n }\n\n if (char === '|') {\n canCount = toggleCanCount(canCount);\n }\n }\n\n return asteristics;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/count-common-words-with-one-occurrence/count-common-words-with-one-occurrence.js",
"content": "function buildHashmap(words) {\n let hashmap = new Map();\n\n for (let word of words) {\n if (hashmap.has(word)) {\n hashmap.set(word, hashmap.get(word) + 1);\n } else {\n hashmap.set(word, 1);\n }\n }\n\n return hashmap;\n}\n\nfunction countWords(words1, words2) {\n let words1Counter = buildHashmap(words1);\n let words2Counter = buildHashmap(words2);\n let words = 0;\n\n for (let [word, counter] of words1Counter) {\n if (\n counter === 1 &&\n words2Counter.has(word) &&\n words2Counter.get(word) === 1\n ) {\n words++;\n }\n }\n\n return words;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/count-complete-tree-nodes/count-complete-tree-nodes.js",
"content": "// https://leetcode.com/problems/count-complete-tree-nodes\n\n/**\n * Definition for a binary tree node.\n * function TreeNode(val, left, right) {\n * this.val = (val===undefined ? 0 : val)\n * this.left = (left===undefined ? null : left)\n * this.right = (right===undefined ? null : right)\n * }\n */\nfunction countNodes(node) {\n return node ? 1 + countNodes(node.left) + countNodes(node.right) : 0;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/count-equal-and-divisible-pairs-in-an-array/count-equal-and-divisible-pairs-in-an-array-2.js",
"content": "/*\nlist = [3, 1, 2, 2, 2, 1, 3]\n\ndata structure\n{\n 3: [0, 6],\n 1: [1, 5],\n 2: [2, 3, 4]\n}\n\nworst case scenario\n{\n x: [0, 1, 2, 3, ..., 100]\n}\n*/\n\nexport function countPairs(numbers, k) {\n let counter = 0;\n\n for (let i = 0; i < numbers.length - 1; i++) {\n for (let j = i + 1; j < numbers.length; j++) {\n if (numbers[i] === numbers[j] && (i * j) % k === 0) {\n counter++;\n }\n }\n }\n\n return counter;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/count-equal-and-divisible-pairs-in-an-array/count-equal-and-divisible-pairs-in-an-array.js",
"content": "/*\nlist = [3, 1, 2, 2, 2, 1, 3]\n\ndata structure\n{\n 3: [0, 6],\n 1: [1, 5],\n 2: [2, 3, 4]\n}\n\nworst case scenario\n{\n x: [0, 1, 2, 3, ..., 100]\n}\n*/\n\nexport function countPairs(numbers, k) {\n const numberToIndices = {};\n\n numbers.forEach((number, index) => {\n if (number in numberToIndices) {\n numberToIndices[number].push(index);\n } else {\n numberToIndices[number] = [index];\n }\n });\n\n let counter = 0;\n\n Object.values(numberToIndices).forEach((indices) => {\n for (let i = 0; i < indices.length - 1; i++) {\n for (let j = i + 1; j < indices.length; j++) {\n if ((indices[i] * indices[j]) % k === 0) {\n counter++;\n }\n }\n }\n });\n\n return counter;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/count-equal-and-divisible-pairs-in-an-array/tests/count-equal-and-divisible-pairs-in-an-array-2.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport { countPairs } from '../count-equal-and-divisible-pairs-in-an-array-2';\n\ndescribe('countPairs', () => {\n it('', () => {\n expect(countPairs([3, 1, 2, 2, 2, 1, 3], 2)).toEqual(4);\n });\n\n it('', () => {\n expect(countPairs([1, 2, 3, 4], 1)).toEqual(0);\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/easy/count-equal-and-divisible-pairs-in-an-array/tests/count-equal-and-divisible-pairs-in-an-array.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport { countPairs } from '../count-equal-and-divisible-pairs-in-an-array';\n\ndescribe('countPairs', () => {\n it('', () => {\n expect(countPairs([3, 1, 2, 2, 2, 1, 3], 2)).toEqual(4);\n });\n\n it('', () => {\n expect(countPairs([1, 2, 3, 4], 1)).toEqual(0);\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/easy/count-good-triplets/count-good-triplets.py",
"content": "# https://leetcode.com/problems/count-good-triplets\n\n'''\nTime Complexity: O(N^3)\nSpace Complexity: O(1) - no extra space rather than the input\n'''\n\ndef count_good_triplets(arr, a, b, c):\n counter = 0\n \n for i in range(len(arr)):\n for j in range(i+1, len(arr)):\n for k in range(j+1, len(arr)):\n if abs(arr[i] - arr[j]) <= a and abs(arr[j] - arr[k]) <= b and abs(arr[i] - arr[k]) <= c:\n counter += 1\n \n return counter\n"
},
{
"path": "coding_interviews/leetcode/easy/count-integers-with-even-digit-sum/count-integers-with-even-digit-sum.js",
"content": "function sumDigits(numString) {\n let sum = 0;\n\n for (let digit of numString) {\n sum += Number(digit);\n }\n\n return sum;\n}\n\nfunction isEven(num) {\n return num % 2 === 0;\n}\n\nfunction countEven(num) {\n let counter = 0;\n\n for (let number = 1; number <= num; number++) {\n let numString = number.toString();\n let digitSum = sumDigits(numString);\n if (isEven(digitSum)) counter++;\n }\n\n return counter;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/count-k-difference/count-k-difference.js",
"content": "/*\nGiven an integer array nums and an integer k, return the number of pairs (i, j) where i < j such that |nums[i] - nums[j]| == k.\n\nThe value of |x| is defined as:\n\nx if x >= 0.\n-x if x < 0.\n \nExample 1:\nInput: nums = [1,2,2,1], k = 1\nOutput: 4\nExplanation: The pairs with an absolute difference of 1 are:\n- [1,2,2,1]\n- [1,2,2,1]\n- [1,2,2,1]\n- [1,2,2,1]\n\nExample 2:\nInput: nums = [1,3], k = 3\nOutput: 0\nExplanation: There are no pairs with an absolute difference of 3.\n\nExample 3:\nInput: nums = [3,2,1,5,4], k = 2\nOutput: 3\nExplanation: The pairs with an absolute difference of 2 are:\n- [3,2,1,5,4]\n- [3,2,1,5,4]\n- [3,2,1,5,4]\n*/\n\nfunction countKDifference(nums, k) {\n const numsMap = {};\n\n nums.forEach((num) => {\n if (num in numsMap) numsMap[num] += 1;\n else numsMap[num] = 1;\n });\n\n let count = 0;\n\n nums.forEach((num) => {\n const rest = num + k;\n\n if (rest in numsMap) {\n count += numsMap[rest];\n }\n });\n\n return count;\n}\n\nconsole.log(countKDifference([1, 2, 2, 1], 1), 4);\nconsole.log(countKDifference([1, 3], 3), 0);\nconsole.log(countKDifference([3, 2, 1, 5, 4], 2), 3);\nconsole.log(countKDifference([7, 10, 10, 6, 10, 1, 9, 10, 4, 9], 7), 0);\nconsole.log(countKDifference([2, 3, 2, 10, 3, 9, 4, 9, 5, 8], 1), 11);\n"
},
{
"path": "coding_interviews/leetcode/easy/count-largest-group/count-largest-group.js",
"content": "// https://leetcode.com/problems/count-largest-group\n\nfunction sumDigits(num) {\n let numString = num.toString();\n let sum = 0;\n\n for (let digit of numString) {\n sum += Number(digit);\n }\n\n return sum;\n}\n\nfunction countLargestGroup(n) {\n let hashmap = new Map();\n\n for (let num = 1; num <= n; num++) {\n let sum = sumDigits(num);\n if (hashmap.has(sum)) hashmap.set(sum, [...hashmap.get(sum), num]);\n else hashmap.set(sum, [num]);\n }\n\n let largest = -Infinity;\n\n for (let [_, values] of hashmap.entries()) {\n largest = Math.max(largest, values.length);\n }\n\n let size = 0;\n\n for (let [_, values] of hashmap.entries()) {\n if (values.length === largest) size++;\n }\n\n return size;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/count-operations-to-obtain-zero/count-operations-to-obtain-zero.js",
"content": "export function countOperations(num1, num2) {\n let counter = 0;\n\n while (num1 > 0 && num2 > 0) {\n if (num1 >= num2) {\n num1 -= num2;\n } else {\n num2 -= num1;\n }\n\n counter++;\n }\n\n return counter;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/count-operations-to-obtain-zero/tests/count-operations-to-obtain-zero.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport { countOperations } from '../count-operations-to-obtain-zero';\n\ndescribe('countOperations', () => {\n it('', () => {\n expect(countOperations(2, 3)).toEqual(3);\n });\n\n it('', () => {\n expect(countOperations(10, 10)).toEqual(1);\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/easy/count-pairs-of-similar-strings/count-pairs-of-similar-strings.js",
"content": "function buildCharsMap(word) {\n const map = new Map();\n\n for (let char of word) {\n if (map.has(char)) map.set(char, map.get(char) + 1);\n else map.set(char, 1);\n }\n\n return map;\n}\n\nfunction hasAllChars(word, charsMap) {\n for (let char of word) {\n if (!charsMap.has(char)) return false;\n }\n\n return true;\n}\n\nfunction isSimilar(word1, word2) {\n const word1CharsMap = buildCharsMap(word1);\n const word2CharsMap = buildCharsMap(word2);\n return hasAllChars(word1, word2CharsMap) && hasAllChars(word2, word1CharsMap);\n}\n\nfunction similarPairs(words) {\n let count = 0;\n\n for (let i = 0; i < words.length - 1; i++) {\n for (let j = i + 1; j < words.length; j++) {\n if (isSimilar(words[i], words[j])) count++;\n }\n }\n\n return count;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/count-pairs-whose-sum-is-less-than-target/count-pairs-whose-sum-is-less-than-target-two-pointers.js",
"content": "// https://leetcode.com/problems/count-pairs-whose-sum-is-less-than-target\n\nfunction countPairs(nums, target) {\n nums.sort((num1, num2) => num1 - num2);\n let counter = 0;\n let start = 0;\n let end = nums.length - 1;\n\n while (start < end) {\n if (nums[start] + nums[end] < target) {\n counter += end - start;\n start++;\n } else {\n end--;\n }\n }\n\n return counter;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/count-pairs-whose-sum-is-less-than-target/count-pairs-whose-sum-is-less-than-target.js",
"content": "// https://leetcode.com/problems/count-pairs-whose-sum-is-less-than-target\n\nfunction countPairs(nums, target) {\n let counter = 0;\n\n for (let i = 0; i < nums.length; i++) {\n for (let j = i + 1; j < nums.length; j++) {\n if (nums[i] + nums[j] < target) counter++;\n }\n }\n\n return counter;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/count-prefixes-of-a-given-string/count-prefixes-of-a-given-string.js",
"content": "function hasPrefix(word, s) {\n for (let index = 0; index < word.length; index++) {\n if (word[index] !== s[index]) {\n return false;\n }\n }\n\n return true;\n}\n\nfunction countPrefixes(words, s) {\n let counter = 0;\n\n for (let word of words) {\n if (word.length <= s.length && hasPrefix(word, s)) {\n counter++;\n }\n }\n\n return counter;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/count-square-sum-triples/count-square-sum-triples.js",
"content": "function countTriples(n) {\n let hashmap = new Map();\n let counter = 0;\n\n for (let num = 1; num <= n; num++) {\n hashmap.set(num * num, num);\n }\n\n for (let a = 1; a <= n; a++) {\n for (let b = 1; b <= n; b++) {\n const c = a * a + b * b;\n\n if (hashmap.has(c)) {\n counter++;\n }\n }\n }\n\n return counter;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/count-symmetric-integers/count-symmetric-integers.js",
"content": "// https://leetcode.com/problems/count-symmetric-integers\n\nfunction isSymmetricIntegers(num) {\n let numString = num.toString();\n\n if (numString.length % 2 !== 0) return false;\n\n let firstHalfSum = 0;\n let lastHalfSum = 0;\n\n for (let index = 0; index < numString.length; index++) {\n let digit = numString[index];\n if (index < numString.length / 2) firstHalfSum += Number(digit);\n else lastHalfSum += Number(digit);\n }\n\n return firstHalfSum === lastHalfSum;\n}\n\nfunction countSymmetricIntegers(low, high) {\n let count = 0;\n\n for (let num = low; num <= high; num++) {\n if (isSymmetricIntegers(num)) {\n count++;\n }\n }\n\n return count;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/count-the-digits-that-divide-a-number/count-the-digits-that-divide-a-number.js",
"content": "function countDigits(num) {\n let digitsCount = 0;\n let numString = num.toString();\n\n for (let numChar of numString) {\n if (num % Number(numChar) === 0) digitsCount++;\n }\n\n return digitsCount;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/count-the-number-of-vowel-strings-in-range/count-the-number-of-vowel-strings-in-range.js",
"content": "const VOWELS = ['a', 'e', 'i', 'o', 'u'];\n\nfunction isVowelString(string) {\n return (\n VOWELS.includes(string[0]) && VOWELS.includes(string[string.length - 1])\n );\n}\n\nfunction vowelStrings(words, left, right) {\n let vowelsStrings = 0;\n\n for (let index = left; index <= right; index++) {\n if (isVowelString(words[index])) {\n vowelsStrings++;\n }\n }\n\n return vowelsStrings;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/count-vowel-substrings-of-a-string/count-vowel-substrings-of-a-string.js",
"content": "const VOWELS = ['a', 'e', 'i', 'o', 'u'];\n\nfunction isVowel(char) {\n return VOWELS.includes(char);\n}\n\nfunction hasAllVowels(foundVowels) {\n return (\n foundVowels.has('a') &&\n foundVowels.has('e') &&\n foundVowels.has('i') &&\n foundVowels.has('o') &&\n foundVowels.has('u')\n );\n}\n\nfunction countVowelSubstrings(word) {\n let vowelSubstringCount = 0;\n\n for (let i = 0; i < word.length - 4; i++) {\n if (!isVowel(word[i])) continue;\n\n const foundVowels = new Map();\n foundVowels.set(word[i], 1);\n\n for (let index = i + 1; index < word.length; index++) {\n const char = word[index];\n if (!isVowel(char)) break;\n if (foundVowels.has(char))\n foundVowels.set(char, foundVowels.get(char) + 1);\n else foundVowels.set(char, 1);\n if (hasAllVowels(foundVowels)) vowelSubstringCount++;\n }\n }\n\n return vowelSubstringCount;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/count_good_rectangles/count_good_rectangles.py",
"content": "# https://leetcode.com/problems/number-of-rectangles-that-can-form-the-largest-square\n\n'''\nTime Complexity: O(N)\nSpace Complexity: O(N)\n'''\n\ndef count_good_rectangles(rectangles):\n max_len, all_max_lens = 0, []\n \n for rec in rectangles:\n square_len = min(rec[0], rec[1])\n max_len = max(max_len, square_len)\n all_max_lens.append(square_len)\n \n counter = 0\n\n for length in all_max_lens:\n if length == max_len:\n counter += 1\n \n return counter\n\n\ndef count_good_rectangles_optimized(rectangles):\n max_len, counter = 0, 0\n \n for rec in rectangles:\n square_len = min(rec[0], rec[1])\n \n if square_len > max_len:\n max_len = square_len\n counter = 0\n \n if square_len == max_len: \n counter += 1\n\n return counter"
},
{
"path": "coding_interviews/leetcode/easy/count_matches/count_matches.py",
"content": "# https://leetcode.com/problems/count-items-matching-a-rule\n\ndef count_matches(items, ruleKey, ruleValue):\n counter = 0\n\n for item in items:\n if ruleKey == 'type' and item[0] == ruleValue: counter += 1\n if ruleKey == 'color' and item[1] == ruleValue: counter += 1\n if ruleKey == 'name' and item[2] == ruleValue: counter += 1\n \n return counter\n"
},
{
"path": "coding_interviews/leetcode/easy/count_of_matches_in_tournament/count_of_matches_in_tournament.py",
"content": "# https://leetcode.com/problems/count-of-matches-in-tournament\n'''\nRuntime: O(N)\nSpace: O(1)\n'''\n\n\ndef number_of_matches(n):\n if n <= 0:\n return 0\n\n number_of_games = 0\n\n while n > 1:\n games = n // 2\n number_of_games += games\n\n if n % 2 == 0:\n n = games\n else:\n n = games + 1\n\n return number_of_games\n"
},
{
"path": "coding_interviews/leetcode/easy/count_students/count_students.py",
"content": "# https://leetcode.com/problems/number-of-students-unable-to-eat-lunch\n\ndef is_empty(arr):\n return len(arr) == 0\n \ndef count_students(students, sandwiches):\n preferred_circles = 0\n preferred_squares = 0\n \n for student in students:\n if student:\n preferred_squares += 1\n else:\n preferred_circles += 1\n \n while not is_empty(students) and not is_empty(sandwiches):\n if students[0] == sandwiches[0]:\n if students[0]:\n preferred_squares -= 1\n else:\n preferred_circles -= 1\n \n del students[0]\n del sandwiches[0]\n else:\n students.append(students[0])\n del students[0]\n \n if not is_empty(sandwiches) and (sandwiches[0] and preferred_squares == 0 or sandwiches[0] == 0 and preferred_circles == 0):\n break\n \n return len(students)\n\n\n\ndef count_students(students, sandwiches):\n preferences = [0, 0]\n \n for student in students:\n preferences[student] += 1\n\n index = 0\n\n while index < len(students):\n if preferences[sandwiches[index]] > 0:\n preferences[sandwiches[index]] -= 1\n else:\n break\n \n index += 1\n\n return len(students) - index"
},
{
"path": "coding_interviews/leetcode/easy/count_the_number_of_consistent_strings/count_the_number_of_consistent_strings.py",
"content": "# https://leetcode.com/problems/count-the-number-of-consistent-strings\n\n'''\nTime complexity: O(WN), where W = number of words and N = number of character of the longest string\nSpace complexity: O(N)\n'''\n\ndef count_consistent_strings(allowed, words):\n allowed_mapper = {}\n \n for char in allowed:\n allowed_mapper[char] = True\n \n counter = 0\n \n for word in words:\n all_chars_allowed = True\n \n for char in word:\n if char not in allowed_mapper:\n all_chars_allowed = False\n break\n \n if all_chars_allowed:\n counter += 1\n \n return counter\n\n'''\nTime complexity: O(WNA), where W = number of words and N = number of character of the longest string, and A = length of the allowed string\nSpace complexity: O(1)\n'''\n\ndef count_consistent_strings(allowed, words):\n counter = 0\n\n for word in words:\n counter += 1\n\n for char in word:\n if char not in allowed:\n counter -= 1\n break\n\n return counter\n"
},
{
"path": "coding_interviews/leetcode/easy/counting-bits/counting-bits.js",
"content": "function countOnesInBinaryTransformation(number) {\n let counter = 0;\n\n while (number) {\n let remainder = number % 2;\n if (remainder) counter++;\n number = Math.floor(number / 2);\n }\n\n return counter;\n}\n\nfunction countBits(n) {\n let answer = [];\n\n for (let num = 0; num <= n; num++) {\n answer.push(countOnesInBinaryTransformation(num));\n }\n\n return answer;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/counting-words-with-a-given-prefix/counting-words-with-a-given-prefix.js",
"content": "function hasPrefix(word, pref) {\n if (pref.length > word.length) {\n return false;\n }\n\n let matchesPrefix = true;\n\n for (let i = 0; i < pref.length; i++) {\n if (word[i] !== pref[i]) {\n matchesPrefix = false;\n break;\n }\n }\n\n return matchesPrefix;\n}\n\nexport function prefixCount(words, pref) {\n let count = 0;\n\n words.forEach((word) => {\n if (hasPrefix(word, pref)) {\n count++;\n }\n });\n\n return count;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/counting-words-with-a-given-prefix/tests/counting-words-with-a-given-prefix.test.js",
"content": "import { describe, it, expect } from 'vitest';\nimport { prefixCount } from '../counting-words-with-a-given-prefix';\n\ndescribe('prefixCount', () => {\n it('matches 2 words', () => {\n expect(\n prefixCount(['pay', 'attention', 'practice', 'attend'], 'at')\n ).toEqual(2);\n });\n\n it('matches 3 words', () => {\n expect(\n prefixCount(['pay', 'attention', 'practice', 'attend', 'at'], 'at')\n ).toEqual(3);\n });\n\n it('matches no word', () => {\n expect(\n prefixCount(['leetcode', 'win', 'loops', 'success'], 'code')\n ).toEqual(0);\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/easy/crawler-log-folder/crawler-log-folder.js",
"content": "function minOperations(logs) {\n let fileLevel = 0;\n\n for (let log of logs) {\n if (log === '../' && fileLevel) fileLevel--;\n else if (log === '../') {\n } else if (log === './') {\n } else fileLevel++;\n }\n\n return Math.abs(fileLevel);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/create_target_array/create_target_array.py",
"content": "# https://leetcode.com/problems/create-target-array-in-the-given-order/\n\n\ndef createTargetArray(nums, index):\n target = []\n\n for i in range(len(nums)):\n target.insert(index[i], nums[i])\n\n return target\n"
},
{
"path": "coding_interviews/leetcode/easy/decode-the-message/decode-the-message.js",
"content": "export function decodeMessage(key, message) {\n let hashmap = new Map();\n let alphabet = 'abcdefghijklmnopqrstuvwxyz';\n let counter = 0;\n\n hashmap.set(' ', ' ');\n\n for (let char of key) {\n if (!hashmap.has(char)) {\n hashmap.set(char, alphabet[counter]);\n counter++;\n }\n }\n\n let result = [];\n\n for (let char of message) {\n result.push(hashmap.get(char));\n }\n\n return result.join('');\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/decode-the-message/tests/decode-the-message.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport { decodeMessage } from '../decode-the-message';\n\ndescribe('decodeMessage', () => {\n it('', () => {\n expect(\n decodeMessage(\n 'eljuxhpwnyrdgtqkviszcfmabo',\n 'zwx hnfx lqantp mnoeius ycgk vcnjrdb'\n )\n ).toEqual('the five boxing wizards jump quickly');\n });\n\n it('', () => {\n expect(\n decodeMessage(\n 'the quick brown fox jumps over the lazy dog',\n 'vkbs bs t suepuv'\n )\n ).toEqual('this is a secret');\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/easy/decode_xored_array/decode_xored_array.py",
"content": "# https://leetcode.com/problems/decode-xored-array\n\ndef decode(encoded, first):\n original = [first]\n \n for num in encoded:\n original.append(original[-1] ^ num)\n \n return original\n"
},
{
"path": "coding_interviews/leetcode/easy/decompressed_encoded_list/decompressed_encoded_list.py",
"content": "# https://leetcode.com/problems/decompress-run-length-encoded-list\n\n'''\nWe are given a list nums of integers representing a list compressed with run-length encoding.\n\nConsider each adjacent pair of elements [freq, val] = [nums[2*i], nums[2*i+1]] (with i >= 0). For each such pair, there are freq elements with value val concatenated in a sublist. Concatenate all the sublists from left to right to generate the decompressed list.\n\nReturn the decompressed list.\n\nInput: nums = [1,2,3,4]\nOutput: [2,4,4,4]\n\nInput: nums = [1,1,2,3]\nOutput: [1,3,3]\n'''\n\n\ndef build_frequencies(frequency, num):\n return [num for i in range(frequency)]\n\n\ndef decompress_list(nums):\n result_list = []\n\n for index in range(0, len(nums), 2):\n result_list += build_frequencies(nums[index], nums[index+1])\n\n return result_list\n\n\ndata_tests = [\n ([1, 2, 3, 4], [2, 4, 4, 4]),\n ([1, 1, 2, 3], [1, 3, 3])\n]\n\n\nfor nums, expected in data_tests:\n result = decompress_list(nums)\n print(result, result == expected)\n"
},
{
"path": "coding_interviews/leetcode/easy/decrypt_string/decrypt_string.py",
"content": "# https://leetcode.com/problems/decrypt-string-from-alphabet-to-integer-mapping\n\ndef alpha(num):\n return chr(int(num) + ord('a') - 1)\n\ndef freqAlphabets(s):\n result, index, s_length = [], 0, len(s)\n\n while index < s_length:\n if index + 2 < len(s) and s[index + 2] == '#':\n result.append(alpha(s[index:index+2]))\n index += 3\n else:\n result.append(alpha(s[index]))\n index += 1\n\n return ''.join(result)\n"
},
{
"path": "coding_interviews/leetcode/easy/defanging_an_ip_address/defanging_an_ip_address.py",
"content": "# https://leetcode.com/problems/defanging-an-ip-address/\n\n'''\n\"1.1.1.1\"\n\"1[.]1[.]1[.]1\"\n\n\"255.100.50.0\"\n\"255[.]100[.]50[.]0\"\n'''\n\n\ndef defang_ip_address(address):\n address_chars_list = []\n\n for char in address:\n if char == '.':\n address_chars_list.append('[.]')\n else:\n address_chars_list.append(char)\n\n return ''.join(address_chars_list)\n\n\ndata_tests = [\n (\"1.1.1.1\", \"1[.]1[.]1[.]1\"),\n (\"255.100.50.0\", \"255[.]100[.]50[.]0\")\n]\n\nfor address, expected in data_tests:\n result = defang_ip_address(address)\n print(result, result == expected)\n"
},
{
"path": "coding_interviews/leetcode/easy/defuse-the-bomb/defuse-the-bomb.js",
"content": "function sumNextK(code, from, k) {\n let sum = 0;\n\n for (let index = from + 1; index <= from + k; index++) {\n sum += code[index];\n }\n\n return sum;\n}\n\nfunction decryptNext(code, k) {\n let newCode = [...code, ...code];\n let sum = sumNextK(newCode, 0, k);\n let nextSum = [sum];\n\n for (let index = 1; index < code.length; index++) {\n sum = sum - newCode[index] + newCode[index + k];\n nextSum.push(sum);\n }\n\n return nextSum;\n}\n\nfunction sumPreviousK(code, from, k) {\n let sum = 0;\n\n for (let index = from - 1; index >= from - k; index--) {\n sum += code[index];\n }\n\n return sum;\n}\n\nfunction decryptPrevious(code, k) {\n let newCode = [...code, ...code];\n let sum = sumPreviousK(code, code.length - 1, k);\n let previousSum = [sum];\n\n for (let index = newCode.length - 2; index >= code.length; index--) {\n sum = sum - newCode[index] + newCode[index - k];\n previousSum.push(sum);\n }\n\n return previousSum.reverse();\n}\n\nfunction decryptWithZeros(code) {\n return code.map((_) => 0);\n}\n\nfunction decrypt(code, k) {\n if (k > 0) return decryptNext(code, k);\n if (k < 0) return decryptPrevious(code, k * -1);\n return decryptWithZeros(code);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/delete-greatest-value-in-each-row/delete-greatest-value-in-each-row.js",
"content": "function isEmpty(grid) {\n let lastRow = grid[grid.length - 1];\n\n for (let col = 0; col < grid[0].length; col++) {\n if (lastRow[col] !== 0) return false;\n }\n\n return true;\n}\n\nfunction deleteGreatestValue(grid) {\n let result = 0;\n\n while (!isEmpty(grid)) {\n let max = -Infinity;\n\n for (let row = 0; row < grid.length; row++) {\n let maxCell = -Infinity;\n let maxCol = -Infinity;\n\n for (let col = 0; col < grid[row].length; col++) {\n const cell = grid[row][col];\n\n if (cell > maxCell) {\n maxCell = Math.max(cell, maxCell);\n maxCol = col;\n }\n }\n\n max = Math.max(maxCell, max);\n grid[row][maxCol] = 0;\n }\n\n result += max;\n }\n\n return result;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/delete_columns_to_make_sorted/delete_columns_to_make_sorted.py",
"content": "# https://leetcode.com/problems/delete-columns-to-make-sorted\n\ndef min_deletion_size(strs):\n counter = 0\n\n for col in range(len(strs[0])):\n column = []\n \n for row in range(len(strs)):\n column.append(strs[row][col])\n\n if column != sorted(column): counter += 1\n \n return counter\n"
},
{
"path": "coding_interviews/leetcode/easy/design-an-ordered-stream/design-an-ordered-stream.js",
"content": "const OrderedStream = function (n) {\n this.n = n;\n this.key = 1;\n this.hashmap = new Map();\n};\n\nOrderedStream.prototype.insert = function (idKey, value) {\n this.hashmap.set(idKey, value);\n\n if (this.key === idKey) {\n const chunk = [];\n\n for (let index = this.key; index <= this.n + 1; index++) {\n if (this.hashmap.has(index)) {\n const value = this.hashmap.get(index);\n chunk.push(value);\n this.hashmap.delete(index);\n this.key++;\n } else {\n return chunk;\n }\n }\n }\n\n return [];\n};\n"
},
{
"path": "coding_interviews/leetcode/easy/design-hashmap/design-hashmap.js",
"content": "const MyHashMap = function () {\n this.map = [];\n};\n\nMyHashMap.prototype.put = function (key, value) {\n let found = false;\n\n this.map.forEach(([k], index) => {\n if (key === k) {\n this.map[index] = [key, value];\n found = true;\n }\n });\n\n if (!found) this.map.push([key, value]);\n};\n\nMyHashMap.prototype.get = function (key) {\n let value = -1;\n\n this.map.forEach(([k, v]) => {\n if (key === k) {\n value = v;\n }\n });\n\n return value;\n};\n\nMyHashMap.prototype.remove = function (key) {\n this.map.forEach(([k], index) => {\n if (key === k) {\n this.map = [...this.map.slice(0, index), ...this.map.slice(index + 1)];\n }\n });\n};\n"
},
{
"path": "coding_interviews/leetcode/easy/design-hashset/design-hashset.js",
"content": "const MyHashSet = function () {\n this.hashmap = new Map();\n};\n\nMyHashSet.prototype.add = function (key) {\n this.hashmap.set(key, true);\n};\n\nMyHashSet.prototype.remove = function (key) {\n this.hashmap.delete(key);\n};\n\nMyHashSet.prototype.contains = function (key) {\n return this.hashmap.has(key);\n};\n"
},
{
"path": "coding_interviews/leetcode/easy/design_parking_system/design_parking_system.py",
"content": "# https://leetcode.com/problems/design-parking-system\n\nclass ParkingSystem:\n def __init__(self, big, medium, small):\n self.big = big\n self.medium = medium\n self.small = small\n\n def add_car(self, car_type):\n if car_type == 1:\n if self.big >= 1:\n self.big -= 1\n return True\n else:\n return False\n \n if car_type == 2:\n if self.medium >= 1:\n self.medium -= 1\n return True\n else:\n return False\n \n if car_type == 3:\n if self.small >= 1:\n self.small -= 1\n return True\n else:\n return False\n"
},
{
"path": "coding_interviews/leetcode/easy/destination_city/destination_city.py",
"content": "def dest_city(paths):\n all_origins = []\n all_destinations = []\n\n for [city1, city2] in paths:\n all_origins.append(city1)\n all_destinations.append(city2)\n\n return [d for d in all_destinations if d not in all_origins][0]\n\n\ndef dest_city(paths):\n all_origins = set()\n all_destinations = set()\n\n for [city1, city2] in paths:\n all_origins.add(city1)\n all_destinations.add(city2)\n\n return (all_destinations - all_origins).pop()\n"
},
{
"path": "coding_interviews/leetcode/easy/detect-capital/detect-capital.js",
"content": "function allCapitals(word) {\n return word === word.toUpperCase();\n}\n\nfunction allNotCapitals(word) {\n return word === word.toLowerCase();\n}\n\nfunction firstCapital(word) {\n return allCapitals(word[0]) && allNotCapitals(word.slice(1));\n}\n\nfunction detectCapitalUse(word) {\n return allCapitals(word) || allNotCapitals(word) || firstCapital(word);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/determine-if-string-halves-are-alike/determine-if-string-halves-are-alike.js",
"content": "const VOWELS = ['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'];\n\nfunction getVowelsCount(string) {\n let count = 0;\n\n for (let char of string) {\n if (VOWELS.includes(char)) count++;\n }\n\n return count;\n}\n\nfunction halvesAreAlike(s) {\n let halfIndex = s.length / 2;\n let firstHalf = s.slice(0, halfIndex);\n let secondHalf = s.slice(halfIndex);\n let firstHalfVowelsCount = getVowelsCount(firstHalf);\n let secondHalfVowelsCount = getVowelsCount(secondHalf);\n\n return firstHalfVowelsCount === secondHalfVowelsCount;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/determine_color_of_a_chessboard_square/determine_color_of_a_chessboard_square.py",
"content": "# https://leetcode.com/problems/determine-color-of-a-chessboard-square/\n\nmapper = {\n 'a': 1,\n 'b': 2,\n 'c': 3,\n 'd': 4,\n 'e': 5,\n 'f': 6,\n 'g': 7,\n 'h': 8\n}\n\ndef is_even(num):\n return num % 2 == 0\n\ndef square_is_white(coordinates):\n x, y = mapper[coordinates[0]], int(coordinates[1])\n if x == y or (is_even(x - y)): return False\n return True\n\ndef square_is_white(coordinates):\n x, y = mapper[coordinates[0]], int(coordinates[1])\n return not (x == y or (is_even(x - y)))\n\ndef square_is_white(coordinates):\n return ord(coordinates[0]) % 2 != int(coordinates[1]) % 2\n"
},
{
"path": "coding_interviews/leetcode/easy/di_string_match/di_string_match.py",
"content": "# https://leetcode.com/problems/di-string-match\n\ndef di_string_match(S):\n permutation, top, bottom = [], len(S), 0\n\n for char in S:\n if char == 'I':\n permutation.append(bottom)\n bottom += 1\n else:\n permutation.append(top)\n top -= 1\n \n permutation.append(top)\n return permutation\n"
},
{
"path": "coding_interviews/leetcode/easy/difference-between-element-sum-and-digit-sum-of-an-array/difference-between-element-sum-and-digit-sum-of-an-array.js",
"content": "function getDigitsSum(num) {\n let digits = 0;\n let numString = num.toString();\n\n for (let numChar of numString) {\n digits += Number(numChar);\n }\n\n return digits;\n}\n\nfunction differenceOfSum(nums) {\n let elementSum = 0;\n let digitSum = 0;\n\n for (let num of nums) {\n elementSum += num;\n digitSum += getDigitsSum(num);\n }\n\n return Math.abs(elementSum - digitSum);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/discount_price/discount_price.py",
"content": "def finalPrices(prices):\n result = []\n\n for index, price in enumerate(prices):\n discount = get_discount(prices, index, price)\n result.append(price - discount)\n\n return result\n\n\ndef get_discount(prices, index, price):\n for other_price in prices[index + 1:]:\n if other_price <= price:\n return other_price\n\n return 0\n"
},
{
"path": "coding_interviews/leetcode/easy/distribute-candies-among-children-i/distribute-candies-among-children-i.js",
"content": "// https://leetcode.com/problems/distribute-candies-among-children-i\n\nfunction distributeCandies(n, limit) {\n let count = 0;\n\n for (let i = limit; i >= 0; i--) {\n for (let j = limit; j >= 0; j--) {\n for (let k = limit; k >= 0; k--) {\n if (i + j + k === n) {\n count++;\n }\n }\n }\n }\n\n return count;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/distribute-candies-among-children-i/distribute-candies-among-children-ii.js",
"content": "// https://leetcode.com/problems/distribute-candies-among-children-i\n\nfunction distributeCandies(n, limit) {\n let count = 0;\n\n for (let i = limit; i >= 0; i--) {\n for (let j = limit; j >= 0; j--) {\n let k = n - i - j;\n if (k >= 0 && k <= limit) {\n count++;\n }\n }\n }\n\n return count;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/distribute-candies-to-people/distribute-candies-to-people.js",
"content": "function initPeopleCandies(numPeople) {\n let peopleCandies = [];\n\n for (let i = 0; i < numPeople; i++) {\n peopleCandies.push(0);\n }\n\n return peopleCandies;\n}\n\nfunction distributeCandies(candies, numPeople) {\n let peopleCandies = initPeopleCandies(numPeople);\n let numOfCandies = 1;\n let index = 0;\n\n while (candies) {\n let candiesToAssign = numOfCandies > candies ? candies : numOfCandies;\n peopleCandies[index] += candiesToAssign;\n candies -= candiesToAssign;\n numOfCandies++;\n index = (index + 1) % numPeople;\n }\n\n return peopleCandies;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/divide-a-string-into-groups-of-size-k/divide-a-string-into-groups-of-size-k.js",
"content": "function fillChar(lastGroup, fill, length) {\n let chars = [];\n\n for (let i = 1; i <= length; i++) {\n chars.push(fill);\n }\n\n return lastGroup + chars.join('');\n}\n\nfunction divideString(s, k, fill) {\n let groups = [];\n let groupSize = 0;\n let group = [];\n\n for (let index = 0; index < s.length; index++) {\n group.push(s[index]);\n groupSize++;\n\n if (groupSize === k) {\n groups.push(group.join(''));\n groupSize = 0;\n group = [];\n } else if (index === s.length - 1) {\n groups.push(group.join(''));\n }\n }\n\n let lastGroup = groups[groups.length - 1];\n let lastGroupLength = lastGroup.length;\n\n if (lastGroupLength !== k) {\n lastGroup = fillChar(lastGroup, fill, k - lastGroupLength);\n groups[groups.length - 1] = lastGroup;\n }\n\n return groups;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/divide-array-into-equal-pairs/divide-array-into-equal-pairs.js",
"content": "export function divideArray(nums) {\n const map = {};\n\n for (let num of nums) {\n if (map[num]) {\n map[num] += 1;\n } else {\n map[num] = 1;\n }\n }\n\n let hasEqualPairs = true;\n\n for (let num of Object.values(map)) {\n if (num % 2 !== 0) {\n hasEqualPairs = false;\n break;\n }\n }\n\n return hasEqualPairs;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/divide-array-into-equal-pairs/tests/divide-array-into-equal-pairs.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport { divideArray } from '../divide-array-into-equal-pairs';\n\ndescribe('divideArray', () => {\n it('', () => {\n expect(divideArray([3, 2, 3, 2, 2, 2])).toEqual(true);\n });\n\n it('', () => {\n expect(divideArray([1, 2, 3, 4])).toEqual(false);\n });\n\n it('', () => {\n expect(divideArray([2, 2])).toEqual(true);\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/easy/divisible-and-non-divisible-sums-difference/divisible-and-non-divisible-sums-difference.js",
"content": "// https://leetcode.com/problems/divisible-and-non-divisible-sums-difference\n\nfunction differenceOfSums(n, m) {\n let num1 = 0,\n num2 = 0;\n\n for (let num = 1; num <= n; num++) {\n if (num % m === 0) num2 += num;\n else num1 += num;\n }\n\n return num1 - num2;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/divisor-game/divisor-game.js",
"content": "// https://leetcode.com/problems/divisor-game\n\nfunction divisorGame(n) {\n return n % 2 === 0;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/equal_reversed_arrays/equal_reversed_arrays.py",
"content": "# https://leetcode.com/problems/make-two-arrays-equal-by-reversing-sub-arrays\n\n'''\nGiven two integer arrays of equal length target and arr.\nIn one step, you can select any non-empty sub-array of arr and reverse it.\nYou are allowed to make any number of steps.\n\nReturn True if you can make arr equal to target, or False otherwise.\n\nInput: target = [1,2,3,4], arr = [2,4,1,3]\nOutput: true\n\nInput: target = [7], arr = [7]\nOutput: true\n\nInput: target = [1,12], arr = [12,1]\nOutput: true\n'''\n\n# 0(nlogn)\n\n\ndef can_be_equal(target, arr):\n return target == arr or sorted(target) == sorted(arr)\n\n\n# 0(n)\n\ndef can_be_equal(target, arr):\n counter = {}\n\n for index in range(len(target)):\n target_item, arr_item = target[index], arr[index]\n\n if target_item in counter:\n counter[target_item] += 1\n else:\n counter[target_item] = 1\n\n if arr_item in counter:\n counter[arr_item] += 1\n else:\n counter[arr_item] = 1\n\n for _, value in counter.items():\n if value % 2 != 0:\n return False\n\n return True\n\n\ndef can_be_equal(target, arr):\n return collections.Counter(target) == collections.Counter(arr)\n"
},
{
"path": "coding_interviews/leetcode/easy/evaluate-boolean-binary-tree/evaluate-boolean-binary-tree.js",
"content": "const values = {\n or: 2,\n and: 3,\n};\n\nfunction evaluateTree(root) {\n if ([0, 1].includes(root.val)) return Boolean(root.val);\n\n const left = evaluateTree(root.left);\n const right = evaluateTree(root.right);\n\n return root.val === values.or ? left || right : left && right;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/even_digits/even_digits.py",
"content": "# https://leetcode.com/problems/find-numbers-with-even-number-of-digits/\n\n\ndef find_numbers(nums):\n counter = 0\n\n for num in nums:\n if len(str(num)) % 2 == 0:\n counter += 1\n\n return counter\n"
},
{
"path": "coding_interviews/leetcode/easy/excel-sheet-column-number/excel-sheet-column-number.js",
"content": "function toNumber(char) {\n return char.charCodeAt(0) - 64;\n}\n\nfunction titleToNumber(columnTitle) {\n let columnNumber = 0;\n\n for (let col of columnTitle) {\n const num = toNumber(col);\n columnNumber = columnNumber * 26 + num;\n }\n\n return columnNumber;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/fair-candy-swap/fair-candy-swap-optimized.js",
"content": "function sum(nums) {\n let sumOfNums = 0;\n\n for (let num of nums) {\n sumOfNums += num;\n }\n\n return sumOfNums;\n}\n\nfunction buildMap(bobSizes) {\n let hashmap = new Map();\n\n for (let bobSize of bobSizes) {\n hashmap.set(bobSize, bobSize);\n }\n\n return hashmap;\n}\n\nfunction fairCandySwap(aliceSizes, bobSizes) {\n let aliceCandies = sum(aliceSizes);\n let bobCandies = sum(bobSizes);\n let hashmap = buildMap(bobSizes);\n\n for (let aliceSize of aliceSizes) {\n let bobCandy = (bobCandies + 2 * aliceSize - aliceCandies) / 2;\n if (hashmap.has(bobCandy)) {\n return [aliceSize, bobCandy];\n }\n }\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/fair-candy-swap/fair-candy-swap.js",
"content": "function sum(nums) {\n let sumOfNums = 0;\n\n for (let num of nums) {\n sumOfNums += num;\n }\n\n return sumOfNums;\n}\n\nfunction fairCandySwap(aliceSizes, bobSizes) {\n let aliceCandies = sum(aliceSizes);\n let bobCandies = sum(bobSizes);\n\n for (let i = 0; i < aliceSizes.length; i++) {\n for (let j = 0; j < bobSizes.length; j++) {\n let aliceCandy = aliceSizes[i];\n let bobCandy = bobSizes[j];\n\n if (\n aliceCandies - aliceCandy + bobCandy ===\n bobCandies - bobCandy + aliceCandy\n ) {\n return [aliceCandy, bobCandy];\n }\n }\n }\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/faulty-keyboard/faulty-keyboard.js",
"content": "// https://leetcode.com/problems/faulty-keyboard\n\nfunction reverse(s) {\n let reversedS = [];\n\n for (let index = s.length - 1; index >= 0; index--) {\n reversedS.push(s[index]);\n }\n\n return reversedS;\n}\n\nfunction finalString(s) {\n let subS = [];\n\n for (let char of s) {\n if (char === 'i') subS = reverse(subS);\n else subS.push(char);\n }\n\n return subS.join('');\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/fibonacci_number/fibonacci_number.py",
"content": "# https://leetcode.com/problems/fibonacci-number\n\ndef fib(n):\n cache = [0, 1]\n prev_1, prev_2 = 0, 1\n \n if n == 0: return 0\n if n == 1: return 1\n \n for _ in range(2, n + 1):\n cache.append(cache[prev_1] + cache[prev_2])\n prev_1 += 1\n prev_2 += 1\n \n return cache[-1]"
},
{
"path": "coding_interviews/leetcode/easy/final-value-after-operations/final-value-after-operations.js",
"content": "/*\nThere is a programming language with only four operations and one variable X:\n\n++X and X++ increments the value of the variable X by 1.\n--X and X-- decrements the value of the variable X by 1.\nInitially, the value of X is 0.\n\nGiven an array of strings operations containing a list of operations, return the final value of X after performing all the operations.\n\n# Example 1\nInput: operations = [\"--X\",\"X++\",\"X++\"]\nOutput: 1\nExplanation: The operations are performed as follows:\nInitially, X = 0.\n--X: X is decremented by 1, X = 0 - 1 = -1.\nX++: X is incremented by 1, X = -1 + 1 = 0.\nX++: X is incremented by 1, X = 0 + 1 = 1.\n\n# Example 2\nInput: operations = [\"++X\",\"++X\",\"X++\"]\nOutput: 3\nExplanation: The operations are performed as follows:\nInitially, X = 0.\n++X: X is incremented by 1, X = 0 + 1 = 1.\n++X: X is incremented by 1, X = 1 + 1 = 2.\nX++: X is incremented by 1, X = 2 + 1 = 3.\n\n# Example 3\nInput: operations = [\"X++\",\"++X\",\"--X\",\"X--\"]\nOutput: 0\nExplanation: The operations are performed as follows:\nInitially, X = 0.\nX++: X is incremented by 1, X = 0 + 1 = 1.\n++X: X is incremented by 1, X = 1 + 1 = 2.\n--X: X is decremented by 1, X = 2 - 1 = 1.\nX--: X is decremented by 1, X = 1 - 1 = 0.\n*/\n\nconst operationsMap = {\n '--X': -1,\n 'X--': -1,\n '++X': +1,\n 'X++': +1,\n};\n\nfunction finalValueAfterOperations(operations = []) {\n let x = 0;\n\n operations.forEach((operation) => {\n x += operationsMap[operation];\n });\n\n return x;\n}\n\nconsole.log(finalValueAfterOperations(['--X', 'X++', 'X++']), 1);\nconsole.log(finalValueAfterOperations(['++X', '++X', 'X++']), 3);\nconsole.log(finalValueAfterOperations(['X++', '++X', '--X', 'X--']), 0);\n"
},
{
"path": "coding_interviews/leetcode/easy/find-all-k-distant-indices-in-an-array/find-all-k-distant-indices-in-an-array.js",
"content": "function getJs(nums, key) {\n let js = [];\n\n for (let index = 0; index < nums.length; index++) {\n if (nums[index] === key) js.push(index);\n }\n\n return js;\n}\n\nfunction isKDistant(index, js, k) {\n for (let j of js) {\n if (Math.abs(index - j) <= k) return true;\n }\n\n return false;\n}\n\nfunction findKDistantIndices(nums, key, k) {\n const js = getJs(nums, key);\n const output = [];\n console.log('js', js);\n\n for (let index = 0; index < nums.length; index++) {\n if (isKDistant(index, js, k)) {\n output.push(index);\n }\n }\n\n return output;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/find-all-numbers-disappeared-in-an-array/find-all-numbers-disappeared-in-an-array.js",
"content": "function buildMap(nums) {\n let hashmap = new Map();\n\n for (let num of nums) {\n hashmap.set(num, true);\n }\n\n return hashmap;\n}\n\nfunction findDisappearedNumbers(nums) {\n let hashmap = buildMap(nums);\n let output = [];\n\n for (let num = 1; num <= nums.length; num++) {\n if (!hashmap.has(num)) output.push(num);\n }\n\n return output;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/find-center-of-star-graph/find-center-of-star-graph.js",
"content": "function addConnection(nodeToConnectionsCount, node) {\n if (nodeToConnectionsCount[node]) {\n nodeToConnectionsCount[node]++;\n } else {\n nodeToConnectionsCount[node] = 1;\n }\n}\n\nfunction findCenter(edges) {\n let nodeToConnectionsCount = {};\n\n for (let [first, second] of edges) {\n addConnection(nodeToConnectionsCount, first);\n addConnection(nodeToConnectionsCount, second);\n }\n\n let star;\n let maxConnections = -Infinity;\n\n Object.entries(nodeToConnectionsCount).forEach(([node, count]) => {\n if (count > maxConnections) {\n star = node;\n maxConnections = count;\n }\n });\n\n return star;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/find-champion-i/find-champion-i-no-map.js",
"content": "// https://leetcode.com/problems/find-champion-i\n\nfunction findChampion(grid) {\n for (let i = 0; i < grid.length; i++) {\n let count = 0;\n\n for (let j = 0; j < grid[i].length; j++) {\n if (grid[i][j] === 1) {\n count++;\n }\n }\n\n if (count === grid.length - 1) {\n return i;\n }\n }\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/find-champion-i/find-champion-i.js",
"content": "// https://leetcode.com/problems/find-champion-i\n\nfunction findChampion(grid) {\n let winners = new Map();\n\n for (let i = 0; i < grid.length; i++) {\n for (let j = 0; j < grid[i].length; j++) {\n if (grid[i][j] === 1) {\n winners.set(i, (winners.get(i) || 0) + 1);\n }\n }\n }\n\n for (let [key, value] of winners.entries()) {\n if (value === grid.length - 1) {\n return key;\n }\n }\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/find-first-palindromic-string-in-the-array/find-first-palindromic-string-in-the-array.js",
"content": "export function isPalindrome(word) {\n for (let i = 0; i < Math.floor(word.length / 2); i++) {\n if (word[i] !== word[word.length - 1 - i]) {\n return false;\n }\n }\n\n return true;\n}\n\nexport function firstPalindrome(words) {\n let palindromicWord = '';\n\n for (let i = 0; i < words.length; i++) {\n if (isPalindrome(words[i])) {\n palindromicWord = words[i];\n break;\n }\n }\n\n return palindromicWord;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/find-first-palindromic-string-in-the-array/tests/find-first-palindromic-string-in-the-array.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport {\n firstPalindrome,\n isPalindrome,\n} from '../find-first-palindromic-string-in-the-array';\n\ndescribe('firstPalindrome', () => {\n it('', () => {\n expect(firstPalindrome(['abc', 'car', 'ada', 'racecar', 'cool'])).toEqual(\n 'ada'\n );\n });\n\n it('', () => {\n expect(firstPalindrome(['notapalindrome', 'racecar'])).toEqual('racecar');\n });\n\n it('', () => {\n expect(firstPalindrome(['def', 'ghi'])).toEqual('');\n });\n});\n\ndescribe('isPalindrome', () => {\n it('', () => {\n expect(isPalindrome('ada')).toBeTruthy();\n });\n\n it('', () => {\n expect(isPalindrome('')).toBeTruthy();\n });\n\n it('', () => {\n expect(isPalindrome('eda')).toBeFalsy();\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/easy/find-greatest-common-divisor-of-array/find-greatest-common-divisor-of-array.js",
"content": "// https://leetcode.com/problems/find-greatest-common-divisor-of-array\n\nconst findSmallestAndLargest = (nums) => {\n let smallest = Infinity;\n let largest = -Infinity;\n\n for (let i = 0; i < nums.length; i++) {\n smallest = Math.min(smallest, nums[i]);\n largest = Math.max(largest, nums[i]);\n }\n\n return [smallest, largest];\n};\n\nconst gcd = (num1, num2) => (num2 ? gcd(num2, num1 % num2) : num1);\n\nconst findGCD = (nums) => {\n const [smallest, largest] = findSmallestAndLargest(nums);\n return gcd(smallest, largest);\n};\n"
},
{
"path": "coding_interviews/leetcode/easy/find-indices-with-index-and-value-difference-i/find-indices-with-index-and-value-difference-i.js",
"content": "// https://leetcode.com/problems/find-indices-with-index-and-value-difference-i\n\nfunction findIndices(nums, indexDifference, valueDifference) {\n for (let i = 0; i < nums.length; i++) {\n for (let j = 0; j < nums.length; j++) {\n if (\n Math.abs(i - j) >= indexDifference &&\n Math.abs(nums[i] - nums[j]) >= valueDifference\n ) {\n return [i, j];\n }\n }\n }\n\n return [-1, -1];\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/find-lucky-integer-in-an-array/find-lucky-integer-in-an-array.js",
"content": "function buildNumCounter(nums) {\n let counter = new Map();\n\n for (let num of nums) {\n if (counter.has(num)) counter.set(num, counter.get(num) + 1);\n else counter.set(num, 1);\n }\n\n return counter;\n}\n\nfunction findLucky(nums) {\n let largestLuckyInteger = -1;\n let counter = buildNumCounter(nums);\n\n for (let num of nums) {\n if (num === counter.get(num) && num > largestLuckyInteger) {\n largestLuckyInteger = num;\n }\n }\n\n return largestLuckyInteger;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/find-maximum-number-of-string-pairs/find-maximum-number-of-string-pairs.js",
"content": "// https://leetcode.com/problems/find-maximum-number-of-string-pairs\n\nfunction paired(s1, s2) {\n for (let i = 0; i < s1.length; i++) {\n if (s1[i] !== s2[s2.length - 1 - i]) {\n return false;\n }\n }\n\n return true;\n}\n\nfunction maximumNumberOfStringPairs(words) {\n let max = 0;\n\n for (let i = 0; i < words.length - 1; i++) {\n for (let j = i + 1; j < words.length; j++) {\n if (paired(words[i], words[j])) {\n max++;\n }\n }\n }\n\n return max;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/find-nearest-point-that-has-the-same-x-or-y-coordinate/find-nearest-point-that-has-the-same-x-or-y-coordinate.js",
"content": "// https://leetcode.com/problems/find-nearest-point-that-has-the-same-x-or-y-coordinate\n// points = [] - not empty\n// x and y positive numbers\n\nconst nearestValidPoint = (x, y, points) => {\n let minDistance = Infinity;\n let pointIndex = -1;\n\n points.forEach((point, index) => {\n if (isValid([x, y], point)) {\n const manhattanDistance = calculateManhattanDistance([x, y], point);\n if (manhattanDistance < minDistance) {\n pointIndex = index;\n minDistance = manhattanDistance;\n }\n }\n });\n\n return pointIndex;\n};\n\nconst isValid = (position, point) => {\n const [x, y] = position;\n const [pointX, pointY] = point;\n return x === pointX || y === pointY;\n};\n\nconst calculateManhattanDistance = (position, point) => {\n const [x, y] = position;\n const [pointX, pointY] = point;\n return Math.abs(x - pointX) + Math.abs(y - pointY);\n};\n"
},
{
"path": "coding_interviews/leetcode/easy/find-subarrays-with-equal-sum/find-subarrays-with-equal-sum.js",
"content": "function findSubarrays(nums) {\n for (let i = 0; i < nums.length - 2; i++) {\n for (let j = i + 1; j < nums.length - 1; j++) {\n if (nums[i] + nums[i + 1] === nums[j] + nums[j + 1]) return true;\n }\n }\n\n return false;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/find-target-indices-after-sorting-array/find-target-indices-after-sorting-array.js",
"content": "export function targetIndices(nums, target) {\n const sortedNums = nums.sort((num1, num2) => num1 - num2);\n const result = [];\n\n sortedNums.forEach((num, index) => {\n if (num === target) {\n result.push(index);\n }\n });\n\n return result;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/find-target-indices-after-sorting-array/tests/find-target-indices-after-sorting-array.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport { targetIndices } from '../find-target-indices-after-sorting-array';\n\ndescribe('targetIndices', () => {\n it('', () => {\n expect(\n targetIndices(\n [\n 48, 90, 9, 21, 31, 35, 19, 69, 29, 52, 100, 54, 21, 86, 6, 45, 42, 5,\n 62, 77, 15, 38,\n ],\n 6\n )\n ).toEqual([1]);\n });\n\n it('', () => {\n expect(targetIndices([1, 2, 5, 2, 3], 2)).toEqual([1, 2]);\n });\n\n it('', () => {\n expect(targetIndices([1, 2, 5, 2, 3], 3)).toEqual([3]);\n });\n\n it('', () => {\n expect(targetIndices([1, 2, 5, 2, 3], 5)).toEqual([4]);\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/easy/find-the-array-concatenation-value/find-the-array-concatenation-value.js",
"content": "function concat(num1, num2) {\n return Number(num1.toString() + num2.toString());\n}\n\nfunction findTheArrayConcVal(nums) {\n let pointer1 = 0;\n let pointer2 = nums.length - 1;\n let output = 0;\n\n while (pointer1 <= pointer2) {\n if (pointer1 === pointer2) output += nums[pointer1];\n else output += concat(nums[pointer1], nums[pointer2]);\n pointer1++;\n pointer2--;\n }\n\n return output;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/find-the-difference/find-the-difference.js",
"content": "function buildMap(string) {\n let hashmap = new Map();\n\n for (let char of string) {\n if (hashmap.has(char)) hashmap.set(char, hashmap.get(char) + 1);\n else hashmap.set(char, 1);\n }\n\n return hashmap;\n}\n\nfunction findTheDifference(s, t) {\n let hashmap = buildMap(s);\n\n for (let char of t) {\n if (hashmap.has(char) && hashmap.get(char) > 0) {\n hashmap.set(char, hashmap.get(char) - 1);\n continue;\n }\n\n return char;\n }\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/find-the-difference-of-two-arrays/find-the-difference-of-two-arrays.js",
"content": "function buildHashmap(nums) {\n let hashmap = new Map();\n\n for (let num of nums) {\n hashmap.set(num, true);\n }\n\n return hashmap;\n}\n\nfunction buildDistinct(nums, hashmap) {\n let distinct = [];\n\n for (let num of nums) {\n if (!hashmap.has(num)) {\n distinct.push(num);\n hashmap.set(num, true);\n }\n }\n\n return distinct;\n}\n\nfunction findDifference(nums1, nums2) {\n let hashmap1 = buildHashmap(nums1);\n let hashmap2 = buildHashmap(nums2);\n let distinct1 = buildDistinct(nums1, hashmap2);\n let distinct2 = buildDistinct(nums2, hashmap1);\n\n return [distinct1, distinct2];\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/find-the-distance-value-between-two-arrays/find-the-distance-value-between-two-arrays.js",
"content": "// https://leetcode.com/problems/find-the-distance-value-between-two-arrays\n\nfunction hasSmallerValue(num, arr, d) {\n for (let number of arr) {\n if (Math.abs(num - number) <= d) return true;\n }\n\n return false;\n}\n\nfunction findTheDistanceValue(arr1, arr2, d) {\n let count = 0;\n\n for (let num1 of arr1) {\n if (!hasSmallerValue(num1, arr2, d)) count++;\n }\n\n return count;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/find-the-distinct-difference-array/find-the-distinct-difference-array.js",
"content": "// https://leetcode.com/problems/find-the-distinct-difference-array\n\nfunction countDistinct(nums, startIndex, endIndex) {\n let count = 0;\n let distinct = new Map();\n\n for (let i = startIndex; i <= endIndex; i++) {\n if (!distinct.has(nums[i])) {\n distinct.set(nums[i], nums[i]);\n count++;\n }\n }\n\n return count;\n}\n\nfunction countDistinctPrefix(nums, index) {\n return countDistinct(nums, 0, index);\n}\n\nfunction countDistinctSufix(nums, index) {\n return countDistinct(nums, index + 1, nums.length - 1);\n}\n\nfunction distinctDifferenceArray(nums) {\n let diff = [];\n\n for (let index = 0; index < nums.length; index++) {\n let prefix = countDistinctPrefix(nums, index);\n let sufix = countDistinctSufix(nums, index);\n diff.push(prefix - sufix);\n }\n\n return diff;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/find-the-distinct-difference-array/optimized-find-the-distinct-difference-array.js",
"content": "// https://leetcode.com/problems/find-the-distinct-difference-array\n\nfunction distinctDifferenceArray(nums) {\n let distinctDiff = [];\n let countInLeft = 0;\n let countInRight = 0;\n let leftCounterMap = new Map();\n let rightCounterMap = new Map();\n\n for (let num of nums) {\n if (leftCounterMap.has(num)) {\n leftCounterMap.set(num, leftCounterMap.get(num) + 1);\n } else {\n leftCounterMap.set(num, 1);\n countInLeft++;\n }\n }\n\n distinctDiff.unshift(countInLeft - countInRight);\n\n for (let index = nums.length - 1; index > 0; index--) {\n let num = nums[index];\n leftCounterMap.set(num, leftCounterMap.get(num) - 1);\n if (leftCounterMap.get(num) === 0) countInLeft--;\n rightCounterMap.set(num, (rightCounterMap.get(num) || 0) + 1);\n if (rightCounterMap.get(num) === 1) countInRight++;\n distinctDiff.unshift(countInLeft - countInRight);\n }\n\n return distinctDiff;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/find-the-maximum-achievable-number/find-the-maximum-achievable-number.js",
"content": "// https://leetcode.com/problems/find-the-maximum-achievable-number\n\nfunction theMaximumAchievableX(num, t) {\n return t * 2 + num;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/find-the-middle-index-in-array/find-the-middle-index-in-array.js",
"content": "function sum(nums) {\n return nums.reduce((sumOfNums, num) => sumOfNums + num, 0);\n}\n\nfunction findMiddleIndex(nums) {\n let sumOfNums = sum(nums) - nums[0];\n let firstHalfSum = 0;\n let index = 0;\n\n while (index < nums.length - 1 && sumOfNums !== firstHalfSum) {\n sumOfNums -= nums[index + 1];\n firstHalfSum += nums[index];\n index++;\n }\n\n return sumOfNums === firstHalfSum ? index : -1;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/find-the-pivot-integer/find-the-pivot-integer.js",
"content": "const NO_PIVOT = -1;\n\nfunction sum(n) {\n let sumOfNs = 0;\n\n for (let num = 1; num <= n; num++) {\n sumOfNs += num;\n }\n\n return sumOfNs;\n}\n\nfunction pivotInteger(n) {\n let sumOfNs = sum(n);\n let leftSum = 0;\n\n for (let num = 1; num <= n; num++) {\n leftSum += num;\n if (sumOfNs === leftSum) return num;\n sumOfNs -= num;\n }\n\n return NO_PIVOT;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/find-the-width-of-columns-of-a-grid/find-the-width-of-columns-of-a-grid.js",
"content": "// https://leetcode.com/problems/find-the-width-of-columns-of-a-grid\n\nfunction findColumnWidth(grid) {\n let output = [];\n\n for (let col = 0; col < grid[0].length; col++) {\n let max = -Infinity;\n for (let row = 0; row < grid.length; row++) {\n let cell = grid[row][col];\n let length = cell.toString().length;\n max = Math.max(max, length);\n }\n output.push(max);\n }\n\n return output;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/find-words-containing-character/find-words-containing-character.js",
"content": "// https://leetcode.com/problems/find-words-containing-character\n\nfunction findWordsContaining(words, x) {\n let indices = [];\n\n for (let index = 0; index < words.length; index++) {\n for (let char of words[index]) {\n if (char === x) {\n indices.push(index);\n break;\n }\n }\n }\n\n return indices;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/find-words-that-can-be-formed-by-characters/find-words-that-can-be-formed-by-characters.js",
"content": "function buildCounter(chars) {\n let counter = new Map();\n\n for (let char of chars) {\n if (counter.has(char)) counter.set(char, counter.get(char) + 1);\n else counter.set(char, 1);\n }\n\n return counter;\n}\n\nfunction isGood(word, counterCopy) {\n for (let char of word) {\n if (counterCopy.has(char) && counterCopy.get(char) > 0)\n counterCopy.set(char, counterCopy.get(char) - 1);\n else return false;\n }\n\n return true;\n}\n\nfunction countCharacters(words, chars) {\n let counter = buildCounter(chars);\n let counterCopy;\n let goodWords = [];\n\n for (let word of words) {\n counterCopy = new Map(counter);\n if (isGood(word, counterCopy)) goodWords.push(word);\n }\n\n return goodWords.reduce((lengths, word) => lengths + word.length, 0);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/find_common_characters/find_common_characters.py",
"content": "# https://leetcode.com/problems/find-common-characters\n\ndef common_chars(A):\n if len(A) == 1: return [char for char in A]\n\n word = A[0]\n words = A[1:]\n result = []\n\n for char in word:\n all = True\n \n for index, other_word in enumerate(words):\n if char in other_word:\n other_word_index = other_word.index(char)\n words[index] = words[index][:other_word_index] + words[index][other_word_index+1:]\n else:\n all = False\n break\n \n if all: result.append(char)\n \n return result\n\n"
},
{
"path": "coding_interviews/leetcode/easy/find_the_highest_altitude/find_the_highest_altitude.py",
"content": "# https://leetcode.com/problems/find-the-highest-altitude\n\ndef largest_altitude(gain):\n highest_altitude, current_altitude = 0, 0 \n\n for net_gain in gain:\n current_altitude += net_gain\n if current_altitude > highest_altitude:\n highest_altitude = current_altitude\n \n return highest_altitude"
},
{
"path": "coding_interviews/leetcode/easy/first-bad-version/first-bad-version-binary-search.js",
"content": "function getMiddle(start, end) {\n return Math.floor((start + end) / 2);\n}\n\nfunction binarySearchFirstBadVersion(isBadVersion) {\n return (n) => {\n let start = 1;\n let end = n;\n let middle = getMiddle(start, end);\n let firstBadVersion = middle;\n\n while (start < end) {\n if (isBadVersion(middle)) {\n end = middle - 1;\n } else {\n start = middle + 1;\n }\n\n middle = getMiddle(start, end);\n\n if (isBadVersion(middle)) {\n firstBadVersion = middle;\n }\n }\n\n return firstBadVersion;\n };\n}\n\nfunction solution(isBadVersion) {\n return binarySearchFirstBadVersion(isBadVersion);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/first-bad-version/first-bad-version.js",
"content": "function solution(isBadVersion) {\n return function (n) {\n for (let version = 1; version <= n; version++) {\n if (isBadVersion(version)) {\n return version;\n }\n }\n };\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/first-letter-to-appear-twice/first-letter-to-appear-twice.js",
"content": "function repeatedCharacter(s) {\n let counter = new Map();\n\n for (let char of s) {\n if (counter.has(char)) {\n return char;\n }\n\n counter.set(char, 1);\n }\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/first-unique-character-in-a-string/first-unique-character-in-a-string.js",
"content": "function firstUniqChar(s) {\n let charCount = {};\n\n for (let char of s) {\n if (charCount[char]) {\n charCount[char]++;\n } else {\n charCount[char] = 1;\n }\n }\n\n for (let index = 0; index < s.length; index++) {\n if (charCount[s[index]] === 1) {\n return index;\n }\n }\n\n return -1;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/first_bad_version/first_bad_version.py",
"content": "'''\nApproach #1 (Linear Scan) [Time Limit Exceeded]\nThe straight forward way is to brute force it by doing a linear scan.\n\nComplexity analysis\n\nTime complexity : O(n)O(n). Assume that isBadVersion(version)isBadVersion(version) takes constant time to check if a version is bad. It takes at most n - 1n−1 checks, therefore the overall time complexity is O(n)O(n).\n\nSpace complexity : O(1)O(1).\n\nApproach #2 (Binary Search) [Accepted]\nIt is not difficult to see that this could be solved using a classic algorithm - Binary search. Let us see how the search space could be halved each time below.\n\nScenario #1: isBadVersion(mid) => false\n\n 1 2 3 4 5 6 7 8 9\n G G G G G G B B B G = Good, B = Bad\n | | |\nleft mid right\nLet us look at the first scenario above where isBadVersion(mid) \\Rightarrow falseisBadVersion(mid)⇒false. We know that all versions preceding and including midmid are all good. So we set left = mid + 1left=mid+1 to indicate that the new search space is the interval [mid + 1, right][mid+1,right] (inclusive).\n\nScenario #2: isBadVersion(mid) => true\n\n 1 2 3 4 5 6 7 8 9\n G G G B B B B B B G = Good, B = Bad\n | | |\nleft mid right\nThe only scenario left is where isBadVersion(mid) \\Rightarrow trueisBadVersion(mid)⇒true. This tells us that midmid may or may not be the first bad version, but we can tell for sure that all versions after midmid can be discarded. Therefore we set right = midright=mid as the new search space of interval [left,mid][left,mid] (inclusive).\n\nIn our case, we indicate leftleft and rightright as the boundary of our search space (both inclusive). This is why we initialize left = 1left=1 and right = nright=n. How about the terminating condition? We could guess that leftleft and rightright eventually both meet and it must be the first bad version, but how could you tell for sure?\n\nThe formal way is to prove by induction, which you can read up yourself if you are interested. Here is a helpful tip to quickly prove the correctness of your binary search algorithm during an interview. We just need to test an input of size 2. Check if it reduces the search space to a single element (which must be the answer) for both of the scenarios above. If not, your algorithm will never terminate.\n\nIf you are setting mid = \\frac{left + right}{2}mid=\n2\nleft+right\n\n , you have to be very careful. Unless you are using a language that does not overflow such as Python, left + rightleft+right could overflow. One way to fix this is to use left + \\frac{right - left}{2}left+\n2\nright−left\n\n instead.\n\nIf you fall into this subtle overflow bug, you are not alone. Even Jon Bentley's own implementation of binary search had this overflow bug and remained undetected for over twenty years.\n\nComplexity analysis\n\nTime complexity : O(logn). The search space is halved each time, so the time complexity is O(\\log n)O(logn).\n\nSpace complexity : O(1).\n'''\n\n\ndef is_bad_version(version):\n True\n\n\ndef first_bad_version(n):\n start = 1\n last = n\n\n while start < last:\n middle = (start + last) / 2\n\n if is_bad_version(middle):\n last = middle\n else:\n start = middle + 1\n\n return start\n"
},
{
"path": "coding_interviews/leetcode/easy/fizz-buzz/fizz-buzz.js",
"content": "function fizzBuzz(n) {\n const answer = [];\n\n for (let i = 1; i <= n; i++) {\n if (i % 3 === 0 && i % 5 === 0) {\n answer.push('FizzBuzz');\n continue;\n }\n\n if (i % 3 === 0) {\n answer.push('Fizz');\n continue;\n }\n\n if (i % 5 === 0) {\n answer.push('Buzz');\n continue;\n }\n\n answer.push(String(i));\n }\n\n return answer;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/flipping_an_image.py",
"content": "# https://leetcode.com/problems/flipping-an-image/description/\n\n# input: [[1,1,0], [1,0,1], [0,0,0]]\n# output: [[1,0,0], [0,1,0], [1,1,1]]\n\ndef flip_and_invert_image(image):\n for i in range(len(image)):\n image[i] = image[i][::-1]\n\n for i in range(len(image)):\n for j in range(len(image[i])):\n image[i][j] = 1 - image[i][j]\n\n return image\n\nprint(flip_and_invert_image([[1,1,0], [1,0,1], [0,0,0]]))\n"
},
{
"path": "coding_interviews/leetcode/easy/flood-fill/flood-fill-without-visited.js",
"content": "function isInsideTheGrid(image, row, col) {\n const validRow = row >= 0 && row < image.length;\n const validCol = col >= 0 && col < image[0].length;\n return validRow && validCol;\n}\n\nfunction dfs(image, row, col, newColor, startingPixel) {\n if (isInsideTheGrid(image, row, col) && image[row][col] === startingPixel) {\n image[row][col] = newColor;\n dfs(image, row - 1, col, newColor, startingPixel);\n dfs(image, row, col + 1, newColor, startingPixel);\n dfs(image, row, col - 1, newColor, startingPixel);\n dfs(image, row + 1, col, newColor, startingPixel);\n }\n}\n\nfunction floodFill(image, row, col, newColor) {\n if (image[row][col] !== newColor) {\n dfs(image, row, col, newColor, image[row][col]);\n }\n\n return image;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/flood-fill/flood-fill.js",
"content": "/**\n- is it inside the grid?\n- is it equal to the target value?\n - update the pixe with newColor\n - recursive call for: top, left, right, bottom\n */\n\nfunction isInsideTheGrid(image, row, col) {\n const validRow = row >= 0 && row < image.length;\n const validCol = col >= 0 && col < image[0].length;\n return validRow && validCol;\n}\n\nfunction floodFillHelper(image, sr, sc, newColor, startingPixel, visited) {\n if (isInsideTheGrid(image, sr, sc)) {\n let currentPixel = image[sr][sc];\n\n if (currentPixel === startingPixel && !visited[sr][sc]) {\n image[sr][sc] = newColor;\n visited[sr][sc] = true;\n\n let topPosition = {\n row: sr - 1,\n col: sc,\n };\n\n let rightPosition = {\n row: sr,\n col: sc + 1,\n };\n\n let leftPosition = {\n row: sr,\n col: sc - 1,\n };\n\n let bottomPosition = {\n row: sr + 1,\n col: sc,\n };\n\n floodFillHelper(\n image,\n topPosition.row,\n topPosition.col,\n newColor,\n startingPixel,\n visited\n );\n\n floodFillHelper(\n image,\n rightPosition.row,\n rightPosition.col,\n newColor,\n startingPixel,\n visited\n );\n\n floodFillHelper(\n image,\n leftPosition.row,\n leftPosition.col,\n newColor,\n startingPixel,\n visited\n );\n\n floodFillHelper(\n image,\n bottomPosition.row,\n bottomPosition.col,\n newColor,\n startingPixel,\n visited\n );\n }\n }\n}\n\nfunction buildVisitedMatrix(image) {\n let matrix = [];\n\n for (let row = 0; row < image.length; row++) {\n let r = [];\n\n for (let col = 0; col < image[row].length; col++) {\n r.push(false);\n }\n\n matrix.push(r);\n }\n\n return matrix;\n}\n\nfunction floodFill(image, sr, sc, newColor) {\n let visited = buildVisitedMatrix(image);\n floodFillHelper(image, sr, sc, newColor, image[sr][sc], visited);\n return image;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/furthest-point-from-origin/furthest-point-from-origin.js",
"content": "// https://leetcode.com/problems/furthest-point-from-origin\n\nfunction furthestDistanceFromOrigin(moves) {\n let diff = 0;\n let underlines = 0;\n\n for (let move of moves) {\n if (move === '_') underlines++;\n if (move === 'R') diff++;\n if (move === 'L') diff--;\n }\n\n return Math.abs(diff) + underlines;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/generate_the_string/generate_the_string.py",
"content": "# https://leetcode.com/problems/generate-a-string-with-characters-that-have-odd-counts\n\ndef generate_the_string(n):\n if n % 2 == 0:\n return 'a' * (n - 1) + 'b'\n \n return 'a' * n"
},
{
"path": "coding_interviews/leetcode/easy/goal_parser_interpretation/goal_parser_interpretation.py",
"content": "# https://leetcode.com/problems/goal-parser-interpretation\n\n\ndef interpret(command):\n result, empty_paren = [], True\n\n for char in command:\n if char == 'G':\n result.append('G')\n else:\n if char == ')':\n if empty_paren:\n result.append('o')\n else:\n result.append('al')\n empty_paren = True\n elif char != '(':\n empty_paren = False\n\n return ''.join(result)\n"
},
{
"path": "coding_interviews/leetcode/easy/greatest-english-letter-in-upper-and-lower-case/greatest-english-letter-in-upper-and-lower-case.js",
"content": "function greatestLetter(string) {\n let greatest = [-Infinity, ''];\n let charsToCode = new Map();\n\n for (let char of string) {\n let lowerCasedChar = char.toLowerCase();\n let charCode = char.charCodeAt();\n\n if (\n charsToCode.has(lowerCasedChar) &&\n charsToCode.get(lowerCasedChar) !== charCode\n ) {\n const greaterCharCode = Math.max(\n charCode,\n charsToCode.get(lowerCasedChar)\n );\n greatest =\n greaterCharCode > greatest[0]\n ? [greaterCharCode, char.toUpperCase()]\n : greatest;\n } else if (!charsToCode.has(lowerCasedChar)) {\n charsToCode.set(lowerCasedChar, charCode);\n }\n }\n\n return greatest[1];\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/greatest_candies/greatest_candies.py",
"content": "# https://leetcode.com/problems/kids-with-the-greatest-number-of-candies/\n\n'''\n[2, 3, 3, 1, 3] 2\n[True, True, True, True, True]\n'''\n\n\ndef kids_with_candies(candies, extra_candies):\n greatest = get_greatest(candies)\n return map_can_be_greatest(candies, extra_candies, greatest)\n\n\ndef map_can_be_greatest(candies, extra_candies, greatest_candy):\n greatest_possibilities = []\n\n for candy in candies:\n greatest_possibilities.append(candy + extra_candies >= greatest_candy)\n\n return greatest_possibilities\n\n\ndef get_greatest(candies):\n greatest = candies[0]\n\n for candy in candies:\n if candy > greatest:\n greatest = candy\n\n return greatest\n\n\ndata_tests = [\n ([2, 3, 3, 1, 3], 2, [True, True, True, True, True]),\n ([4, 2, 1, 1, 2], 1, [True, False, False, False, False]),\n ([12, 1, 12], 10, [True, False, True]),\n]\n\nfor candies, extra_candies, expected in data_tests:\n result = kids_with_candies(candies, extra_candies)\n print(result, result == expected)\n"
},
{
"path": "coding_interviews/leetcode/easy/guess-number-higher-or-lower/guess-number-higher-or-lower.js",
"content": "// https://leetcode.com/problems/guess-number-higher-or-lower\n\nfunction guessNumber(n) {\n let start = 1;\n let end = n;\n let middle = Math.round(n / 2);\n\n while (guess(middle)) {\n if (guess(middle) > 0) {\n start = middle + 1;\n } else {\n end = middle - 1;\n }\n\n middle = Math.round(end + start) / 2;\n }\n\n return middle;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/halves_are_alike/halves_are_alike.py",
"content": "# https://leetcode.com/problems/determine-if-string-halves-are-alike/\n\n\ndef halves_are_alike(s):\n vowels = {\n 'a': True, \n 'e': True, \n 'i': True, \n 'o': True, \n 'u': True, \n 'A': True, \n 'E': True, \n 'I': True, \n 'O': True, \n 'U': True, \n }\n \n \n middle_index = len(s) // 2\n a, b = s[:middle_index], s[middle_index:]\n a_counter, b_counter = 0, 0\n \n for char in a:\n if char in vowels:\n a_counter += 1\n \n for char in b:\n if char in vowels:\n b_counter += 1\n \n return a_counter == b_counter"
},
{
"path": "coding_interviews/leetcode/easy/hamming_distance/hamming_distance.py",
"content": "def get_bit(number):\n return \"{0:b}\".format(number)\n\ndef hamming_distance(x, y):\n x_bit = get_bit(x)\n y_bit = get_bit(y)\n \n min_len = min(len(x_bit), len(y_bit))\n max_len = max(len(x_bit), len(y_bit))\n diff_len = max_len - min_len\n \n if len(x_bit) > len(y_bit):\n max_bit = x_bit\n min_bit = y_bit\n else:\n max_bit = y_bit\n min_bit = x_bit\n \n min_bit = '0' * diff_len + min_bit\n \n counter = 0\n \n for index in range(max_len):\n if max_bit[index] != min_bit[index]: counter += 1\n \n return counter\n\ndef hamming_distance_2(x, y):\n counter = 0\n\n while x or y:\n if (x % 2) != (y % 2): counter += 1\n x //= 2\n y //= 2\n\n return counter"
},
{
"path": "coding_interviews/leetcode/easy/height_checker/height_checker.py",
"content": "# https://leetcode.com/problems/height-checker\n\ndef height_checker(heights):\n sorted_heights, counter = sorted(heights), 0\n \n for index in range(len(heights)):\n if heights[index] != sorted_heights[index]:\n counter += 1\n \n return counter"
},
{
"path": "coding_interviews/leetcode/easy/implement-queue-using-stacks/implement-queue-using-stacks.js",
"content": "const MyQueue = function () {\n this.list = [];\n};\n\nMyQueue.prototype.push = function (x) {\n this.list.push(x);\n};\n\nMyQueue.prototype.pop = function () {\n return this.list.shift();\n};\n\nMyQueue.prototype.peek = function () {\n return this.list[0];\n};\n\nMyQueue.prototype.empty = function () {\n return this.list.length === 0;\n};\n"
},
{
"path": "coding_interviews/leetcode/easy/implement-stack-using-queues/implement-stack-using-queues.js",
"content": "function MyStack() {\n this.items = [];\n}\n\nMyStack.prototype.push = function (x) {\n this.items.push(x);\n};\n\nMyStack.prototype.pop = function () {\n return this.items.pop();\n};\n\nMyStack.prototype.top = function () {\n return this.items.at(-1);\n};\n\nMyStack.prototype.empty = function () {\n return this.items.length === 0;\n};\n"
},
{
"path": "coding_interviews/leetcode/easy/increasing_decreasing_string/incresing_decreasin_string.py",
"content": "\n# https://leetcode.com/problems/increasing-decreasing-string/\n\n\ndef sort_string(s):\n result = []\n \n while len(s):\n last_appended, to_be_appended, chosen_index = float('-Inf'), float('Inf'), float('Inf')\n\n while chosen_index is not None:\n chosen_index = None\n\n for index, char in enumerate(s):\n unicode_char = ord(char)\n\n if unicode_char > last_appended and unicode_char < to_be_appended:\n to_be_appended = unicode_char\n chosen_index = index\n\n if chosen_index is not None:\n result.append(chr(to_be_appended))\n last_appended = to_be_appended\n to_be_appended = float('Inf')\n s = s[0:chosen_index] + s[chosen_index+1:]\n\n last_appended, to_be_appended, chosen_index = float('Inf'), float('-Inf'), float('Inf')\n\n while chosen_index is not None:\n chosen_index = None\n\n for index, char in enumerate(s):\n unicode_char = ord(char)\n\n if unicode_char < last_appended and unicode_char > to_be_appended:\n to_be_appended = unicode_char\n chosen_index = index\n\n if chosen_index is not None:\n result.append(chr(to_be_appended))\n last_appended = to_be_appended\n to_be_appended = float('-Inf')\n s = s[0:chosen_index] + s[chosen_index+1:]\n \n return ''.join(result)"
},
{
"path": "coding_interviews/leetcode/easy/increasing_order_search_tree/increasing_order_search_tree.py",
"content": "def increasingBST(root):\n arr = []\n helper(root, arr)\n\n ans = current = TreeNode(arr[0])\n \n for val in arr[1:]:\n current.right = TreeNode(val)\n current = current.right\n \n return ans\n \ndef helper(self, old_tree, arr):\n if old_tree.left: helper(old_tree.left, arr)\n arr.append(old_tree.val)\n if old_tree.right: helper(old_tree.right, arr)\n"
},
{
"path": "coding_interviews/leetcode/easy/intersection-of-multiple-arrays/intersection-of-multiple-arrays.js",
"content": "function intersection(nums) {\n const numberCounts = new Map();\n const numsLength = nums.length;\n const intersectionNums = [];\n\n for (let numsList of nums) {\n for (let num of numsList) {\n if (numberCounts.has(num)) {\n numberCounts.set(num, numberCounts.get(num) + 1);\n } else {\n numberCounts.set(num, 1);\n }\n }\n }\n\n for (let [num, count] of numberCounts.entries()) {\n if (count === numsLength) {\n intersectionNums.push(num);\n }\n }\n\n return intersectionNums.sort((a, b) => a - b);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/intersection-of-two-arrays-ii/intersection-of-two-arrays-ii.js",
"content": "/*\nnums1 = [1,2,2,1], nums2 = [2,2] => [2] => []\nresult = [2,2]\nRuntime: O(N^3)\nSpace: O(N)\n\nnums1 = [1,2,2,1], nums2 = [2,2]\nhashmap = { 1: 2, 2: 2 }; => { 1: 2, 2: 1 }; => { 1: 2, 2: 0 };\nresult = [2, 2]\nRuntime: O(N) + O(N) => O(N)\nSpace: O(N) + O(N) => O(N)\n*/\n\nfunction intersect(nums1, nums2) {\n let numsCount = {};\n\n for (let num of nums1) {\n if (numsCount[num]) {\n numsCount[num]++;\n } else {\n numsCount[num] = 1;\n }\n }\n\n let result = [];\n\n for (let num of nums2) {\n if (numsCount[num]) {\n numsCount[num]--;\n result.push(num);\n }\n }\n\n return result;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/intersection_of_two_arrays/intersection_of_two_arrays.py",
"content": "# https://leetcode.com/problems/intersection-of-two-arrays/\n\n\ndef intersection(nums1, nums2):\n intersect_set = set()\n \n for num1 in nums1:\n for num2 in nums2:\n if num1 == num2:\n intersect_set.add(num1)\n \n return intersect_set\n\ndef intersection(nums1, nums2):\n return set(nums1).intersection(nums2)\n\n\ndef intersection(nums1, nums2):\n nums_mapper = {}\n\n for num in nums1:\n nums_mapper[num] = True\n\n nums = set()\n\n for num in nums2:\n if num in nums_mapper:\n nums.add(num)\n\n return nums"
},
{
"path": "coding_interviews/leetcode/easy/intersection_of_two_arrays_ii/intersection_of_two_arrays.py",
"content": "# https://leetcode.com/problems/intersection-of-two-arrays-ii\n\n\ndef intersection(nums1, nums2):\n hash_map = {}\n\n for num in nums1:\n if num in hash_map:\n hash_map[num] += 1\n else:\n hash_map[num] = 1\n\n nums = []\n\n for num in nums2:\n if num in hash_map and hash_map[num]:\n nums.append(num)\n hash_map[num] -= 1\n\n return nums"
},
{
"path": "coding_interviews/leetcode/easy/invert-binary-tree/invert-binary-tree.js",
"content": "function invertTree(root) {\n if (!root) {\n return root;\n }\n\n let leftNode = root.left;\n let rightNode = root.right;\n\n root.left = invertTree(rightNode);\n root.right = invertTree(leftNode);\n\n return root;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/is-subsequence/is-subsequence.js",
"content": "// https://leetcode.com/problems/is-subsequence\n\nfunction isSubsequence(s, t) {\n let sIndex = 0;\n let tIndex = 0;\n\n while (sIndex < s.length && tIndex < t.length) {\n let sChar = s[sIndex];\n let tChar = t[tIndex];\n\n if (sChar === tChar) {\n sIndex++;\n tIndex++;\n } else {\n tIndex++;\n }\n }\n\n return sIndex === s.length;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/is_palindrome.py",
"content": "# https://leetcode.com/problems/palindrome-number/description/\n\ndef is_palindrome(x):\n if x < 0:\n return False\n\n s = ''\n\n while x > 0:\n s += str(x % 10)\n x /= 10\n\n return s == s[::-1]\n"
},
{
"path": "coding_interviews/leetcode/easy/is_sum_equal/is_sum_equal.py",
"content": "# https://leetcode.com/problems/check-if-word-equals-summation-of-two-words\n\nalphabet = {\n 'a': '0',\n 'b': '1',\n 'c': '2',\n 'd': '3',\n 'e': '4',\n 'f': '5',\n 'g': '6',\n 'h': '7',\n 'i': '8',\n 'j': '9',\n}\n\ndef get_numerical_value(word):\n list_of_chars = []\n \n for char in word:\n list_of_chars.append(alphabet[char])\n \n return int(''.join(list_of_chars))\n\ndef is_sum_equal(first_word, second_word, target_word):\n first_num = get_numerical_value(first_word)\n second_num = get_numerical_value(second_word)\n target_num = get_numerical_value(target_word)\n return first_num + second_num == target_num\n"
},
{
"path": "coding_interviews/leetcode/easy/island-perimeter/island-perimeter.js",
"content": "function isOffGrid(grid, row, col) {\n return row < 0 || row >= grid.length || col < 0 || col >= grid[0].length;\n}\n\nfunction isWater(grid, row, col) {\n return grid[row][col] === 0;\n}\n\nfunction isPartOfIsland(grid, row, col) {\n return grid[row][col] === 1;\n}\n\nfunction wasAlreadyVisited(grid, row, col) {\n return grid[row][col] === 2;\n}\n\nfunction dfs(grid, row, col) {\n if (isOffGrid(grid, row, col) || isWater(grid, row, col)) {\n return 1;\n }\n\n if (wasAlreadyVisited(grid, row, col)) {\n return 0;\n }\n\n grid[row][col] = 2;\n\n return (\n dfs(grid, row, col - 1) +\n dfs(grid, row, col + 1) +\n dfs(grid, row - 1, col) +\n dfs(grid, row + 1, col)\n );\n}\n\nfunction islandPerimeter(grid) {\n let perimeter = 0;\n\n for (let row = 0; row < grid.length; row++) {\n for (let col = 0; col < grid[row].length; col++) {\n if (isPartOfIsland(grid, row, col)) {\n perimeter += dfs(grid, row, col);\n }\n }\n }\n\n return perimeter;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/jewels_and_stones.py",
"content": "# https://leetcode.com/problems/jewels-and-stones/description/\n\n# input: J = \"aA\" | S = \"aAAbbbb\"\n# output: 3\n\n# input: J = \"z\", S = \"ZZ\"\n# output: 0\n\n# Solution: O(N^2)\n\n\ndef num_jewels_in_stones(J, S):\n jewels = 0\n\n for j in J:\n for s in S:\n if s == j:\n jewels += 1\n\n return jewels\n\n\nprint(num_jewels_in_stones(\"aA\", \"aAAbbbb\"))\nprint(num_jewels_in_stones(\"z\", \"ZZ\"))\n\n# Solution: O(N)\n\n\ndef num_jewels_in_stones_opt(J, S):\n number_by_chars = {}\n counter = 0\n\n for char in J:\n if char in number_by_chars:\n number_by_chars[char] += 1\n else:\n number_by_chars[char] = 1\n\n for char in S:\n if char in number_by_chars:\n counter += number_by_chars[char]\n\n return counter\n\n\nprint(num_jewels_in_stones_opt(\"aA\", \"aAAbbbb\"))\nprint(num_jewels_in_stones_opt(\"z\", \"ZZ\"))\n"
},
{
"path": "coding_interviews/leetcode/easy/judge_route_circle.py",
"content": "'''\nhttps://leetcode.com/problems/judge-route-circle/description/\n\nExample 1:\nInput: \"UD\"\nOutput: true\n\nExample 2:\nInput: \"LL\"\nOutput: false\n'''\n\ndef judge_circle(moves):\n horizontal, vertical = 0, 0\n moves_mapper = { 'U': 1, 'D': -1, 'R': 1, 'L': -1 }\n for move in moves:\n if move in ['U', 'D']:\n vertical += moves_mapper[move]\n else:\n horizontal += moves_mapper[move]\n\n return horizontal == 0 and vertical == 0\n\nprint(judge_circle(\"UD\"))\nprint(judge_circle(\"LL\"))\n"
},
{
"path": "coding_interviews/leetcode/easy/judge_route_circle_one_line.py",
"content": "'''\nhttps://leetcode.com/problems/judge-route-circle/description/\n\nExample 1:\nInput: \"UD\"\nOutput: true\n\nExample 2:\nInput: \"LL\"\nOutput: false\n'''\n\ndef judge_circle(moves):\n return moves.count(\"U\") == moves.count(\"D\") and moves.count(\"R\") == moves.count(\"L\")\n\nprint(judge_circle(\"UD\"))\nprint(judge_circle(\"LL\"))\n"
},
{
"path": "coding_interviews/leetcode/easy/k-items-with-the-maximum-sum/k-items-with-the-maximum-sum-second.js",
"content": "// https://leetcode.com/problems/k-items-with-the-maximum-sum\n\nfunction kItemsWithMaximumSum(numOnes, numZeros, numNegOnes, k) {\n if (k <= numOnes) {\n return k;\n }\n\n let sum = 0;\n\n if (numOnes) {\n sum += numOnes;\n k -= numOnes;\n }\n\n if (k > 0 && numZeros) {\n k -= numZeros;\n }\n\n if (k > 0 && numNegOnes) {\n sum -= k;\n }\n\n return sum;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/k-items-with-the-maximum-sum/k-items-with-the-maximum-sum.js",
"content": "// https://leetcode.com/problems/k-items-with-the-maximum-sum\n\nfunction kItemsWithMaximumSum(numOnes, numZeros, numNegOnes, k) {\n let max = 0;\n let mutK = k;\n\n mutK -= numOnes;\n if (mutK <= 0) return k;\n max += numOnes;\n mutK -= numZeros;\n if (mutK <= 0) return max;\n if (mutK - numNegOnes < 0) return max - mutK;\n max -= numNegOnes;\n return max;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/keep-multiplying-found-values-by-two/keep-multiplying-found-values-by-two.js",
"content": "function findFinalValue(nums, original) {\n let keepProcessing = true;\n let originalCopy = original;\n\n while (keepProcessing) {\n let foundOriginal = false;\n\n for (let num of nums) {\n if (num === originalCopy) {\n foundOriginal = true;\n }\n }\n\n if (foundOriginal) {\n originalCopy *= 2;\n } else {\n keepProcessing = false;\n }\n }\n\n return originalCopy;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/keyboard-row/keyboard-row.js",
"content": "function stringToMap(string) {\n const map = new Map();\n\n for (let char of string) {\n map.set(char, true);\n }\n\n return map;\n}\n\nconst firstRow = stringToMap('qwertyuiop');\nconst secondRow = stringToMap('asdfghjkl');\nconst thirdRow = stringToMap('zxcvbnm');\n\nfunction belongsToRow(word, row) {\n for (let char of word) {\n if (!row.has(char)) {\n return false;\n }\n }\n\n return true;\n}\n\nfunction belongsToSomeRow(word) {\n let belongsToARow = belongsToRow(word, firstRow);\n if (belongsToARow) return true;\n belongsToARow = belongsToRow(word, secondRow);\n if (belongsToARow) return true;\n belongsToARow = belongsToRow(word, thirdRow);\n return belongsToARow;\n}\n\nfunction findWords(words) {\n const result = [];\n\n for (let word of words) {\n if (belongsToSomeRow(word.toLowerCase())) {\n result.push(word);\n }\n }\n\n return result;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/kth-distinct-string-in-an-array/kth-distinct-string-in-an-array.js",
"content": "function kthDistinct(arr, k) {\n let count = 0;\n let hashmap = new Map();\n\n for (let string of arr) {\n if (hashmap.has(string)) {\n hashmap.set(string, hashmap.get(string) + 1);\n } else {\n hashmap.set(string, 1);\n }\n }\n\n let distinctStrings = [];\n\n hashmap.forEach((count, string) => {\n if (count === 1) {\n distinctStrings.push(string);\n }\n });\n\n for (let string of distinctStrings) {\n count++;\n if (count === k) return string;\n }\n\n return '';\n}\n\nfunction kthDistinct(arr, k) {\n let hashmap = new Map();\n\n for (let string of arr) {\n if (hashmap.has(string)) {\n hashmap.set(string, hashmap.get(string) + 1);\n } else {\n hashmap.set(string, 1);\n }\n }\n\n let distinctStrings = [];\n\n hashmap.forEach((count, string) => {\n if (count === 1) {\n distinctStrings.push(string);\n }\n });\n\n return distinctStrings[k - 1] || '';\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/largest-local-values-in-a-matrix/largest-local-values-in-a-matrix.js",
"content": "function getLargestFromGrid(grid, startRow, startCol, endRow, endCol) {\n let largest = -Infinity;\n\n for (let row = startRow; row <= endRow; row++) {\n for (let col = startCol; col <= endCol; col++) {\n largest = Math.max(largest, grid[row][col]);\n }\n }\n\n return largest;\n}\n\nfunction largestLocal(grid) {\n const generatedGrid = [];\n\n for (let row = 0; row < grid.length - 2; row++) {\n const generatedRow = [];\n\n for (let col = 0; col < grid[row].length - 2; col++) {\n generatedRow.push(getLargestFromGrid(grid, row, col, row + 2, col + 2));\n }\n\n generatedGrid.push(generatedRow);\n }\n\n return generatedGrid;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/largest-number-after-digit-swaps-by-parity/largest-number-after-digit-swaps-by-parity.js",
"content": "// https://leetcode.com/problems/largest-number-after-digit-swaps-by-parity\n\nconst isEven = (num) => num % 2 === 0;\nconst isOdd = (num) => !isEven(num);\n\nfunction largestInteger(num) {\n let numString = num.toString().split('');\n\n for (let index = 0; index < numString.length - 1; index++) {\n let digit = Number(numString[index]);\n let isDigitEven = isEven(digit);\n let maxDigit = digit;\n let swapIndex1 = index;\n let swapIndex2;\n\n for (\n let digitIndex = index + 1;\n digitIndex < numString.length;\n digitIndex++\n ) {\n let otherDigit = Number(numString[digitIndex]);\n let isOtherDigitEven = isEven(otherDigit);\n\n if (isDigitEven && isOtherDigitEven && otherDigit > maxDigit) {\n maxDigit = otherDigit;\n swapIndex2 = digitIndex;\n }\n\n if (!isDigitEven && !isOtherDigitEven && otherDigit > maxDigit) {\n maxDigit = otherDigit;\n swapIndex2 = digitIndex;\n }\n }\n\n if (swapIndex2) {\n let aux = numString[swapIndex1];\n numString[swapIndex1] = numString[swapIndex2];\n numString[swapIndex2] = aux;\n }\n }\n\n return numString.join('');\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/largest-positive-integer-that-exists-with-its-negative/largest-positive-integer-that-exists-with-its-negative.js",
"content": "function findMaxK(nums) {\n const hashmap = new Map();\n\n for (let num of nums) {\n if (!hashmap.has(num)) hashmap.set(num, true);\n }\n\n let output = -1;\n\n for (let num of nums) {\n if (num > output && hashmap.has(num * -1)) {\n output = num;\n }\n }\n\n return output;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/last-stone-weight/last-stone-weight.js",
"content": "function getTwoHaviest(stones) {\n const first = stones[0];\n const second = stones[1];\n\n let heaviest = first > second ? first : second;\n let secondHeaviest = first > second ? second : first;\n\n for (let i = 2; i < stones.length; i++) {\n const stone = stones[i];\n\n if (stone > heaviest) {\n secondHeaviest = heaviest;\n heaviest = stone;\n continue;\n }\n\n if (stone > secondHeaviest) {\n secondHeaviest = stone;\n continue;\n }\n }\n\n return { heaviest, secondHeaviest };\n}\n\nfunction removeStone(stones, stoneToBeRemoved) {\n for (let i = 0; i < stones.length; i++) {\n if (stones[i] === stoneToBeRemoved) {\n stones.splice(i, 1);\n return;\n }\n }\n}\n\nfunction updateStone(stones, stone, stoneWeight) {\n for (let i = 0; i < stones.length; i++) {\n if (stones[i] === stone) {\n stones[i] = stoneWeight;\n return;\n }\n }\n}\n\nexport function lastStoneWeight(stones) {\n while (stones.length > 1) {\n const { heaviest, secondHeaviest } = getTwoHaviest(stones);\n\n if (heaviest === secondHeaviest) {\n removeStone(stones, heaviest);\n removeStone(stones, secondHeaviest);\n }\n\n if (heaviest !== secondHeaviest) {\n updateStone(stones, heaviest, heaviest - secondHeaviest);\n removeStone(stones, secondHeaviest);\n }\n }\n\n return stones[0] || 0;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/last-stone-weight/tests/last-stone-weight.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport { lastStoneWeight } from '../last-stone-weight';\n\ndescribe('lastStoneWeight', () => {\n it('', () => {\n expect(lastStoneWeight([2, 7, 4, 1, 8, 1])).toEqual(1);\n });\n\n it('', () => {\n expect(lastStoneWeight([1])).toEqual(1);\n });\n\n it('', () => {\n expect(lastStoneWeight([2, 2])).toEqual(0);\n });\n\n it('', () => {\n expect(lastStoneWeight([10, 4, 2, 10])).toEqual(2);\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/easy/last-visited-integers/last-visited-integers.js",
"content": "// https://leetcode.com/problems/last-visited-integers\n\nfunction getLastInteger(words, lastNumberIndex, consecutivePrevs) {\n for (let index = lastNumberIndex; index >= 0; index--) {\n while (words[index] === 'prev') {\n index--;\n }\n\n if (index < 0) {\n return -1;\n }\n\n if (consecutivePrevs === 0) {\n return words[index];\n }\n\n if (words[index] !== 'prev') {\n consecutivePrevs--;\n }\n }\n\n return -1;\n}\n\nfunction lastVisitedIntegers(words) {\n let result = [];\n let consecutivePrevs = 0;\n let lastNumberIndex;\n\n for (let index = 0; index < words.length; index++) {\n if (words[index] === 'prev') {\n result.push(getLastInteger(words, lastNumberIndex, consecutivePrevs));\n consecutivePrevs++;\n } else {\n lastNumberIndex = index;\n consecutivePrevs = 0;\n }\n }\n\n return result;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/leaf-similar-trees/leaf-similar-trees.js",
"content": "/**\n * Definition for a binary tree node.\n * function TreeNode(val, left, right) {\n * this.val = (val===undefined ? 0 : val)\n * this.left = (left===undefined ? null : left)\n * this.right = (right===undefined ? null : right)\n * }\n */\n\nfunction getLeafValueSequence(node, leafValueSequence) {\n if (!node) return;\n if (!node.left && !node.right) {\n leafValueSequence.push(node.val);\n return;\n }\n\n getLeafValueSequence(node.left, leafValueSequence);\n getLeafValueSequence(node.right, leafValueSequence);\n}\n\nfunction hasSimilarLeafSequence(leafValueSequence1, leafValueSequence2) {\n if (leafValueSequence1.length !== leafValueSequence2.length) return false;\n\n for (let index = 0; index < leafValueSequence1.length; index++) {\n if (leafValueSequence1[index] !== leafValueSequence2[index]) return false;\n }\n\n return true;\n}\n\nfunction leafSimilar(root1, root2) {\n let leafValueSequence1 = [];\n let leafValueSequence2 = [];\n\n getLeafValueSequence(root1, leafValueSequence1);\n getLeafValueSequence(root2, leafValueSequence2);\n\n return hasSimilarLeafSequence(leafValueSequence1, leafValueSequence2);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/left-and-right-sum-differences/left-and-right-sum-differences.js",
"content": "function sum(nums) {\n let sumOfNums = 0;\n\n for (let num of nums) {\n sumOfNums += num;\n }\n\n return sumOfNums;\n}\n\nfunction leftRigthDifference(nums) {\n let rightSum = sum(nums);\n let leftSum = 0;\n let previous = 0;\n let answer = [];\n\n for (let num of nums) {\n leftSum += previous;\n rightSum -= num;\n previous = num;\n answer.push(Math.abs(leftSum - rightSum));\n }\n\n return answer;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/length-of-last-word/length-of-last-word.js",
"content": "// https://leetcode.com/problems/length-of-last-word\n\nconst lengthOfLastWord = (s) => {\n const words = s.trim().split(' ');\n return words[words.length - 1].length;\n};\n\nconst lengthOfLastWord = (s) => {\n let lastWordLength = 0;\n\n for (let i = s.length - 1; i >= 0; i--) {\n if (s[i] !== ' ') lastWordLength++;\n if (s[i] === ' ' && lastWordLength > 0) break;\n }\n\n return lastWordLength;\n};\n"
},
{
"path": "coding_interviews/leetcode/easy/lexicographically-smallest-palindrome/lexicographically-smallest-palindrome.js",
"content": "function makeSmallestPalindrome(string) {\n let start = 0;\n let end = string.length - 1;\n let palindrome = [];\n\n while (start <= end) {\n let charCode1 = string.charCodeAt(start);\n let charCode2 = string.charCodeAt(end);\n\n if (charCode1 <= charCode2) {\n palindrome[start] = string[start];\n palindrome[end] = string[start];\n }\n\n if (charCode2 < charCode1) {\n palindrome[start] = string[end];\n palindrome[end] = string[end];\n }\n\n start++;\n end--;\n }\n\n return palindrome.join('');\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/linked-list-cycle/linked-list-cycle.js",
"content": "function hasCycle(head) {\n let fast = head;\n\n while (fast && fast.next) {\n head = head.next;\n fast = fast.next.next;\n\n if (head === fast) {\n return true;\n }\n }\n\n return false;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/longer-contiguous-segments-of-ones-than-zeros/longer-contiguous-segments-of-ones-than-zeros.js",
"content": "function checkZeroOnes(s) {\n let zerosLongestContinuousSegment = 0;\n let onesLongestContinuousSegment = 0;\n let zerosContinuousSegment = 0;\n let onesContinuousSegment = 0;\n\n for (let index = 0; index < s.length; index++) {\n let char = s[index];\n\n if (char === '1') {\n zerosLongestContinuousSegment = Math.max(\n zerosLongestContinuousSegment,\n zerosContinuousSegment\n );\n zerosContinuousSegment = 0;\n onesContinuousSegment++;\n } else {\n onesLongestContinuousSegment = Math.max(\n onesLongestContinuousSegment,\n onesContinuousSegment\n );\n onesContinuousSegment = 0;\n zerosContinuousSegment++;\n }\n\n if (index === s.length - 1) {\n if (char === '1') {\n onesLongestContinuousSegment = Math.max(\n onesLongestContinuousSegment,\n onesContinuousSegment\n );\n } else {\n zerosLongestContinuousSegment = Math.max(\n zerosLongestContinuousSegment,\n zerosContinuousSegment\n );\n }\n }\n }\n\n return onesLongestContinuousSegment > zerosLongestContinuousSegment;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/longest-nice-substring/longest-nice-substring.js",
"content": "function isNice(substring, map) {\n for (let char of substring) {\n if (!map.has(char.toLowerCase()) || !map.has(char.toUpperCase())) {\n return false;\n }\n }\n\n return true;\n}\n\nfunction longestNiceSubstring(s) {\n let substring = '';\n\n for (let i = 0; i < s.length; i++) {\n let newSubstring = [s[i]];\n let map = new Map([[s[i], true]]);\n\n for (let j = i + 1; j < s.length; j++) {\n newSubstring.push(s[j]);\n map.set(s[j], true);\n\n if (isNice(newSubstring, map) && newSubstring.length > substring.length) {\n substring = newSubstring.join('');\n }\n }\n }\n\n return substring;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/longest-subsequence-with-limited-sum/longest-subsequence-with-limited-sum.js",
"content": "function immutableSort(nums) {\n return [...nums].sort((a, b) => a - b);\n}\n\nfunction buildAllSums(nums) {\n let allSums = [];\n let sum = 0;\n\n for (num of nums) {\n sum += num;\n allSums.push(sum);\n }\n\n return allSums;\n}\n\nfunction answerQueries(nums, queries) {\n let answer = [];\n let sortedNums = immutableSort(nums);\n let allSums = buildAllSums(sortedNums);\n\n for (let query of queries) {\n let num;\n\n for (let index = 0; index < allSums.length; index++) {\n let sum = allSums[index];\n\n if (sum <= query) {\n num = index + 1;\n if (index === allSums.length - 1) answer.push(num);\n } else {\n if (num) answer.push(num);\n break;\n }\n }\n\n if (!num) answer.push(0);\n }\n\n return answer;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/longest_palindrome.py",
"content": "def count_pairs(letters):\n hash = {}\n result = {\"pair\": 0, \"single\": 0}\n\n for letter in letters:\n if hash.get(letter):\n hash[letter] += 1\n else:\n hash[letter] = 1\n\n for k, v in hash.items():\n if v > 1:\n result[\"pair\"] += v - (v % 2)\n result[\"single\"] += v % 2\n else:\n result[\"single\"] += 1\n\n return result\n\n\ndef main(letters):\n counter = 0\n\n pairs = count_pairs(letters)\n counter += pairs[\"pair\"]\n\n if pairs[\"single\"] > 0:\n counter += 1\n\n return counter\n"
},
{
"path": "coding_interviews/leetcode/easy/lowest-common-ancestor-of-a-binary-search-tree/lowest-common-ancestor-of-a-binary-search-tree.js",
"content": "function lowestCommonAncestor(root, p, q) {\n if (root === p || root === q) {\n return root;\n }\n\n if (\n (p.val < root.val && q.val > root.val) ||\n (p.val > root.val && q.val < root.val)\n ) {\n return root;\n }\n\n if (p.val < root.val && q.val < root.val) {\n return lowestCommonAncestor(root.left, p, q);\n }\n\n if (p.val > root.val && q.val > root.val) {\n return lowestCommonAncestor(root.right, p, q);\n }\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/lucky_numbers_in_a_matrix/lucky_numbers_in_a_matrix.py",
"content": "# https://leetcode.com/problems/lucky-numbers-in-a-matrix\n\ndef lucky_numbers(matrix):\n all_lucky_numbers, all_mins = [], []\n \n for row in matrix:\n found_min, col_index = float('Inf'), -1\n \n for index, column in enumerate(row):\n if column < found_min:\n found_min = column\n col_index = index\n \n all_mins.append([found_min, col_index])\n \n for a_min in all_mins:\n [min_value, min_column] = a_min\n maximum = float('-Inf')\n \n for index in range(len(matrix)):\n num = matrix[index][min_column]\n maximum = max(num, maximum)\n \n if maximum == min_value:\n all_lucky_numbers.append(min_value)\n \n return all_lucky_numbers\n"
},
{
"path": "coding_interviews/leetcode/easy/majority-element/majority-element.js",
"content": "function majorityElement(nums) {\n let hashmap = {};\n let result;\n\n for (let num of nums) {\n if (hashmap[num]) {\n hashmap[num]++;\n } else {\n hashmap[num] = 1;\n }\n }\n\n Object.entries(hashmap).forEach(([num, count]) => {\n if (count > nums.length / 2) {\n result = num;\n }\n });\n\n return result;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/make-array-zero-by-subtracting-equal-amounts/make-array-zero-by-subtracting-equal-amounts.js",
"content": "function minimumOperationsAllInOne(nums) {\n let count = 0;\n let smallest = 0;\n\n for (let num of nums) {\n if (num > 0) {\n smallest = smallest ? Math.min(smallest, num) : num;\n }\n }\n\n while (smallest) {\n let smallestToSubtract = smallest;\n smallest = 0;\n\n for (let index = 0; index < nums.length; index++) {\n let subtractionResult = nums[index] - smallestToSubtract;\n nums[index] = subtractionResult > 0 ? subtractionResult : 0;\n\n if (subtractionResult > 0) {\n smallest = smallest\n ? Math.min(smallest, subtractionResult)\n : subtractionResult;\n }\n }\n\n count++;\n }\n\n return count;\n}\n\n// --------------------------------------------------\n\nfunction smallestExceptZeros(smallest, num) {\n return smallest ? Math.min(smallest, num) : num;\n}\n\nfunction getSmallest(nums) {\n let smallest = 0;\n\n for (let num of nums) {\n if (num > 0) {\n smallest = smallestExceptZeros(smallest, num);\n }\n }\n\n return smallest;\n}\n\nfunction performSubtraction(nums, smallestToSubtract, smallest) {\n for (let index = 0; index < nums.length; index++) {\n let subtractionResult = nums[index] - smallestToSubtract;\n nums[index] = subtractionResult > 0 ? subtractionResult : 0;\n\n if (subtractionResult > 0) {\n smallest = smallestExceptZeros(smallest, subtractionResult);\n }\n }\n\n return smallest;\n}\n\nfunction minimumOperations(nums) {\n let count = 0;\n let smallest = getSmallest(nums);\n\n while (smallest) {\n smallest = performSubtraction(nums, smallest, 0);\n count++;\n }\n\n return count;\n}\n\n// --------------------------------------------------\n\nfunction minimumOperationsSet(nums) {\n return new Set(nums.filter((num) => num !== 0));\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/make-the-string-great/make-the-string-great.js",
"content": "function isUpperCase(char1, char2) {\n return char1 !== char1.toUpperCase() && char1.toUpperCase() === char2;\n}\n\nfunction isLowerCase(char1, char2) {\n return char2.toLowerCase() !== char2 && char2.toLowerCase() === char1;\n}\n\nfunction isBadPair(char1, char2) {\n return (\n isUpperCase(char1, char2) ||\n isUpperCase(char2, char1) ||\n isLowerCase(char1, char2) ||\n isLowerCase(char2, char1)\n );\n}\n\nfunction makeGood(string, pointer1 = 0, pointer2 = 1) {\n if (string.length <= 1) return string;\n if (pointer2 === string.length) return string;\n console.log(\n string[pointer1],\n string[pointer2],\n isBadPair(string[pointer1], string[pointer2])\n );\n if (isBadPair(string[pointer1], string[pointer2])) {\n return makeGood(\n string.slice(0, pointer1) + string.slice(pointer2 + 1),\n 0,\n 1\n );\n }\n\n return makeGood(string, pointer1 + 1, pointer2 + 1);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/matrix-cells-in-distance-order/matrix-cells-in-distance-order.js",
"content": "function sortDistances(distances) {\n return [...distances].sort((distance1, distance2) => distance1 - distance2);\n}\n\nfunction allCellsDistOrder(rows, cols, rCenter, cCenter) {\n const distancesMap = new Map();\n const distances = [];\n\n for (let row = 0; row < rows; row++) {\n for (let col = 0; col < cols; col++) {\n const distance = Math.abs(row - rCenter) + Math.abs(col - cCenter);\n\n if (distancesMap.has(distance)) {\n distancesMap.set(distance, [...distancesMap.get(distance), [row, col]]);\n } else {\n distances.push(distance);\n distancesMap.set(distance, [[row, col]]);\n }\n }\n }\n\n return sortDistances(distances)\n .map((distance) => distancesMap.get(distance))\n .flatMap((cell) => cell);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/matrix_diagonal_sum/matrix_diagonal_sum.py",
"content": "# https://leetcode.com/problems/matrix-diagonal-sum\n\n'''\nTime Complexity: O(N)\nSpace Complexity: O(1)\n'''\n\ndef diagonal_sum(mat):\n diagonals_sum, mat_length = 0, len(mat)\n \n # left-top --> right-bottom & right-top --> left-bottom\n for index in range(mat_length):\n diagonals_sum += mat[index][index] + mat[index][mat_length-index-1]\n \n if len(mat) % 2 == 0:\n return diagonals_sum\n \n center = mat_length // 2\n return diagonals_sum - mat[center][center]]\n"
},
{
"path": "coding_interviews/leetcode/easy/matrix_negative_numbers/matrix_negative_numbers.py",
"content": "def count_negatives(grid):\n counter = 0\n\n for i in range(len(grid)):\n for j in range(len(grid[i])):\n if grid[i][j] < 0:\n counter += 1\n\n return counter\n"
},
{
"path": "coding_interviews/leetcode/easy/max-consecutive-ones/max-consecutive-ones.js",
"content": "function findMaxConsecutiveOnes(nums) {\n let max = 0;\n let consecutive = 0;\n\n for (let index = 0; index < nums.length; index++) {\n if (nums[index] === 1) consecutive++;\n if (nums[index] === 0 || index === nums.length - 1) {\n max = Math.max(max, consecutive);\n consecutive = 0;\n }\n }\n\n return max;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/maximum-69-number/maximum-69-number.js",
"content": "function maximum69Number(num) {\n let nums = String(num).split('');\n let firstSixIndex;\n\n for (let index = 0; index < nums.length; index++) {\n if (nums[index] === '6' && firstSixIndex === undefined) {\n firstSixIndex = index;\n }\n }\n\n nums[firstSixIndex] = '9';\n\n return Number(nums.join(''));\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/maximum-ascending-subarray-sum/maximum-ascending-subarray-sum.js",
"content": "function maxAscendingSum(nums) {\n let max = 0;\n let maxSubsequence = 0;\n let previous = -Infinity;\n\n for (let index = 0; index < nums.length; index++) {\n let num = nums[index];\n\n if (num > previous) {\n maxSubsequence += num;\n previous = num;\n\n if (index === nums.length - 1) max = Math.max(max, maxSubsequence);\n } else {\n max = Math.max(max, maxSubsequence);\n previous = num;\n maxSubsequence = num;\n }\n }\n\n return max;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/maximum-count-of-positive-integer-and-negative-integer/maximum-count-of-positive-integer-and-negative-integer.js",
"content": "function maximumCount(nums) {\n let pos = 0;\n let neg = 0;\n\n for (let num of nums) {\n if (num > 0) pos++;\n if (num < 0) neg++;\n }\n\n return Math.max(pos, neg);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/maximum-depth-of-binary-tree/maximum-depth-of-binary-tree-2.js",
"content": "function getMaximumDepth(node, depth) {\n if (!node) {\n return depth;\n }\n\n return Math.max(\n getMaximumDepth(node.left, depth + 1),\n getMaximumDepth(node.right, depth + 1)\n );\n}\n\nfunction maxDepth(root) {\n if (!root) {\n return 0;\n }\n\n return Math.max(\n getMaximumDepth(root.left, 1),\n getMaximumDepth(root.right, 1)\n );\n}\n\n// shorter without a helper function\nfunction maxDepth(root, depth = 0) {\n return root\n ? Math.max(maxDepth(root.left, depth + 1), maxDepth(root.right, depth + 1))\n : depth;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/maximum-depth-of-binary-tree/maximum-depth-of-binary-tree.js",
"content": "// https://leetcode.com/problems/maximum-depth-of-binary-tree\n\nconst maxDepth = (root) => maxDepthHelper(root, 0);\n\nconst maxDepthHelper = (node, depth) => {\n if (!node) return depth;\n const leftDepth = maxDepthHelper(node.left, depth + 1);\n const rightDepth = maxDepthHelper(node.right, depth + 1);\n return Math.max(leftDepth, rightDepth);\n};\n"
},
{
"path": "coding_interviews/leetcode/easy/maximum-depth-of-n-ary-tree/maximum-depth-of-n-ary-tree.js",
"content": "function maxDepth(root, depth = 1) {\n if (!root) return depth - 1;\n\n let depths = [];\n\n for (let child of root.children) {\n const childDepth = maxDepth(child, depth + 1);\n depths.push(childDepth);\n }\n\n return depths.length ? Math.max(...depths) : depth;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/maximum-number-of-balloons/maximum-number-of-balloons.js",
"content": "function buildHashmap(text) {\n const hashmap = new Map();\n\n for (let char of text) {\n if (hashmap.has(char)) hashmap.set(char, hashmap.get(char) + 1);\n else hashmap.set(char, 1);\n }\n\n return hashmap;\n}\n\nfunction maxNumberOfBalloons(text) {\n let hashmap = buildHashmap(text);\n let minCharCount = Infinity;\n let balloon = 'balon';\n\n for (let char of balloon) {\n if (!hashmap.has(char)) return 0;\n if (['l', 'o'].includes(char))\n minCharCount = Math.min(minCharCount, Math.floor(hashmap.get(char) / 2));\n else minCharCount = Math.min(minCharCount, hashmap.get(char));\n }\n\n return minCharCount;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/maximum-number-of-pairs-in-array/maximum-number-of-pairs-in-array.js",
"content": "function numberOfPairs(nums) {\n let countNums = new Map();\n\n for (let num of nums) {\n if (countNums.has(num)) {\n countNums.set(num, countNums.get(num) + 1);\n } else {\n countNums.set(num, 1);\n }\n }\n\n let pairs = 0;\n let rest = 0;\n\n countNums.forEach((num) => {\n pairs += Math.floor(num / 2);\n rest += Math.floor(num % 2);\n });\n\n return [pairs, rest];\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/maximum-odd-binary-number/maximum-odd-binary-number.js",
"content": "// https://leetcode.com/problems/maximum-odd-binary-number\n\nfunction countOnesAndZeros(s) {\n let countOnes = 0;\n let countZeros = 0;\n\n for (let char of s) {\n if (char === '1') {\n countOnes++;\n } else {\n countZeros++;\n }\n }\n\n return { countOnes, countZeros };\n}\n\nfunction maximumOddBinaryNumber(s) {\n const { countOnes, countZeros } = countOnesAndZeros(s);\n let result = '';\n\n for (let one = 1; one <= countOnes - 1; one++) {\n result += '1';\n }\n\n for (let zero = 1; zero <= countZeros; zero++) {\n result += '0';\n }\n\n return result + '1';\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/maximum-subarray/maximum-subarray.js",
"content": "function maxSubArray(nums) {\n let maxSum = nums[0];\n let localSum = nums[0];\n\n for (let index = 1; index < nums.length; index++) {\n localSum = Math.max(nums[index], localSum + nums[index]);\n maxSum = Math.max(maxSum, localSum);\n }\n\n return maxSum;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/maximum-sum-with-exactly-k-elements/maximum-sum-with-exactly-k-elements.js",
"content": "function getBiggest(nums) {\n let biggest = -Infinity;\n\n for (let num of nums) {\n biggest = Math.max(biggest, num);\n }\n\n return biggest;\n}\n\nfunction maximizeSum(nums, k) {\n let biggest = getBiggest(nums);\n let sum = 0;\n\n while (k--) {\n sum += biggest;\n biggest++;\n }\n\n return sum;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/maximum-units-on-a-truck/maximum-units-on-a-truck.py",
"content": "# https://leetcode.com/problems/maximum-units-on-a-truck\n\ndef maximum_units(box_types, truck_size):\n sorted_by_units_per_box = sorted(box_types, key=lambda box_type: box_type[1], reverse=True)\n \n units = 0\n \n for [num_of_boxes, num_of_units] in sorted_by_units_per_box:\n num_of_boxes_to_put_on_the_truck = min(truck_size, num_of_boxes)\n truck_size -= num_of_boxes_to_put_on_the_truck\n units += num_of_boxes_to_put_on_the_truck * num_of_units\n if truck_size <= 0: break\n \n return units\n"
},
{
"path": "coding_interviews/leetcode/easy/maximum-value-of-a-string-in-an-array/maximum-value-of-a-string-in-an-array.js",
"content": "function maximumValue(strs) {\n return strs.reduce(\n (max, string) =>\n Math.max(\n max,\n Number.isNaN(Number(string)) ? string.length : Number(string)\n ),\n 0\n );\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/maximum_nesting_depth_of_the_parentheses/maximum_nesting_depth_of_the_parentheses.py",
"content": "# https://leetcode.com/problems/maximum-nesting-depth-of-the-parentheses\n\ndef max_depth(s):\n depth = open_paren = 0\n \n for char in s:\n if char == '(':\n open_paren += 1\n depth = max(depth, open_paren)\n\n if char == ')':\n open_paren -= 1\n \n return depth\n"
},
{
"path": "coding_interviews/leetcode/easy/maximum_number_of_balls_in_a_box/maximum_number_of_balls_in_a_box.py",
"content": "# https://leetcode.com/problems/maximum-number-of-balls-in-a-box\n\ndef get_box(ball):\n count = 0\n \n while ball > 0:\n count += ball % 10\n ball //= 10\n \n return count\n\ndef count_balls(low_limit, high_limit):\n hash_counter = {}\n \n for ball in range(low_limit, high_limit + 1):\n box = get_box(ball)\n \n if box in hash_counter:\n hash_counter[box] += 1\n else:\n hash_counter[box] = 1\n \n max_balls = float('-Inf')\n \n for key, value in hash_counter.items():\n max_balls = max(max_balls, value)\n \n return max_balls\n"
},
{
"path": "coding_interviews/leetcode/easy/maximum_number_of_words_you_can_type/maximum_number_of_words_you_can_type.js",
"content": "// https://leetcode.com/problems/maximum-number-of-words-you-can-type\n\nconst canBeTypedWords = function (text, brokenLetters) {\n const words = text.split(' ');\n const broken = buildBrokenMapper(brokenLetters);\n const okWords = words.filter((word) => {\n let foundBroken = false;\n for (let char of word) {\n if (broken[char]) {\n foundBroken = true;\n }\n }\n\n return !foundBroken;\n });\n\n return okWords.length;\n};\n\nconst buildBrokenMapper = (brokenLetters) => {\n const mapper = {};\n\n for (let letter of brokenLetters) {\n mapper[letter] = true;\n }\n\n return mapper;\n};\n"
},
{
"path": "coding_interviews/leetcode/easy/maximum_population/maximum_population.py",
"content": "# https://leetcode.com/problems/maximum-population-year\n\ndef maximum_population(logs):\n population_by_year = {}\n \n for [birth, death] in logs:\n for year in range(birth, death):\n if year in population_by_year:\n population_by_year[year] += 1\n else:\n population_by_year[year] = 1\n \n earliest_year = 0\n max_population = 0\n \n for year, population in population_by_year.items():\n if population == max_population:\n earliest_year = min(earliest_year, year)\n \n if population > max_population:\n earliest_year = year\n max_population = population\n \n return earliest_year\n"
},
{
"path": "coding_interviews/leetcode/easy/maximum_product/maximum_product.py",
"content": "# https://leetcode.com/problems/maximum-product-of-two-elements-in-an-array\n\n\ndef max_product(nums):\n sorted_list = sorted(nums)\n return (sorted_list[-1] - 1) * (sorted_list[-2] - 1)\n\n\ndef max_product(nums):\n max, second_max = 0, 0\n\n for num in nums:\n if num >= max:\n second_max = max\n max = num\n elif num >= second_max:\n second_max = num\n\n return (max - 1) * (second_max - 1)\n"
},
{
"path": "coding_interviews/leetcode/easy/maximum_product_difference_between_two_pairs/maximum_product_difference_between_two_pairs.js",
"content": "// https://leetcode.com/problems/maximum-product-difference-between-two-pairs\n\nconst maxProductDifference = function (nums) {\n nums.sort((a, b) => a - b);\n const greatest = nums[nums.length - 1];\n const secondGreatest = nums[nums.length - 2];\n const smallest = nums[0];\n const secondSmallest = nums[1];\n\n return greatest * secondGreatest - smallest * secondSmallest;\n};\n\nconst max = maxProductDifference([1, 6, 7, 5, 2, 4, 10, 6, 4]);\nconsole.log(max);\n"
},
{
"path": "coding_interviews/leetcode/easy/mean-of-array-after-removing-some-elements/mean-of-array-after-removing-some-elements.js",
"content": "function removeFivePercent(numbers) {\n let totalNumbers = numbers.length;\n let fivePercent = numbers.length * 0.05;\n return numbers.slice(fivePercent, totalNumbers - fivePercent);\n}\n\nfunction sum(numbers) {\n return numbers.reduce((sumOfNums, num) => sumOfNums + num, 0);\n}\n\nfunction trimMean(numbers) {\n numbers.sort((a, b) => a - b);\n const withoutFivePercent = removeFivePercent(numbers);\n const sumOfNums = sum(withoutFivePercent);\n return sumOfNums / withoutFivePercent.length;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/merge-nodes-in-between-zeros/merge-nodes-in-between-zeros.js",
"content": "export class ListNode {\n constructor(val, next) {\n this.val = val === undefined ? 0 : val;\n this.next = next === undefined ? null : next;\n }\n}\n\nexport function mergeNodes(head) {\n let nonZeroHead;\n let node;\n let nextNode;\n let currentNode = head.next;\n let valueSum = 0;\n let gotFirstNode = false;\n\n while (currentNode) {\n valueSum += currentNode.val;\n\n if (currentNode.val === 0) {\n nextNode = new ListNode(valueSum);\n valueSum = 0;\n\n if (gotFirstNode) {\n node.next = nextNode;\n node = node.next;\n } else {\n node = nextNode;\n nonZeroHead = nextNode;\n gotFirstNode = true;\n }\n }\n\n currentNode = currentNode.next;\n }\n\n return nonZeroHead;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/merge-nodes-in-between-zeros/tests/merge-nodes-in-between-zeros.test.js",
"content": "import { describe, it, expect } from 'vitest';\nimport { ListNode, mergeNodes } from '../merge-nodes-in-between-zeros';\n\nfunction buildList(nums, initValue = 0) {\n let head = new ListNode(initValue);\n let node = head;\n let nextNode;\n\n for (let i = 1; i < nums.length; i++) {\n nextNode = new ListNode(nums[i]);\n node.next = nextNode;\n node = node.next;\n }\n\n return head;\n}\n\ndescribe('mergeNodes', () => {\n it('removes zeros and merges nodes', () => {\n const head = buildList([0, 3, 1, 0, 4, 5, 2, 0]);\n const result = buildList([4, 11], 4);\n expect(mergeNodes(head)).toEqual(result);\n });\n\n it('removes zeros and merges nodes', () => {\n const head = buildList([0, 1, 0, 3, 0, 2, 2, 0]);\n const result = buildList([1, 3, 4], 1);\n expect(mergeNodes(head)).toEqual(result);\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/easy/merge-similar-items/merge-similar-items.js",
"content": "function fillHashmapAndList(items, hashmap, list) {\n for (let [value, weight] of items) {\n if (hashmap.has(value)) {\n hashmap.set(value, hashmap.get(value) + weight);\n } else {\n hashmap.set(value, weight);\n list.push(value);\n }\n }\n}\n\nfunction mergeSimilarItems(items1, items2) {\n let hashmap = new Map();\n let list = [];\n\n fillHashmapAndList(items1, hashmap, list);\n fillHashmapAndList(items2, hashmap, list);\n\n return list.sort((a, b) => a - b).map((value) => [value, hashmap.get(value)]);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/merge-sorted-array/merge-sorted-array.js",
"content": "/*\nnums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3\n[1,2,2,3,5,6]\n\nnums1 = [0,0,0], m = 0, nums2 = [1,2,3], n = 3\n[1,2,3]\n\ntime: O(n + m)\nspace: O(n + m)\n*/\n\nfunction merge(nums1, m, nums2, n) {\n let pointer1 = 0;\n let pointer2 = 0;\n let numbers = [];\n let mIndex = m - 1;\n let nIndex = n - 1;\n\n while (pointer1 <= mIndex || pointer2 <= nIndex) {\n if (pointer1 <= mIndex && pointer2 <= nIndex) {\n let num1 = nums1[pointer1];\n let num2 = nums2[pointer2];\n\n if (num1 <= num2) {\n numbers.push(num1);\n pointer1++;\n } else {\n numbers.push(num2);\n pointer2++;\n }\n }\n\n if (pointer1 <= mIndex && pointer2 > nIndex) {\n numbers.push(nums1[pointer1]);\n pointer1++;\n }\n\n if (pointer2 <= nIndex && pointer1 > mIndex) {\n numbers.push(nums2[pointer2]);\n pointer2++;\n }\n }\n\n for (let [index, num] of numbers.entries()) {\n nums1[index] = num;\n }\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/merge-two-2d-arrays-by-summing-values/merge-two-2d-arrays-by-summing-values.js",
"content": "function mergeArrays(nums1, nums2) {\n let nums = [];\n let index1 = 0;\n let index2 = 0;\n\n while (index1 < nums1.length && index2 < nums2.length) {\n let [id1, val1] = nums1[index1];\n let [id2, val2] = nums2[index2];\n\n if (id1 < id2) {\n nums.push([id1, val1]);\n index1++;\n } else if (id2 < id1) {\n nums.push([id2, val2]);\n index2++;\n } else {\n nums.push([id1, val1 + val2]);\n index1++;\n index2++;\n }\n }\n\n while (index1 < nums1.length) {\n nums.push(nums1[index1]);\n index1++;\n }\n\n while (index2 < nums2.length) {\n nums.push(nums2[index2]);\n index2++;\n }\n\n return nums;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/merge-two-binary-trees/merge-two-binary-trees.js",
"content": "function mergeTrees(root1, root2) {\n let root = new TreeNode();\n\n if (root1 && root2) {\n root.val = root1.val + root2.val;\n root.left = mergeTrees(root1.left, root2.left);\n root.right = mergeTrees(root1.right, root2.right);\n } else if (root1) {\n root = root1;\n } else if (root2) {\n root = root2;\n } else {\n return null;\n }\n\n return root;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/merge-two-sorted-lists/merge-two-sorted-lists.js",
"content": "export class ListNode {\n constructor(val, next) {\n this.val = val === undefined ? 0 : val;\n this.next = next === undefined ? null : next;\n }\n}\n\nexport function mergeTwoLists(list1, list2) {\n if (!list1 && !list2) {\n return null;\n }\n\n if (!list1) {\n return list2;\n }\n\n if (!list2) {\n return list1;\n }\n\n let newList;\n\n if (list1.val <= list2.val) {\n newList = new ListNode(list1.val);\n list1 = list1.next;\n } else {\n newList = new ListNode(list2.val);\n list2 = list2.next;\n }\n\n let node = newList;\n\n while (list1 && list2) {\n if (list1.val <= list2.val) {\n node.next = new ListNode(list1.val);\n list1 = list1.next;\n } else {\n node.next = new ListNode(list2.val);\n list2 = list2.next;\n }\n\n node = node.next;\n }\n\n while (list1) {\n node.next = new ListNode(list1.val);\n node = node.next;\n list1 = list1.next;\n }\n\n while (list2) {\n node.next = new ListNode(list2.val);\n node = node.next;\n list2 = list2.next;\n }\n\n return newList;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/merge-two-sorted-lists/tests/merge-two-sorted-lists.test.js",
"content": "import { describe, it, expect } from 'vitest';\nimport { mergeTwoLists, ListNode } from '../merge-two-sorted-lists';\n\nfunction buildList(nums) {\n if (nums.length === 0) {\n return null;\n }\n\n let head = new ListNode(nums[0]);\n let node = head;\n let nextNode;\n\n for (let i = 1; i < nums.length; i++) {\n nextNode = new ListNode(nums[i]);\n node.next = nextNode;\n node = node.next;\n }\n\n return head;\n}\n\ndescribe('mergeTwoLists', () => {\n it('', () => {\n const list1 = buildList([1, 2, 4]);\n const list2 = buildList([1, 3, 4]);\n const result = buildList([1, 1, 2, 3, 4, 4]);\n\n expect(mergeTwoLists(list1, list2)).toEqual(result);\n });\n\n it('', () => {\n const list1 = buildList([]);\n const list2 = buildList([]);\n const result = buildList([]);\n\n expect(mergeTwoLists(list1, list2)).toEqual(result);\n });\n\n it('', () => {\n const list1 = buildList([]);\n const list2 = buildList([0]);\n const result = buildList([0]);\n\n expect(mergeTwoLists(list1, list2)).toEqual(result);\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/easy/merge_strings_alternately/merge_strings_alternately.py",
"content": "# https://leetcode.com/problems/merge-strings-alternately/\n\ndef mergeAlternately(word1, word2):\n smallest_length = min(len(word1), len(word2))\n letters = []\n\n for index in range(smallest_length):\n letters.append(word1[index])\n letters.append(word2[index])\n\n if len(word1) > len(word2):\n biggest_word = word1\n else:\n biggest_word = word2\n \n return ''.join(letters) + biggest_word[smallest_length:]\n"
},
{
"path": "coding_interviews/leetcode/easy/merge_trees.py",
"content": "'''\nhttps://leetcode.com/problems/merge-two-binary-trees/description/\n\nInput:\n\tTree 1 Tree 2\n 1 2\n / \\ / \\\n 3 2 1 3\n / \\ \\\n 5 4 7\n\nOutput:\nMerged tree\n\t 3\n\t / \\\n\t 4 5\n\t / \\ \\\n\t 5 4 7\n'''\n\nclass TreeNode(object):\n def __init__(self, val):\n self.val = val\n self.left = None\n self.right = None\n\ndef merge_trees(t1, t2):\n if not t1 and not t2: return None\n\n new_node = TreeNode((t1.val if t1 else 0) + (t2.val if t2 else 0))\n new_node.left = merge_trees(t1 and t1.left, t2 and t2.left)\n new_node.right = merge_trees(t1 and t1.right, t2 and t2.right)\n\n return new_node\n"
},
{
"path": "coding_interviews/leetcode/easy/merge_two_lists.py",
"content": "# https://leetcode.com/problems/merge-two-sorted-lists/description/\n\nclass ListNode(object):\n def __init__(self, x):\n self.val = x\n self.next = None\n\ndef merge_two_lists(l1, l2):\n if l1 == None and l2 == None:\n return l1\n elif l1 == None:\n return l2\n elif l2 == None:\n return l1\n else:\n n = root = ListNode(0)\n\n while l1 and l2:\n if l1.val <= l2.val:\n n.next = l1\n l1 = l1.next\n else:\n n.next = l2\n l2 = l2.next\n\n n = n.next\n\n if l1:\n n.next = l1\n\n if l2:\n n.next = l2\n\n return root.next\n"
},
{
"path": "coding_interviews/leetcode/easy/middle-of-the-linked-list/middle-of-the-linked-list-fast-slow.js",
"content": "function middleNode(head) {\n let slow = head;\n let fast = head;\n\n while (fast && fast.next) {\n slow = slow.next;\n fast = fast.next.next;\n }\n\n return slow;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/middle-of-the-linked-list/middle-of-the-linked-list.js",
"content": "/**\n * Definition for singly-linked list.\n * function ListNode(val, next) {\n * this.val = (val===undefined ? 0 : val)\n * this.next = (next===undefined ? null : next)\n * }\n */\n/**\nhead = [1,2,3,4,5] => n = 5 => 5 / 2 => 2.5 => 2\n[3,4,5]\n\nhead = [1] => n = 1 => 1 / 2 => 0.5 => 0\n[1]\n\nhead = [1,2,3,4,5,6] => n = 6 => 6 / 2 => 3\n[4,5,6]\n*/\n\nfunction getNodeCount(node, count) {\n return node ? getNodeCount(node.next, count + 1) : count;\n}\n\nfunction getNode(node, index) {\n return index ? getNode(node.next, index - 1) : node;\n}\n\nfunction middleNode(head) {\n let count = getNodeCount(head, 0);\n let middleIndex = Math.floor(count / 2);\n return getNode(head, middleIndex);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/min-max-game/min-max-game.js",
"content": "function minMaxGame(nums) {\n while (nums.length > 1) {\n let newNums = [];\n let middleIndex = nums.length / 2;\n\n for (let i = 0; i < middleIndex; i++) {\n if (i % 2 === 0) newNums.push(Math.min(nums[2 * i], nums[2 * i + 1]));\n else newNums.push(Math.max(nums[2 * i], nums[2 * i + 1]));\n }\n\n nums = newNums;\n }\n\n return nums;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/minimize-string-length/minimize-string-length.js",
"content": "// https://leetcode.com/problems/minimize-string-length\n\nfunction minimizedStringLength(s) {\n let set = new Set();\n\n for (let char of s) {\n set.add(char);\n }\n\n return set.size;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/minimum-absolute-difference/minimum-absolute-difference.js",
"content": "// https://leetcode.com/problems/minimum-absolute-difference\n\nconst minimumAbsDifference = (arr) => {\n // runtime: O(NlogN)\n // space: O(N)\n\n let minDifference = Infinity;\n const differenceToPairs = {};\n\n arr.sort((a, b) => a - b);\n\n for (let i = 0; i < arr.length - 1; i++) {\n const num1 = arr[i];\n const num2 = arr[i + 1];\n const currentDifference = num2 - num1;\n\n if (differenceToPairs[currentDifference]) {\n differenceToPairs[currentDifference].push([num1, num2]);\n } else {\n differenceToPairs[currentDifference] = [[num1, num2]];\n }\n\n minDifference = Math.min(minDifference, currentDifference);\n }\n\n return differenceToPairs[minDifference];\n};\n"
},
{
"path": "coding_interviews/leetcode/easy/minimum-absolute-difference-in-bst/minimum-absolute-difference-in-bst.js",
"content": "function getMinimumDifference(root, rootVal = Infinity) {\n if (!root) return Infinity;\n return Math.min(\n Math.abs(root.val - rootVal),\n getMinimumDifference(root.left, root.val),\n getMinimumDifference(root.right, root.val)\n );\n}\n\n// ===============================================================\n\nfunction traverse(node, list) {\n if (!node) return null;\n traverse(node.left, list);\n list.push(node.val);\n traverse(node.right, list);\n}\n\nfunction diff(list) {\n let minDiff = Infinity;\n let previous = list[0];\n\n for (let index = 1; index < list.length; index++) {\n minDiff = Math.min(list[index] - previous, minDiff);\n previous = list[index];\n }\n\n return minDiff;\n}\n\nfunction getMinimumDifference(root) {\n let list = [];\n traverse(root, list);\n return diff(list);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/minimum-bit-flips-to-convert-number/minimum-bit-flips-to-convert-number.js",
"content": "function toBinary(number) {\n const binary = [];\n\n while (number) {\n binary.push((number % 2).toString());\n number = Math.floor(number / 2);\n }\n\n return binary;\n}\n\nexport function minBitFlips(start, goal) {\n const startBinary = toBinary(start);\n const goalBinary = toBinary(goal);\n const greatestLength =\n startBinary.length > goalBinary.length\n ? startBinary.length\n : goalBinary.length;\n\n let flips = 0;\n\n for (let i = 0; i < greatestLength; i++) {\n const startBit = startBinary[i] || '0';\n const goalBit = goalBinary[i] || '0';\n\n if (startBit !== goalBit) {\n flips++;\n }\n }\n\n return flips;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/minimum-bit-flips-to-convert-number/tests/minimum-bit-flips-to-convert-number.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport { minBitFlips } from '../minimum-bit-flips-to-convert-number';\n\ndescribe('minBitFlips', () => {\n it('', () => {\n expect(minBitFlips(10, 7)).toEqual(3);\n });\n\n it('', () => {\n expect(minBitFlips(1, 16)).toEqual(2);\n });\n\n it('', () => {\n expect(minBitFlips(3, 4)).toEqual(3);\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/easy/minimum-cost-to-move-chips-to-the-same-position/minimum-cost-to-move-chips-to-the-same-position.js",
"content": "function minCostToMoveChips(positions) {\n let evenCount = 0;\n let oddCount = 0;\n\n for (let position of positions) {\n if (position % 2 === 0) evenCount++;\n else oddCount++;\n }\n\n return Math.min(evenCount, oddCount);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/minimum-depth-of-binary-tree/minimum-depth-of-binary-tree.js",
"content": "// https://leetcode.com/problems/minimum-depth-of-binary-tree\n\n/**\n * Definition for a binary tree node.\n * function TreeNode(val, left, right) {\n * this.val = (val===undefined ? 0 : val)\n * this.left = (left===undefined ? null : left)\n * this.right = (right===undefined ? null : right)\n * }\n */\nfunction minDepth(node, depth = 1) {\n if (!node) return 0;\n if (!node.left && !node.right) return depth;\n if (!node.left) return minDepth(node.right, depth + 1);\n if (!node.right) return minDepth(node.left, depth + 1);\n return Math.min(\n minDepth(node.left, depth + 1),\n minDepth(node.right, depth + 1)\n );\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/minimum-distance-between-bst-nodes/minimum-distance-between-bst-nodes.js",
"content": "function traverse(node, list) {\n if (!node) return;\n traverse(node.left, list);\n list.push(node.val);\n traverse(node.right, list);\n}\n\nfunction getMinDiff(list) {\n let minDiff = Infinity;\n let previous = list[0];\n\n for (let index = 1; index < list.length; index++) {\n if (list[index] - previous < minDiff) minDiff = list[index] - previous;\n previous = list[index];\n }\n\n return minDiff;\n}\n\nfunction minDiffInBST(root) {\n let list = [];\n traverse(root, list);\n return getMinDiff(list);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/minimum-number-game/minimum-number-game.js",
"content": "// https://leetcode.com/problems/minimum-number-game\n\nfunction numberGame(nums) {\n let arr = [];\n\n nums.sort((a, b) => a - b);\n\n for (let index = 0; index < nums.length; index += 2) {\n let alice = nums[index];\n let bob = nums[index + 1];\n arr.push(bob);\n arr.push(alice);\n }\n\n return arr;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/minimum-number-of-moves-to-seat-everyone/minimum-number-of-moves-to-seat-everyone.js",
"content": "function sort(nums) {\n return [...nums].sort((a, b) => a - b);\n}\n\nexport function minMovesToSeat(seats, students) {\n const sortedSeats = sort(seats);\n const sortedStudents = sort(students);\n const N = seats.length;\n\n let moves = 0;\n\n for (let i = 0; i < N; i++) {\n moves += Math.abs(sortedSeats[i] - sortedStudents[i]);\n }\n\n return moves;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/minimum-number-of-moves-to-seat-everyone/tests/minimum-number-of-moves-to-seat-everyone.test.js",
"content": "import { describe, it, expect } from 'vitest';\nimport { minMovesToSeat } from '../minimum-number-of-moves-to-seat-everyone';\n\ndescribe('minMovesToSeat', () => {\n it('', () => {\n expect(minMovesToSeat([3, 1, 5], [2, 7, 4])).toEqual(4);\n });\n\n it('', () => {\n expect(minMovesToSeat([4, 1, 5, 9], [1, 3, 2, 6])).toEqual(7);\n });\n\n it('', () => {\n expect(minMovesToSeat([2, 2, 6, 6], [1, 3, 2, 6])).toEqual(4);\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/easy/minimum-number-of-operations-to-convert-time/minimum-number-of-operations-to-convert-time.js",
"content": "function toMinutes(stringTime) {\n const [hour, minutes] = stringTime.split(':');\n return Number(hour) * 60 + Number(minutes);\n}\n\nfunction convertTime(current, correct) {\n let count = 0;\n let minutes = toMinutes(correct) - toMinutes(current);\n\n while (minutes) {\n if (minutes >= 60) minutes -= 60;\n else if (minutes >= 15) minutes -= 15;\n else if (minutes >= 5) minutes -= 5;\n else minutes -= 1;\n count++;\n }\n\n return count;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/minimum-string-length-after-removing-substrings/minimum-string-length-after-removing-substrings.js",
"content": "// https://leetcode.com/problems/minimum-string-length-after-removing-substrings\n\nfunction minLength(s) {\n while (true) {\n let found = false;\n for (let index = 0; index < s.length - 1; index++) {\n let slice = s.slice(index, index + 2);\n if (['AB', 'CD'].includes(slice)) {\n s = s.slice(0, index) + s.slice(index + 2);\n found = true;\n break;\n }\n }\n\n if (!found) break;\n }\n\n return s.length;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/minimum-subsequence-in-non-increasing-order/minimum-subsequence-in-non-increasing-order.js",
"content": "function sum(nums) {\n return nums.reduce((sumOfNums, num) => sumOfNums + num, 0);\n}\n\nfunction minSubsequence(nums) {\n const result = [];\n const sortedNums = [...nums].sort((a, b) => a - b);\n let index = nums.length - 1;\n let sumOfNums = sum(sortedNums);\n let otherHalfSum = 0;\n\n while (index >= 0 && otherHalfSum <= sumOfNums) {\n const num = sortedNums[index];\n result.push(num);\n sumOfNums -= num;\n otherHalfSum += num;\n index--;\n }\n\n return result;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/minimum-sum/minimum-sum.js",
"content": "/*\nYou are given a positive integer num consisting of exactly four digits.\nSplit num into two new integers new1 and new2 by using the digits found in num. Leading zeros are allowed in new1 and new2,\nand all the digits found in num must be used.\n\nFor example, given num = 2932, you have the following digits:\ntwo 2's, one 9 and one 3. Some of the possible pairs [new1, new2] are [22, 93], [23, 92], [223, 9] and [2, 329].\nReturn the minimum possible sum of new1 and new2.\n\n# Example 1:\nInput: num = 2932\nOutput: 52\nExplanation: Some possible pairs [new1, new2] are [29, 23], [223, 9], etc.\nThe minimum sum can be obtained by the pair [29, 23]: 29 + 23 = 52.\n\n# Example 2:\nInput: num = 4009\nOutput: 13\nExplanation: Some possible pairs [new1, new2] are [0, 49], [490, 0], etc. \nThe minimum sum can be obtained by the pair [4, 9]: 4 + 9 = 13.\n*/\n\n// 2932 => 2, 9, 3, 2 => 2, 2 => 29, 23\n\nfunction getAllDigits(number) {\n const stringNumber = number.toString();\n const digits = [];\n\n for (let i = 0; i < stringNumber.length; i++) {\n digits.push(Number(stringNumber[i]));\n }\n\n return digits;\n}\n\nfunction sort(digits) {\n return digits.sort((digit1, digit2) => digit1 - digit2);\n}\n\nfunction minimumSum(number) {\n const digits = getAllDigits(number);\n const sortedDigits = sort(digits);\n const [digit1, digit2, digit3, digit4] = sortedDigits;\n\n return digit1 * 10 + digit3 + (digit2 * 10 + digit4);\n}\n\nconsole.log(minimumSum(2932), 52);\nconsole.log(minimumSum(4009), 13);\n\nfunction altMinimunSum(number) {\n const digits = number.toString().split('').sort();\n return Number(digits[0] + digits[2]) + Number(digits[1] + digits[3]);\n}\n\nconsole.log(altMinimunSum(2932), 52);\nconsole.log(altMinimunSum(4009), 13);\n"
},
{
"path": "coding_interviews/leetcode/easy/minimum-sum-of-mountain-triplets-i/minimum-sum-of-mountain-triplets-i.js",
"content": "// https://leetcode.com/problems/minimum-sum-of-mountain-triplets-i\n\nfunction minimumSum(nums) {\n let min = Infinity;\n\n for (let i = 0; i < nums.length - 2; i++) {\n for (let j = i + 1; j < nums.length - 1; j++) {\n for (let k = j + 1; k < nums.length; k++) {\n if (nums[i] < nums[j] && nums[k] < nums[j]) {\n min = Math.min(min, nums[i] + nums[j] + nums[k]);\n }\n }\n }\n }\n\n return min == Infinity ? -1 : min;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/minimum-time-to-type-word-using-special-typewriter/minimum-time-to-type-word-using-special-typewriter.js",
"content": "// https://leetcode.com/problems/minimum-time-to-type-word-using-special-typewriter\n\nconst minTimeToType = (word) => {\n const wordLength = word.length;\n\n let currentIndex = 0;\n let moves = wordLength;\n\n for (let i = 0; i < wordLength; i++) {\n const letter = word[i];\n const charCode = letter.charCodeAt() - 97;\n const firstDistance = Math.abs(charCode - currentIndex);\n const secondDistance =\n charCode > currentIndex\n ? currentIndex + 26 - charCode\n : charCode + 26 - currentIndex;\n\n const minimumDistance = Math.min(firstDistance, secondDistance);\n\n moves += minimumDistance;\n currentIndex = charCode;\n }\n\n return moves;\n};\n"
},
{
"path": "coding_interviews/leetcode/easy/minimum-value-to-get-positive-step-by-step-sum/minimum-value-to-get-positive-step-by-step-sum.js",
"content": "function getMinValue(nums) {\n let min = Infinity;\n let sum = 0;\n\n for (let num of nums) {\n sum += num;\n min = Math.min(min, sum);\n }\n\n return min;\n}\n\nfunction minStartValue(nums) {\n const minValue = getMinValue(nums);\n const result = 1 - minValue;\n return result >= 1 ? result : 1;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/minimum_operations_to_make_the_array_increasing/minimum_operations_to_make_the_array_increasing.py",
"content": "# https://leetcode.com/problems/minimum-operations-to-make-the-array-increasing\n\ndef min_operations(nums):\n previous_num = nums[0]\n operations = 0\n\n for index, num in enumerate(nums[1:]):\n if num <= previous_num:\n new_num = previous_num - num + 1\n operations += new_num\n nums[index + 1] += new_num\n\n previous_num = nums[index + 1]\n \n return operations\n\ndef min_operations(nums):\n prev, ops = 0, 0\n\n for num in nums:\n if num <= prev:\n prev += 1\n ops += prev - num\n else:\n prev = num\n \n return ops\n"
},
{
"path": "coding_interviews/leetcode/easy/missing-number/missing-number.js",
"content": "function buildHashmap(nums) {\n const hashmap = new Map();\n\n for (let num of nums) {\n hashmap.set(num, true);\n }\n\n return hashmap;\n}\n\nfunction getMissingNumber(numsLength, hashmap) {\n for (let i = 0; i <= numsLength; i++) {\n if (!hashmap.has(i)) return i;\n }\n}\n\nfunction missingNumber(nums) {\n const hashmap = buildHashmap(nums);\n return getMissingNumber(nums.length, hashmap);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/monotonic-array/monotonic-array.js",
"content": "function isMonotonic(nums) {\n if (nums.length === 1) return true;\n let isIncreasing;\n let previous = nums[0];\n\n for (let index = 1; index < nums.length; index++) {\n if (nums[index] === previous) {\n previous = nums[index];\n continue;\n }\n\n if (isIncreasing === undefined) {\n isIncreasing = previous <= nums[index];\n }\n\n if (isIncreasing && nums[index] < previous) return false;\n if (!isIncreasing && nums[index] > previous) return false;\n previous = nums[index];\n }\n\n return true;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/most-words-found/most-words-found.js",
"content": "/*\nA sentence is a list of words that are separated by a single space with no leading or trailing spaces.\nYou are given an array of strings sentences, where each sentences[i] represents a single sentence.\nReturn the maximum number of words that appear in a single sentence.\n\n# Example 1:\nInput: sentences = [\"alice and bob love leetcode\", \"i think so too\", \"this is great thanks very much\"]\nOutput: 6\nExplanation: \n- The first sentence, \"alice and bob love leetcode\", has 5 words in total.\n- The second sentence, \"i think so too\", has 4 words in total.\n- The third sentence, \"this is great thanks very much\", has 6 words in total.\nThus, the maximum number of words in a single sentence comes from the third sentence, which has 6 words.\n\n# Example 2:\nInput: sentences = [\"please wait\", \"continue to fight\", \"continue to win\"]\nOutput: 3\nExplanation: It is possible that multiple sentences contain the same number of words. \nIn this example, the second and third sentences (underlined) have the same number of words.\n*/\n\nfunction mostWordsFound(sentences = []) {\n return Math.max(...sentences.map((sentence) => sentence.split(' ').length));\n}\n\nconsole.log(\n mostWordsFound([\n 'alice and bob love leetcode',\n 'i think so too',\n 'this is great thanks very much',\n ]),\n 6\n);\n\nconsole.log(\n mostWordsFound(['please wait', 'continue to fight', 'continue to win']),\n 3\n);\n"
},
{
"path": "coding_interviews/leetcode/easy/move-zeroes/move-zeroes-in-place.js",
"content": "function moveZeroes(nums) {\n let zeroesCount = 0;\n let inPlaceIndex = 0;\n\n for (let num of nums) {\n if (num) {\n nums[inPlaceIndex] = num;\n inPlaceIndex++;\n } else {\n zeroesCount++;\n }\n }\n\n while (zeroesCount) {\n nums[nums.length - zeroesCount] = 0;\n zeroesCount--;\n }\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/move-zeroes/move-zeroes.js",
"content": "function moveZeroes(nums) {\n let numsWithZerosAtTheEnd = [];\n let zeroCount = 0;\n\n for (let num of nums) {\n if (num) {\n numsWithZerosAtTheEnd.push(num);\n } else {\n zeroCount++;\n }\n }\n\n while (zeroCount) {\n numsWithZerosAtTheEnd.push(0);\n zeroCount--;\n }\n\n return numsWithZerosAtTheEnd;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/n_ary_tree_postorder_traversal/n_ary_tree_postorder_traversal.py",
"content": "# https://leetcode.com/problems/n-ary-tree-postorder-traversal\n\nresult = []\n\ndef postorder(root):\n if root is None: return []\n \n for node in root.children:\n postorder(node)\n \n result.append(root.val)\n return result\n"
},
{
"path": "coding_interviews/leetcode/easy/n_ary_tree_preorder_traversal/n_ary_tree_preorder_traversal.py",
"content": "# https://leetcode.com/problems/n-ary-tree-postorder-traversal\n\nresult = []\n\ndef preorder(root):\n if root is None: return []\n \n result.append(root.val)\n\n for node in root.children:\n preorder(node)\n \n return result\n"
},
{
"path": "coding_interviews/leetcode/easy/n_repeated_element_in_size_2n_array/n_repeated_element_in_size_2n_array.py",
"content": "# https://leetcode.com/problems/n-repeated-element-in-size-2n-array/\n\n'''\nIn a array A of size 2N, there are N+1 unique elements,\nand exactly one of these elements is repeated N times.\n\nReturn the element repeated N times.\n\nExample 1:\nInput: [1,2,3,3]\nOutput: 3\n\nExample 2:\nInput: [2,1,2,5,3,2]\nOutput: 2\n\nExample 3:\nInput: [5,1,5,2,5,3,5,4]\nOutput: 5\n'''\n\n\ndef n_repeated_element_in_size_2n_array(A):\n map_counter = {}\n\n for number in A:\n if number in map_counter:\n map_counter[number] += 1\n return number\n else:\n map_counter[number] = 1\n\n\ndata_tests = [\n ([1, 2, 3, 3], 3),\n ([2, 1, 2, 5, 3, 2], 2),\n ([5, 1, 5, 2, 5, 3, 5, 4], 5)\n]\n\nfor numbers, expected in data_tests:\n result = n_repeated_element_in_size_2n_array(numbers)\n print(result, expected == result)\n"
},
{
"path": "coding_interviews/leetcode/easy/neither-minimum-nor-maximum/neither-minimum-nor-maximum-on.js",
"content": "// https://leetcode.com/problems/neither-minimum-nor-maximum\n\nfunction findNonMinOrMax(nums) {\n let min = Infinity,\n max = -Infinity;\n\n for (num of nums) {\n min = Math.min(min, num);\n max = Math.max(max, num);\n }\n\n for (let num of nums) {\n if (num !== min && num !== max) {\n return num;\n }\n }\n\n return -1;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/neither-minimum-nor-maximum/neither-minimum-nor-maximum.js",
"content": "// https://leetcode.com/problems/neither-minimum-nor-maximum\n\nfunction findNonMinOrMax(nums) {\n return nums.length > 2 ? nums.sort((a, b) => a - b)[1] : -1;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/next-greater-element-i/next-greater-element-i-optimized.js",
"content": "function peek(stack) {\n return stack[stack.length - 1];\n}\n\nfunction isEmpty(stack) {\n return stack.length === 0;\n}\n\nexport function nextGreaterElement(nums1, nums2) {\n const stack = [];\n const hashmap = new Map();\n\n for (let num of nums2) {\n while (!isEmpty(stack) && num > peek(stack)) {\n hashmap.set(stack.pop(), num);\n }\n\n stack.push(num);\n }\n\n while (!isEmpty(stack)) {\n hashmap.set(stack.pop(), -1);\n }\n\n const result = [];\n\n for (let num of nums1) {\n if (hashmap.has(num)) {\n result.push(hashmap.get(num));\n } else {\n result.push(-1);\n }\n }\n\n return result;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/next-greater-element-i/next-greater-element-i.js",
"content": "export function nextGreaterElement(nums1, nums2) {\n const result = [];\n\n for (let num1 of nums1) {\n let foundNumber = false;\n let foundNextGreaterElement = false;\n\n for (let num2 of nums2) {\n if (num1 === num2) {\n foundNumber = true;\n }\n\n if (foundNumber && num2 > num1) {\n result.push(num2);\n foundNextGreaterElement = true;\n break;\n }\n }\n\n if (!foundNextGreaterElement) {\n result.push(-1);\n }\n }\n\n return result;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/next-greater-element-i/tests/next-greater-element-i-optimized.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport { nextGreaterElement } from '../next-greater-element-i-optimized';\n\ndescribe('nextGreaterElement', () => {\n it('', () => {\n expect(nextGreaterElement([4, 1, 2], [1, 3, 4, 2])).toEqual([-1, 3, -1]);\n });\n\n it('', () => {\n expect(nextGreaterElement([2, 4], [1, 2, 3, 4])).toEqual([3, -1]);\n });\n\n it('', () => {\n expect(nextGreaterElement([4, 1, 2], [1, 3, 4, 2, 5])).toEqual([5, 3, 5]);\n });\n\n it('', () => {\n expect(nextGreaterElement([4, 1, 2], [3, 4, 5, 2, 1])).toEqual([5, -1, -1]);\n });\n\n it('', () => {\n expect(nextGreaterElement([4, 1, 2], [3, 4, 5, 2, 1, 6])).toEqual([\n 5, 6, 6,\n ]);\n });\n\n it('', () => {\n expect(\n nextGreaterElement([9, 8, 7, 3, 2, 1, 6], [9, 8, 7, 3, 2, 1, 6])\n ).toEqual([-1, -1, -1, 6, 6, 6, -1]);\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/easy/next-greater-element-i/tests/next-greater-element-i.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport { nextGreaterElement } from '../next-greater-element-i';\n\ndescribe('nextGreaterElement', () => {\n it('', () => {\n expect(nextGreaterElement([4, 1, 2], [1, 3, 4, 2])).toEqual([-1, 3, -1]);\n });\n\n it('', () => {\n expect(nextGreaterElement([2, 4], [1, 2, 3, 4])).toEqual([3, -1]);\n });\n\n it('', () => {\n expect(nextGreaterElement([4, 1, 2], [1, 3, 4, 2, 5])).toEqual([5, 3, 5]);\n });\n\n it('', () => {\n expect(nextGreaterElement([4, 1, 2], [3, 4, 5, 2, 1])).toEqual([5, -1, -1]);\n });\n\n it('', () => {\n expect(nextGreaterElement([4, 1, 2], [3, 4, 5, 2, 1, 6])).toEqual([\n 5, 6, 6,\n ]);\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/easy/num_unique_emails/num_unique_emails.py",
"content": "def num_unique_emails(emails):\n unique_emails = set()\n \n for email in emails:\n [local, domain] = email.split('@')\n splitted_local = local.split('+')\n new_local = ''.join(splitted_local[0].split('.'))\n unique_emails.add(new_local + '@' + domain)\n \n return len(unique_emails)"
},
{
"path": "coding_interviews/leetcode/easy/number-of-1-bits/number-of-1-bits.js",
"content": "function hammingWeight(n) {\n let sum = 0;\n\n while (n != 0) {\n sum += n & 1;\n n = n >>> 1;\n }\n\n return sum;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/number-of-arithmetic-triplets/number-of-arithmetic-triplets.js",
"content": "function buildMap(nums) {\n const hashmap = new Map();\n\n for (let num of nums) {\n hashmap.set(num, num);\n }\n\n return hashmap;\n}\n\nfunction arithmeticTriplets(nums, diff) {\n let hashmap = buildMap(nums);\n let counter = 0;\n\n for (let index = 0; index < nums.length - 2; index++) {\n const number = nums[index] + diff;\n const anotherNumber = number + diff;\n\n if (hashmap.has(number) && hashmap.has(anotherNumber)) {\n counter++;\n }\n }\n\n return counter;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/number-of-common-factors/number-of-common-factors.js",
"content": "function commonFactors(a, b) {\n let minValue = Math.min(a, b);\n let counter = 0;\n\n for (let num = 1; num <= minValue; num++) {\n if (a % num === 0 && b % num === 0) counter++;\n }\n\n return counter;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/number-of-employees-who-met-the-target/number-of-employees-who-met-the-target.js",
"content": "function numberOfEmployeesWhoMetTarget(hours, target) {\n let count = 0;\n\n for (let hour of hours) {\n if (hour >= target) count++;\n }\n\n return count;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/number-of-even-and-odd-bits/number-of-even-and-odd-bits.js",
"content": "function toBinary(n) {\n const binary = [];\n\n while (n > 0) {\n binary.push(n % 2);\n n = Math.floor(n / 2);\n }\n\n return binary;\n}\n\nfunction isEven(n) {\n return n % 2 === 0;\n}\n\nfunction isOdd(n) {\n return n % 2 !== 0;\n}\n\nfunction evenOddBit(n) {\n let binary = toBinary(n);\n let even = 0;\n let odd = 0;\n\n for (let index = 0; index < binary.length; index++) {\n if (isEven(index) && binary[index]) even++;\n if (isOdd(index) && binary[index]) odd++;\n }\n\n return [even, odd];\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/number-of-lines-to-write-string/number-of-lines-to-write-string.js",
"content": "// https://leetcode.com/problems/number-of-lines-to-write-string\n\nfunction toWidthsIndex(char) {\n return char.charCodeAt() - 97;\n}\n\nfunction numberOfLines(widths, s) {\n let output = [1, 0];\n\n for (let char of s) {\n let width = widths[toWidthsIndex(char)];\n\n if (output[1] + width <= 100) {\n output[1] = output[1] + width;\n } else {\n output[0]++;\n output[1] = width;\n }\n }\n\n return output;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/number-of-senior-citizens/number-of-senior-citizens.js",
"content": "function countSeniors(details) {\n let count = 0;\n\n for (let detail of details) {\n if (Number(detail.slice(11, 13)) > 60) {\n count++;\n }\n }\n\n return count;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/number-of-senior-citizens/one-liner-number-of-senior-citizens.js",
"content": "function countSeniors(details) {\n return details\n .filter((detail) => Number(detail.slice(11, 13)) > 60)\n .length;\n};"
},
{
"path": "coding_interviews/leetcode/easy/number-of-strings-that-appear-as-substrings-in-word/number-of-strings-that-appear-as-substrings-in-word.js",
"content": "const isPatternInWord = (pattern, word) => {\n const patternLength = pattern.length;\n let hasPattern = false;\n\n for (let i = 0; i + patternLength <= word.length; i++) {\n console.log(word.substring(i, i + patternLength));\n if (word.substring(i, i + patternLength) === pattern) {\n hasPattern = true;\n }\n }\n\n return hasPattern;\n};\n\nconst numOfStrings = (patterns, word) => {\n let count = 0;\n\n patterns.forEach((pattern) => {\n if (isPatternInWord(pattern, word)) {\n count++;\n }\n });\n\n return count;\n};\n\nconst result = numOfStrings(['a', 'abc', 'bc', 'd'], 'abc');\nconsole.log('result', result);\n"
},
{
"path": "coding_interviews/leetcode/easy/number-of-unequal-triplets-in-array/number-of-unequal-triplets-in-array.js",
"content": "function unequalTriplets(nums) {\n let counter = 0;\n\n for (let i = 0; i < nums.length - 2; i++) {\n for (let j = i + 1; j < nums.length - 1; j++) {\n for (let k = j + 1; k < nums.length; k++) {\n let iNum = nums[i];\n let jNum = nums[j];\n let kNum = nums[k];\n\n if (iNum !== jNum && iNum !== kNum && jNum !== kNum) counter++;\n }\n }\n }\n\n return counter;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/number_complement.py",
"content": "'''\nhttps://leetcode.com/problems/number-complement/description/\n\nInput: 5\nOutput: 2\n\nInput: 1\nOutput: 0\n'''\n\ndef to_binary(num):\n binary_num = ''\n copy_num = num\n\n while copy_num > 0:\n binary_num += str(copy_num % 2)\n copy_num /= 2\n\n return binary_num\n\ndef to_binary_complement(binary_num):\n return ''.join(['1' if binary == '0' else '0' for binary in binary_num])\n\ndef to_complement(complement_binary_num):\n return sum([pow(2, index) for index, binary in enumerate(complement_binary_num) if binary == '1'])\n\ndef find_complement(num):\n binary_num = to_binary(num)\n complement_binary_num = to_binary_complement(binary_num)\n return to_complement(complement_binary_num)\n\nprint(find_complement(5) == 2)\nprint(find_complement(1) == 0)\nprint(find_complement(8) == 7)\n"
},
{
"path": "coding_interviews/leetcode/easy/number_of_good_pairs/number_of_good_pairs.py",
"content": "def factorial(n):\n if n <= 1: return 1\n return factorial(n - 1) * n\n\ndef permutation(n, r):\n return factorial(n) // (factorial(n - r) * factorial(r))\n\ndef number_of_good_pairs(nums):\n nums_counter = {}\n \n for num in nums:\n if num in nums_counter:\n nums_counter[num] += 1\n else:\n nums_counter[num] = 1\n \n counter = 0\n \n for num, num_counter in nums_counter.items():\n if num_counter > 1:\n counter += permutation(num_counter, 2)\n \n return counter\n\n# ------------------------------------------------------------\n\nfrom math import factorial\n\ndef permutation(n, r):\n return factorial(n) // (factorial(n - r) * factorial(r))\n\ndef number_of_good_pairs(nums):\n nums_counter = {}\n \n for num in nums:\n if num in nums_counter:\n nums_counter[num] += 1\n else:\n nums_counter[num] = 1\n \n counter = 0\n \n for num, num_counter in nums_counter.items():\n if num_counter > 1:\n counter += permutation(num_counter, 2)\n \n return counter\n\n# ------------------------------------------------------------\n\ndef number_of_good_pairs(nums):\n nums_counter = {}\n counter = 0\n \n for num in nums:\n if num in nums_counter:\n counter += nums_counter[num]\n nums_counter[num] += 1\n else:\n nums_counter[num] = 1\n \n return counter\n\n# ------------------------------------------------------------\n\nfrom collections import Counter\n\ndef number_of_good_pairs(nums):\n nums_counter = Counter()\n counter = 0\n \n for num in nums:\n counter += nums_counter[num]\n nums_counter[num] += 1\n \n return counter\n"
},
{
"path": "coding_interviews/leetcode/easy/number_of_recent_calls/number_of_recent_calls.py",
"content": "# https://leetcode.com/problems/number-of-recent-calls\n\nclass RecentCounter:\n def __init__(self):\n self.requests = []\n\n def ping(self, t: int) -> int:\n self.requests.append(t)\n initial_time = t - 3000\n \n counter = 0\n \n for request in self.requests:\n if request >= initial_time and request <= t:\n counter += 1\n \n return counter\n\nclass RecentCounter:\n def __init__(self):\n self.requests = deque()\n\n def ping(self, t: int) -> int:\n self.requests.append(t)\n \n while self.requests[0] < t - 3000:\n self.requests.popleft()\n \n return len(self.requests)"
},
{
"path": "coding_interviews/leetcode/easy/number_of_students/number_of_students.py",
"content": "def busy_student(start_time, end_time, query_time):\n number_of_students = 0\n\n for index in range(len(start_time)):\n start, end = start_time[index], end_time[index]\n\n if query_time >= start and query_time <= end:\n number_of_students += 1\n\n return number_of_students\n\n\ndef busy_student(start_time, end_time, query_time):\n number_of_students = 0\n\n for start, end in zip(start_time, end_time):\n if query_time >= start and query_time <= end:\n number_of_students += 1\n\n return number_of_students\n"
},
{
"path": "coding_interviews/leetcode/easy/odd-string-difference/odd-string-difference.js",
"content": "function toCode(char) {\n return char.charCodeAt() - 97;\n}\n\nfunction buildDiffIntegerArray(word) {\n let diffIntegerArray = [];\n let previous = word[0];\n\n for (let index = 1; index < word.length; index++) {\n let current = word[index];\n diffIntegerArray.push(toCode(current) - toCode(previous));\n previous = current;\n }\n\n return diffIntegerArray;\n}\n\nfunction joinIntegersString(diff) {\n return diff.map((diffNum) => diffNum.toString()).join('*');\n}\n\nfunction oddString(words) {\n let hashmap = new Map();\n\n for (let word of words) {\n let key = joinIntegersString(buildDiffIntegerArray(word));\n\n if (hashmap.has(key)) {\n hashmap.set(key, [hashmap.get(key)[0] + 1, word]);\n } else {\n hashmap.set(key, [1, word]);\n }\n }\n\n for (let [_, [count, word]] of hashmap.entries()) {\n if (count === 1) {\n return word;\n }\n }\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/odd_in_matrix/odd_in_matrix.py",
"content": "def init_matrix(rows, columns):\n return [[0 for _ in range(columns)] for _ in range(rows)]\n\n\ndef odd_cells(n, m, indices):\n matrix = init_matrix(n, m)\n\n for [ri, ci] in indices:\n for column in range(m):\n matrix[ri][column] += 1\n\n for row in range(n):\n matrix[row][ci] += 1\n\n odds = 0\n\n for row in range(n):\n for column in range(m):\n if matrix[row][column] % 2 != 0:\n odds += 1\n\n return odds\n"
},
{
"path": "coding_interviews/leetcode/easy/partition_labels.py",
"content": "'''\nhttps://leetcode.com/problems/partition-labels/description/\n\nInput: S = \"ababcbacadefegdehijhklij\"\nOutput: [9, 7, 8]\n\nInput: S = \"abc\"\nOutput: [1, 1, 1]\n\nInput: S = \"abbaa\"\nOutput: [5]\n'''\n\ndef partition_labels(S):\n partitions = []\n start_index = 0\n last_index = S.rfind(S[0])\n\n for i, c in enumerate(S, 1):\n if i == len(S):\n partitions.append(S[start_index:])\n elif last_index == i - 1:\n partitions.append(S[start_index:i])\n start_index = i\n last_index = S.rfind(S[i])\n elif S.rfind(S[i]) > last_index:\n last_index = S.rfind(S[i])\n\n return [len(partition) for partition in partitions]\n\nprint(partition_labels(\"ababcbacadefegdehijhklij\") == [9, 7, 8])\nprint(partition_labels(\"abc\") == [1, 1, 1])\nprint(partition_labels(\"abbaa\") == [5])\n"
},
{
"path": "coding_interviews/leetcode/easy/pascals-triangle/pascals-triangle.js",
"content": "function generate(numRows) {\n let triangle = [[1]];\n\n for (let row = 1; row < numRows; row++) {\n let triangleRow = [];\n\n for (let index = 0; index <= row; index++) {\n const num1 = index - 1 >= 0 ? triangle[row - 1][index - 1] : 0;\n const num2 =\n index < triangle[row - 1].length ? triangle[row - 1][index] : 0;\n triangleRow.push(num1 + num2);\n }\n\n triangle.push(triangleRow);\n }\n\n return triangle;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/path-sum/path-sum.js",
"content": "function hasPathSum(root, targetSum, sum = 0) {\n if (!root) {\n return false;\n }\n\n if (!root.left && !root.right) {\n return sum + root.val === targetSum;\n }\n\n return (\n hasPathSum(root.left, targetSum, sum + root.val) ||\n hasPathSum(root.right, targetSum, sum + root.val)\n );\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/peak_index_mountain.py",
"content": "'''\nhttps://leetcode.com/problems/peak-index-in-a-mountain-array/description/\n\nInput: [0, 1, 0]\nOutput: 1\n\nInput: [0, 2, 1, 0]\nOutput: 1\n'''\n\ndef peak_index_in_mountain_array(A):\n peak = A[0]\n peak_index = 0\n\n for index, mountain_height in enumerate(A):\n if mountain_height > peak:\n peak_index = index\n peak = mountain_height\n\n return peak_index\n\nprint(peak_index_in_mountain_array([0, 1, 0]) == 1)\nprint(peak_index_in_mountain_array([0, 2, 1, 0]) == 1)\n"
},
{
"path": "coding_interviews/leetcode/easy/percentage-of-letter-in-string/percentage-of-letter-in-string.js",
"content": "function percentageLetter(s, letter) {\n let counter = new Map();\n\n for (let char of s) {\n if (counter.has(char)) {\n counter.set(char, counter.get(char) + 1);\n } else {\n counter.set(char, 1);\n }\n }\n\n let letterCount = counter.has(letter) ? counter.get(letter) : 0;\n\n return Math.floor((letterCount / s.length) * 100);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/plus_one/plus_one.js",
"content": "// https://leetcode.com/problems/plus-one/\n\nfunction add_one(digits) {\n return plus_one(digits, 1);\n}\n\nfunction plus_one(digits, inc) {\n if (digits.length == 0 && inc > 0) {\n return [1];\n }\n\n if (digits.length == 0 && inc == 0) {\n return [];\n }\n\n let new_inc;\n let last_digit;\n\n last_digit = digits[digits.length - 1];\n last_digit = last_digit + inc;\n\n if (last_digit == 10) {\n new_inc = 1;\n } else {\n new_inc = 0;\n }\n\n return plus_one(\n digits.slice(0, digits.length - 1),\n new_inc\n ).concat([last_digit % 10]);\n}\n\nconsole.log(add_one([1, 2, 3])) // [1, 2, 4]\nconsole.log(add_one([4, 3, 2, 1])) // [4, 3, 2, 2]\nconsole.log(add_one([1, 2, 9])) // [1, 3, 0]\nconsole.log(add_one([1, 9, 9])) // [2, 0, 0]\nconsole.log(add_one([9, 9, 9])) // [1, 0, 0, 0]\nconsole.log(add_one([1, 0, 0, 0, 0])) // [1, 0, 0, 0, 1]\n"
},
{
"path": "coding_interviews/leetcode/easy/plus_one/plus_one.py",
"content": "# https://leetcode.com/problems/plus-one/\n\n\ndef add_one(digits):\n return plus_one(digits, 1)\n\n\ndef plus_one(digits, inc):\n if digits == [] and inc > 0:\n return [1]\n\n if digits == [] and inc == 0:\n return []\n\n last_digit = digits[-1]\n last_digit = last_digit + inc\n\n if last_digit == 10:\n new_inc = 1\n else:\n new_inc = 0\n\n return plus_one(digits[0:-1], new_inc) + [last_digit % 10]\n\n\nprint(add_one([1, 2, 3])) # [1, 2, 4]\nprint(add_one([4, 3, 2, 1])) # [4, 3, 2, 2]\nprint(add_one([1, 2, 9])) # [1, 3, 0]\nprint(add_one([1, 9, 9])) # [2, 0, 0]\nprint(add_one([9, 9, 9])) # [1, 0, 0, 0]\nprint(add_one([1, 0, 0, 0, 0])) # [1, 0, 0, 0, 1]\n"
},
{
"path": "coding_interviews/leetcode/easy/points-that-intersect-with-cars/points-that-intersect-with-cars.js",
"content": "// https://leetcode.com/problems/points-that-intersect-with-cars\n\nfunction numberOfPoints(nums) {\n let map = new Map();\n let points = 0;\n\n for ([start, end] of nums) {\n for (let num = start; num <= end; num++) {\n if (!map.has(num)) {\n points++;\n map.set(num, true);\n }\n }\n }\n\n return points;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/power-of-two/power-of-two.js",
"content": "function isPowerOfTwo(n) {\n if (n <= 0) {\n return false;\n }\n\n while (n > 1) {\n if (n % 2 !== 0) {\n return false;\n }\n\n n /= 2;\n }\n\n return true;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/prime-number-of-set-bits-in-binary-representation/prime-number-of-set-bits-in-binary-representation.js",
"content": "// https://leetcode.com/problems/prime-number-of-set-bits-in-binary-representation\n\nfunction toBinary(n) {\n let binary = [];\n\n while (n) {\n binary.push((n % 2).toString());\n n = Math.floor(n / 2);\n }\n\n return binary.join('');\n}\n\nfunction getNumberOfSetBits(binary) {\n let count = 0;\n\n for (let digit of binary) {\n if (digit === '1') count++;\n }\n\n return count;\n}\n\nfunction isPrime(num) {\n for (let i = 2, s = Math.sqrt(num); i <= s; i++) {\n if (num % i === 0) return false;\n }\n return num > 1;\n}\n\nfunction countPrimeSetBits(left, right) {\n let count = 0;\n\n for (let num = left; num <= right; num++) {\n let binary = toBinary(num);\n let setBits = getNumberOfSetBits(binary);\n\n if (isPrime(setBits)) {\n count++;\n }\n }\n\n return count;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/projection-area-of-3d-shapes/projection-area-of-3d-shapes.js",
"content": "// https://leetcode.com/problems/projection-area-of-3d-shapes\n\nfunction projectionArea(grid) {\n let xy = 0;\n let xz = 0;\n let yz = 0;\n\n for (let x = 0; x < grid.length; x++) {\n for (let y = 0; y < grid[x].length; y++) {\n if (grid[x][y] > 0) xy++;\n }\n }\n\n for (let x = 0; x < grid.length; x++) {\n let max = -Infinity;\n\n for (let z = 0; z < grid[x].length; z++) {\n max = Math.max(max, grid[x][z]);\n }\n\n xz += max;\n }\n\n let allAreas = [];\n\n for (let y = 0; y < grid.length; y++) {\n for (let z = 0; z < grid[y].length; z++) {\n allAreas[z] = Math.max(allAreas[z] || 0, grid[y][z]);\n }\n }\n\n yz = allAreas.reduce((sum, area) => sum + area, 0);\n\n return xy + xz + yz;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/range_sum_of_bst/range_sum_of_bst.py",
"content": "# https://leetcode.com/problems/range-sum-of-bst/submissions/\n\n'''\nGiven the root node of a binary search tree,\nreturn the sum of values of all nodes with value between L and R (inclusive).\n\nThe binary search tree is guaranteed to have unique values.\n\nExample 1:\nInput: root = [10,5,15,3,7,null,18], L = 7, R = 15\nOutput: 32\n\nExample 2:\nInput: root = [10,5,15,3,7,13,18,1,null,6], L = 6, R = 10\nOutput: 23\n'''\n\n\ndef rangeSumBST(root, L, R):\n left_sum = 0\n right_sum = 0\n root_sum = 0\n\n if root.left is not None and root.val > L:\n left_sum = rangeSumBST(root.left, L, R)\n\n if root.right is not None and root.val < R:\n right_sum = rangeSumBST(root.right, L, R)\n\n if root.val >= L and root.val <= R:\n root_sum = root.val\n\n return root_sum + left_sum + right_sum\n"
},
{
"path": "coding_interviews/leetcode/easy/rank-transform-of-an-array/rank-transform-of-an-array-less-memory.js",
"content": "// https://leetcode.com/problems/rank-transform-of-an-array\n\n/**\n * [40,10,20,30]\n * [10,20,30,40] => O(NlogN)\n * {10: 1, 20: 2, 30: 3, 40: 4} => O(N), N = array size\n * [4,1,2,3] => O(N)\n * runtime: O(NlogN)\n * space: O(N)\n */\nfunction buildMap(set) {\n let map = new Map();\n let index = 1;\n\n for (let num of set.values()) {\n map.set(num, index);\n index++;\n }\n\n return map;\n}\n\nfunction buildRank(arr, map) {\n for (let index = 0; index < arr.length; index++) {\n arr[index] = map.get(arr[index]);\n }\n\n return arr;\n}\n\nfunction arrayRankTransform(arr) {\n const sortedSet = new Set([...arr].sort((a, b) => a - b));\n const map = buildMap(sortedSet);\n return buildRank(arr, map);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/rank-transform-of-an-array/rank-transform-of-an-array.js",
"content": "// https://leetcode.com/problems/rank-transform-of-an-array\n\n/**\n * [40,10,20,30]\n * [10,20,30,40] => O(NlogN)\n * {10: 1, 20: 2, 30: 3, 40: 4} => O(N), N = array size\n * [4,1,2,3] => O(N)\n * runtime: O(NlogN)\n * space: O(N)\n */\nfunction buildMap(set) {\n let map = new Map();\n let index = 1;\n\n for (let num of set.values()) {\n map.set(num, index);\n index++;\n }\n\n return map;\n}\n\nfunction buildRank(arr, map) {\n let rank = [];\n\n for (let num of arr) {\n rank.push(map.get(num));\n }\n\n return rank;\n}\n\nfunction arrayRankTransform(arr) {\n const sortedSet = new Set([...arr].sort((a, b) => a - b));\n const map = buildMap(sortedSet);\n return buildRank(arr, map);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/ransom-note/ransom-note.js",
"content": "function canConstruct(ransomNote, magazine) {\n let map = {};\n\n for (let char of magazine) {\n if (map[char]) {\n map[char] += 1;\n } else {\n map[char] = 1;\n }\n }\n\n for (let char of ransomNote) {\n if (map[char]) {\n map[char]--;\n } else {\n return false;\n }\n }\n\n return true;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/ransom_note/ransom_note.py",
"content": "def can_construct(ransom_note, magazine):\n if ransom_note == '':\n return True\n\n if magazine == '':\n return False\n\n letters_counter = {}\n\n for letter in magazine:\n if letter in letters_counter:\n letters_counter[letter] += 1\n else:\n letters_counter[letter] = 1\n\n for char in ransom_note:\n if char not in letters_counter or letters_counter[char] == 0:\n return False\n\n letters_counter[char] -= 1\n\n return True\n"
},
{
"path": "coding_interviews/leetcode/easy/reduce_zero/reduce_zero.py",
"content": "# https://leetcode.com/problems/number-of-steps-to-reduce-a-number-to-zero/\n\n\ndef reduce_number(num):\n if num % 2 == 0:\n return num / 2\n else:\n return num - 1\n\n\ndef number_of_steps(num):\n counter = 0\n\n while num:\n counter += 1\n num = reduce_number(num)\n\n return counter\n\n\ndata_tests = [\n (14, 6),\n (8, 4)\n]\n\nfor number, expected in data_tests:\n result = number_of_steps(number)\n print(result, expected == result)\n"
},
{
"path": "coding_interviews/leetcode/easy/reformat-date/reformat-date.js",
"content": "// https://leetcode.com/problems/reformat-date\n\nfunction getDateInfo(date) {\n let dateInfo = [];\n let info = '';\n\n for (let index = 0; index < date.length; index++) {\n let char = date[index];\n if (char === ' ') {\n dateInfo.push(info);\n info = '';\n } else if (index === date.length - 1) {\n dateInfo.push(info + char);\n } else {\n info += char;\n }\n }\n\n return dateInfo;\n}\n\nconst monthStringToNumber = {\n Jan: '01',\n Feb: '02',\n Mar: '03',\n Apr: '04',\n May: '05',\n Jun: '06',\n Jul: '07',\n Aug: '08',\n Sep: '09',\n Oct: '10',\n Nov: '11',\n Dec: '12',\n};\n\nfunction formatDay(day) {\n return day.length === 1 ? `0${day}` : day;\n}\n\nfunction reformatDate(date) {\n let [day, month, year] = getDateInfo(date);\n let dateDay = '';\n let dateMonth = monthStringToNumber[month];\n\n for (let char of day) {\n if (!Number.isNaN(Number(char))) {\n dateDay += char;\n }\n }\n\n return `${year}-${dateMonth}-${formatDay(dateDay)}`;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/reformat-phone-number/reformat-phone-number.js",
"content": "function removeSpacesAndDashes(number) {\n return number.replaceAll('-', '').replaceAll(' ', '');\n}\n\nfunction reformatNumber(number) {\n let num = removeSpacesAndDashes(number);\n let blocks = [];\n let block = [];\n let blockLimit = 2;\n let numLength = num.length;\n\n for (let index = 0; index < numLength; index++) {\n if (block.length === 0) {\n if (numLength - index === 2) {\n blocks.push(num.slice(index));\n break;\n }\n\n if (numLength - index === 4) {\n blocks.push(num.slice(index, index + 2));\n blocks.push(num.slice(index + 2));\n break;\n }\n }\n\n if (index === blockLimit) {\n blockLimit = index + 3;\n block.push(num[index]);\n blocks.push(block.join(''));\n block = [];\n } else {\n block.push(num[index]);\n }\n }\n\n return blocks.join('-');\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/relative-ranks/relative-ranks.js",
"content": "function sortDesc(list) {\n return list.sort((a, b) => b - a);\n}\n\nconst mapper = {\n 0: 'Gold Medal',\n 1: 'Silver Medal',\n 2: 'Bronze Medal',\n};\n\nfunction buildHashmap(list) {\n let hashmap = new Map();\n\n for (let [index, item] of list.entries()) {\n hashmap.set(item, mapper[index] || (index + 1).toString());\n }\n\n return hashmap;\n}\n\nfunction getRelativeRanks(score, hashmap) {\n let rank = [];\n\n for (let value of score) {\n rank.push(hashmap.get(value));\n }\n\n return rank;\n}\n\nfunction findRelativeRanks(score) {\n const sortedScore = sortDesc([...score]);\n const hashmap = buildHashmap(sortedScore);\n return getRelativeRanks(score, hashmap);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/relative-sort-array/relative-sort-array.js",
"content": "// https://leetcode.com/problems/relative-sort-array\n\nconst relativeSortArray = (arr1, arr2) => {\n const mapper1 = {};\n const mapper2 = {};\n\n arr2.forEach((num) => (mapper2[num] = true));\n\n arr1.forEach((num) => {\n if (mapper1[num]) mapper1[num].push(num);\n else if (mapper2[num]) mapper1[num] = [num];\n else if (mapper1['other']) mapper1['other'].push(num);\n else mapper1['other'] = [num];\n });\n\n const sortedArr = [];\n\n arr2.forEach((num) => {\n sortedArr.push(...mapper1[num]);\n });\n\n if (mapper1['other'])\n sortedArr.push(...mapper1['other'].sort((a, b) => a - b));\n\n return sortedArr;\n};\n"
},
{
"path": "coding_interviews/leetcode/easy/remove-duplicates-from-sorted-list/remove-duplicates-from-sorted-list.js",
"content": "function deleteDuplicates(head) {\n if (!head || !head.next) {\n return head;\n }\n\n let current = head;\n let next = current.next;\n\n while (next) {\n if (current.val === next.val) {\n next = next.next;\n current.next = next;\n } else {\n current = next;\n next = next.next;\n }\n }\n\n return head;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/remove-linked-list-elements/remove-linked-list-elements.js",
"content": "function removeElements(head, val) {\n if (!head) return head;\n\n while (head && head.val === val) {\n head = head.next;\n }\n\n if (!head) return head;\n\n let previous = head;\n let current = head.next;\n\n while (current) {\n if (current.val === val) {\n previous.next = current.next;\n current = previous.next;\n } else {\n previous = previous.next;\n current = current.next;\n }\n }\n\n return head;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/remove-outermost-parentheses/remove-outermost-parentheses.js",
"content": "export function removeOuterParentheses(string) {\n const stack = [];\n const result = [];\n\n for (let i = 0; i < string.length; i++) {\n const char = string[i];\n\n if (char === '(') {\n if (stack.length) {\n result.push(char);\n }\n\n stack.push(char);\n } else {\n if (stack.length > 1) {\n result.push(char);\n }\n\n stack.pop();\n }\n }\n\n return result.join('');\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/remove-outermost-parentheses/tests/remove-outermost-parentheses.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport { removeOuterParentheses } from '../remove-outermost-parentheses';\n\ndescribe('removeOuterParentheses', () => {\n it('', () => {\n expect(removeOuterParentheses('(()())(())')).toEqual('()()()');\n });\n\n it('', () => {\n expect(removeOuterParentheses('(()())(())(()(()))')).toEqual(\n '()()()()(())'\n );\n });\n\n it('', () => {\n expect(removeOuterParentheses('()()')).toEqual('');\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/easy/remove-palindromic-subsequences/remove-palindromic-subsequences.js",
"content": "function isPalindrome(s) {\n return s === s.split('').reverse().join('');\n}\n\nfunction removePalindromeSub(s) {\n return isPalindrome(s) ? 1 : 2;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/remove-trailing-zeros-from-a-string/remove-trailing-zeros-from-a-string.js",
"content": "function removeTrailingZeros(num) {\n let result = '';\n let trailing = true;\n\n for (let index = num.length - 1; index >= 0; index--) {\n if (num[index] === '0' && trailing) {\n continue;\n } else {\n trailing = false;\n result = num[index] + result;\n }\n }\n\n return result;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/remove_duplicates/remove_duplicates.py",
"content": "# https://leetcode.com/problems/remove-all-adjacent-duplicates-in-string\n\ndef remove_duplicates(S):\n if len(S) <= 1: return S\n\n start, end = 0, 1\n\n while end < len(S):\n if S[start] != S[end]:\n start = end\n end = start + 1\n\n elif S[start] == S[end] and end + 1 == len(S):\n S = S[0:start]\n\n elif S[start] == S[end]:\n S = S[0:start] + S[end+1:]\n start, end = 0, 1\n\n return S\n\ndef remove_duplicates(S):\n stack = []\n\n for char in S:\n if len(stack) and stack[-1] == char:\n stack.pop()\n else:\n stack.append(char)\n\n return ''.join(stack)"
},
{
"path": "coding_interviews/leetcode/easy/remove_duplicates.py",
"content": "# https://leetcode.com/problems/remove-duplicates-from-sorted-array/description/\n\n'''\n- Examples:\n[1, 1, 2] # => 2\n[] # => 0\n[1, 1, 1] # => 1\n[1, 2, 3, 3, 4, 5] # => 5\n'''\n\ndef remove_duplicates(nums):\n if not nums:\n return 0\n\n total_result = 1\n num = nums[0]\n\n for index in range(1, len(nums)):\n if nums[index] != num:\n nums[total_result] = nums[index]\n total_result += 1\n num = nums[index]\n\n return total_result\n\nlist1 = [1, 1, 2]\nlist2 = []\nlist3 = [1, 1, 1]\nlist4 = [1, 2, 3, 3, 4, 5]\n\nprint remove_duplicates(list1)\nprint remove_duplicates(list2)\nprint remove_duplicates(list3)\nprint remove_duplicates(list4)\n\nprint list1\nprint list2\nprint list3\nprint list4\n"
},
{
"path": "coding_interviews/leetcode/easy/remove_duplicates_from_list.py",
"content": "# https://leetcode.com/problems/remove-duplicates-from-sorted-list/description/\n\nclass ListNode(object):\n def __init__(self, value):\n self.val = value\n self.next = None\n\ndef remove_duplicates(head):\n if head is None:\n return\n\n current_node = head\n\n while current_node and current_node.next:\n if current_node.val == current_node.next.val:\n current_node.next = current_node.next.next\n else:\n current_node = current_node.next\n\n return head\n\n# 1 -> 1 -> 2\nprint('1 -> 1 -> 2')\nhead = ListNode(1)\nhead.next = ListNode(1)\nhead.next.next = ListNode(2)\ncurrent_node = remove_duplicates(head)\n\nwhile current_node:\n print(current_node.val)\n current_node = current_node.next\n\n# 1 -> 1 -> 2 -> 3 -> 3\nprint('\\n1 -> 1 -> 2 -> 3 -> 3')\nhead = ListNode(1)\nhead.next = ListNode(1)\nhead.next.next = ListNode(2)\nhead.next.next.next = ListNode(3)\nhead.next.next.next.next = ListNode(3)\ncurrent_node = remove_duplicates(head)\n\nwhile current_node:\n print(current_node.val)\n current_node = current_node.next\n"
},
{
"path": "coding_interviews/leetcode/easy/remove_element.py",
"content": "# https://leetcode.com/problems/remove-element/description/\n\n'''\nnums = [3, 2, 2, 3], val = 3 # => 2\nnums = [3, 2, 2, 3], val = 2 # => 2\nnums = [1, 2, 2, 4], val = 3 # => 4\nnums = [], val = 3 # => 0\n'''\n\ndef remove_element(nums, val):\n while val in nums:\n nums.remove(val)\n\n return len(nums)\n"
},
{
"path": "coding_interviews/leetcode/easy/replace_digits/replace_digits.py",
"content": "# https://leetcode.com/problems/replace-all-digits-with-characters\n\ndef replace_digits(s):\n replaced_string = []\n \n for index in range(len(s)):\n if index % 2 == 0:\n replaced_string.append(s[index])\n else:\n replaced_string.append(shift(s[index-1], s[index]))\n \n return ''.join(replaced_string)\n \ndef shift(char, digit):\n return chr(ord(char) + int(digit))\n"
},
{
"path": "coding_interviews/leetcode/easy/replace_elements/replace_elements.py",
"content": "# https://leetcode.com/problems/replace-elements-with-greatest-element-on-right-side\n\ndef replace_elements(arr):\n index, max_num = len(arr) - 1, -1\n\n for number in reversed(arr):\n arr[index] = max_num\n max_num = max(number, max_num)\n index -= 1\n \n return arr"
},
{
"path": "coding_interviews/leetcode/easy/reshape-the-matrix/reshape-the-matrix.js",
"content": "function matrixReshape(mat, r, c) {\n if (mat.length * mat[0].length !== r * c) {\n return mat;\n }\n\n let reshapedMatrix = [];\n let reshapedMatrixRow = [];\n let index = 0;\n\n for (let row = 0; row < mat.length; row++) {\n for (let col = 0; col < mat[row].length; col++) {\n const num = mat[row][col];\n\n if (index < c) {\n reshapedMatrixRow.push(num);\n } else {\n reshapedMatrix.push(reshapedMatrixRow);\n reshapedMatrixRow = [num];\n index = 0;\n }\n\n index++;\n }\n }\n\n reshapedMatrix.push(reshapedMatrixRow);\n\n return reshapedMatrix;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/reverse-linked-list/reverse-linked-list.js",
"content": "function reverseList(head) {\n if (!head) {\n return head;\n }\n\n let firstNode = head;\n let secondNode = head.next;\n let auxiliaryNode = null;\n let previousNode = null;\n\n while (secondNode) {\n auxiliaryNode = secondNode.next;\n secondNode.next = firstNode;\n firstNode.next = previousNode;\n previousNode = firstNode;\n firstNode = secondNode;\n secondNode = auxiliaryNode;\n }\n\n return firstNode;\n}\n\nfunction reverseListSimpler(head) {\n let previous = null;\n let current = head;\n let next;\n\n while (current) {\n next = current.next;\n current.next = previous;\n previous = current;\n current = next;\n }\n\n return previous;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/reverse-only-letters/reverse-only-letters.js",
"content": "function isEnglishLetter(char) {\n return (\n (char.charCodeAt() >= 65 && char.charCodeAt() <= 90) ||\n (char.charCodeAt() >= 97 && char.charCodeAt() <= 122)\n );\n}\n\nfunction reverseOnlyLetters(s) {\n const englishLetter = [];\n\n for (let char of s) {\n if (isEnglishLetter(char)) englishLetter.push(char);\n }\n\n let index = englishLetter.length - 1;\n let output = s.split('');\n\n for (let i = 0; i < s.length; i++) {\n if (isEnglishLetter(s[i])) {\n output[i] = englishLetter[index];\n index--;\n }\n }\n\n return output.join('');\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/reverse-prefix-of-word/reverse-prefix-of-word.js",
"content": "function reverse(charsList) {\n const reversedCharsList = [];\n\n for (let i = charsList.length - 1; i >= 0; i--) {\n reversedCharsList.push(charsList[i]);\n }\n\n return reversedCharsList;\n}\n\nexport function reversePrefix(word, char) {\n let charsList = [];\n let foundFirstOccurrence = false;\n\n for (let i = 0; i < word.length; i++) {\n const wordChar = word[i];\n charsList.push(wordChar);\n\n if (wordChar === char && !foundFirstOccurrence) {\n foundFirstOccurrence = true;\n charsList = reverse(charsList);\n }\n }\n\n return charsList.join('');\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/reverse-prefix-of-word/tests/reverse-prefix-of-word.test.js",
"content": "import { describe, it, expect } from 'vitest';\nimport { reversePrefix } from '../reverse-prefix-of-word';\n\ndescribe('reversePrefix', () => {\n it('reverses the prefix', () => {\n expect(reversePrefix('abcdefd', 'd')).toEqual('dcbaefd');\n });\n\n it('reverses the prefix', () => {\n expect(reversePrefix('xyxzxe', 'z')).toEqual('zxyxxe');\n });\n\n it('reverses the prefix', () => {\n expect(reversePrefix('abcd', 'z')).toEqual('abcd');\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/easy/reverse-string/reverse-string-in-place.js",
"content": "function reverseString(s) {\n let pointer1 = 0;\n let pointer2 = s.length - 1;\n let auxiliaryChar;\n\n while (pointer1 < pointer2) {\n auxiliaryChar = s[pointer1];\n s[pointer1] = s[pointer2];\n s[pointer2] = auxiliaryChar;\n pointer1++;\n pointer2--;\n }\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/reverse-string/reverse-string.js",
"content": "function reverseString(s) {\n let reversedString = [];\n\n for (let index = s.length - 1; index >= 0; index--) {\n reversedString.push(s[index]);\n }\n\n return reversedString;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/reverse-vowels-of-a-string/reverse-vowels-of-a-string.js",
"content": "function reverseVowels(s) {\n const allVowels = [];\n const vowels = 'aeiouAEIOU';\n\n for (let char of s) {\n if (vowels.includes(char)) allVowels.push(char);\n }\n\n const reversedVowels = [];\n\n for (\n let index = 0, vowelIndex = allVowels.length - 1;\n index < s.length;\n index++\n ) {\n if (vowels.includes(s[index])) {\n reversedVowels.push(allVowels[vowelIndex]);\n vowelIndex--;\n } else {\n reversedVowels.push(s[index]);\n }\n }\n\n return reversedVowels.join('');\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/reverse-words-in-a-string-iii/reverse-words-in-a-string-iii.js",
"content": "function reverseWords(s) {\n let reversedString = [];\n let splittedString = s.split(' ');\n\n for (let word of splittedString) {\n let reversedWord = [];\n\n for (let index = word.length - 1; index >= 0; index--) {\n reversedWord.push(word[index]);\n }\n\n reversedString.push(reversedWord.join(''));\n }\n\n return reversedString.join(' ');\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/reverse_integer.py",
"content": "# https://leetcode.com/problems/reverse-integer/\n\ndef reverse(x):\n number_list = []\n\n if x < 0:\n negative = True\n x *= -1\n else:\n negative = False\n\n while x > 0:\n number_list.append(x % 10)\n x /= 10\n\n result_number = 0\n\n for index, n in enumerate(number_list):\n result_number += n * pow(10, len(number_list) - 1 - index)\n\n if negative:\n result_number *= -1\n\n if (result_number < 2147483648*-1 or result_number > 2147483647):\n return 0\n\n return result_number\n"
},
{
"path": "coding_interviews/leetcode/easy/reverse_string.py",
"content": "'''\nhttps://leetcode.com/problems/reverse-string/description/\n\ninput: \"hello\"\noutput: \"olleh\"\n'''\n\ndef reverse_string(s):\n return s[::-1]\n"
},
{
"path": "coding_interviews/leetcode/easy/reverse_vowels.py",
"content": "'''\nhttps://leetcode.com/problems/reverse-vowels-of-a-string/description/\n\ninput: \"hello\"\noutput: \"holle\"\n\ninput: \"leetcode\"\noutput: \"leotcede\"\n'''\n\ndef vowel(char):\n return char in ['a', 'e', 'i', 'o', 'u']\n\ndef reverse_vowels(s):\n vowels = [char for char in s if vowel(char)]\n index = len(vowels) - 1\n result = ''\n\n for char in s:\n if vowel(char):\n result += vowels[index]\n index -= 1\n else:\n result += char\n\n return result\n\n\n\nprint(reverse_vowels('hello') == 'holle')\nprint(reverse_vowels('leetcode') == 'leotcede')\n"
},
{
"path": "coding_interviews/leetcode/easy/reverse_words_string.py",
"content": "'''\nhttps://leetcode.com/problems/reverse-words-in-a-string-iii/description/\n\ninput: \"Let's take LeetCode contest\"\noutput: \"s'teL ekat edoCteeL tsetnoc\"\n'''\n\ndef reverse_words(s):\n return ' '.join([word[::-1] for word in s.split(' ')])\n\nprint(reverse_words(\"Let's take LeetCode contest\") == \"s'teL ekat edoCteeL tsetnoc\")\n"
},
{
"path": "coding_interviews/leetcode/easy/rings-and-rods/rings-and-rods.js",
"content": "/*\nThere are n rings and each ring is either red, green, or blue. The rings are distributed across ten rods labeled from 0 to 9.\n\nYou are given a string rings of length 2n that describes the n rings that are placed onto the rods. Every two characters in rings forms a color-position pair that is used to describe each ring where:\n\nThe first character of the ith pair denotes the ith ring's color ('R', 'G', 'B').\nThe second character of the ith pair denotes the rod that the ith ring is placed on ('0' to '9').\nFor example, \"R3G2B1\" describes n == 3 rings: a red ring placed onto the rod labeled 3, a green ring placed onto the rod labeled 2, and a blue ring placed onto the rod labeled 1.\n\nReturn the number of rods that have all three colors of rings on them.\n\nInput: rings = \"B0B6G0R6R0R6G9\"\nOutput: 1\n\nInput: rings = \"B0R0G0R9R0B0G0\"\nOutput: 1\n*/\n\nexport function countPoints(rings = '') {\n const rods = {\n 0: new Set(),\n 1: new Set(),\n 2: new Set(),\n 3: new Set(),\n 4: new Set(),\n 5: new Set(),\n 6: new Set(),\n 7: new Set(),\n 8: new Set(),\n 9: new Set(),\n };\n\n for (let i = 0; i < rings.length - 1; i += 2) {\n const color = rings[i];\n const position = rings[i + 1];\n rods[position].add(color);\n }\n\n return Object.values(rods).reduce(\n (count, colors) => (colors.size === 3 ? count + 1 : count),\n 0\n );\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/rings-and-rods/tests/rings-and-rods.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport { countPoints } from '../rings-and-rods';\n\ndescribe('countPoints', () => {\n it('', () => {\n expect(countPoints('B0B6G0R6R0R6G9')).toEqual(1);\n });\n\n it('', () => {\n expect(countPoints('B0R0G0R9R0B0G0')).toEqual(1);\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/easy/root-equals-sum-of-children/index.js",
"content": "function checkTree(root) {\n return root.val === root.left.val + root.right.val;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/row-with-maximum-ones/row-with-maximum-ones.js",
"content": "// https://leetcode.com/problems/row-with-maximum-ones\n\nfunction rowAndMaximumOnes(mat) {\n let rowIndex;\n let maxCountOfOnes = -Infinity;\n\n for (let row = 0; row < mat.length; row++) {\n let countOfOnes = 0;\n\n for (let num of mat[row]) {\n if (num === 1) {\n countOfOnes++;\n }\n }\n\n if (countOfOnes > maxCountOfOnes) {\n maxCountOfOnes = countOfOnes;\n rowIndex = row;\n }\n }\n\n return [rowIndex, maxCountOfOnes];\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/running_array_sum/running_array_sum.py",
"content": "def running_sum(nums):\n sum = 0\n result = []\n\n for num in nums:\n sum += num\n result.append(sum)\n\n return result\n"
},
{
"path": "coding_interviews/leetcode/easy/same-tree/same-tree.js",
"content": "function isSameTree(p, q) {\n if (!p && !q) return true;\n if ((!p && q) || (!q && p)) return false;\n\n return (\n p.val === q.val &&\n isSameTree(p.left, q.left) &&\n isSameTree(p.right, q.right)\n );\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/same_tree.py",
"content": "# https://leetcode.com/problems/same-tree/description/\n\ndef is_same_tree(p, q):\n if (p and not q) or (not p and q):\n return False\n\n if not p and not q:\n return True\n\n return p.val == q.val and is_same_tree(p.left, q.left) and is_same_tree(p.right, q.right)\n\ndef is_same_tree(p, q):\n if p and q:\n return p.val == q.val and is_same_tree(p.left, q.left) and is_same_tree(p.right, q.right)\n\n return p is q\n"
},
{
"path": "coding_interviews/leetcode/easy/search-in-a-binary-search-tree/search-in-a-binary-search-tree.js",
"content": "function searchBST(root, val) {\n if (!root) {\n return null;\n }\n\n if (root.val === val) {\n return root;\n }\n\n return searchBST(root.left, val) || searchBST(root.right, val);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/search-insert-position/search-insert-position-new.js",
"content": "function getMiddle(start, end) {\n return Math.floor((start + end) / 2);\n}\n\nfunction searchInsert(nums, target) {\n let start = 0;\n let end = nums.length - 1;\n let middle = getMiddle(start, end);\n\n while (start <= end) {\n if (target < nums[middle]) {\n end = middle - 1;\n middle = getMiddle(start, end);\n } else if (target > nums[middle]) {\n start = middle + 1;\n middle = getMiddle(start, end);\n } else {\n return middle;\n }\n }\n\n return middle + 1;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/search-insert-position/search-insert-position.js",
"content": "// https://leetcode.com/problems/search-insert-position\n\nconst searchInsert = (nums, target) => {\n let start = 0;\n let end = nums.length - 1;\n\n while (start <= end) {\n middle = Math.floor((start + end) / 2);\n if (nums[middle] === target) return middle;\n if (target > nums[middle]) start = middle + 1;\n if (target < nums[middle]) end = middle - 1;\n }\n\n return start;\n};\n\nconst print = (nums, target) => console.log(searchInsert(nums, target));\n\nprint([1, 3, 5, 6], 5);\nprint([1, 3, 5, 6], 2);\nprint([1, 3, 5, 6], 7);\nprint([1, 3, 5, 6], 0);\nprint([1], 0);\n"
},
{
"path": "coding_interviews/leetcode/easy/search_in_a_binary_search_tree/search_in_a_binary_search_tree.py",
"content": "# https://leetcode.com/problems/search-in-a-binary-search-tree\n\ndef searchBST(root, val):\n if root and val < root.val:\n return searchBST(root.left, val)\n \n if root and val > root.val:\n return searchBST(root.right, val)\n \n return root\n"
},
{
"path": "coding_interviews/leetcode/easy/second-largest-digit-in-a-string/second-largest-digit-in-a-string.js",
"content": "// https://leetcode.com/problems/second-largest-digit-in-a-string\n\nfunction secondHighest(s) {\n let highest = -1;\n let secHighest = -1;\n\n for (let char of s) {\n let numChar = Number(char);\n let isInt = Number.isInteger(numChar);\n\n if (isInt && numChar > highest) {\n secHighest = highest;\n highest = numChar;\n } else if (isInt && numChar !== highest && numChar > secHighest) {\n secHighest = numChar;\n }\n }\n\n return highest === secHighest ? -1 : secHighest;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/self_dividing_numbers.py",
"content": "'''\nhttps://leetcode.com/problems/self-dividing-numbers/description/\n\nInput: left = 1, right = 22\nOutput: [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22]\n'''\n\ndef self_dividing_numbers(left, right):\n output = [number for number in range(left, right + 1) if dividing(number, number)]\n return output\n\ndef dividing(number, original):\n if number == 0: return True\n if number % 10 == 0: return False\n return dividing(number / 10, original) and original % (number % 10) == 0\n\nprint(self_dividing_numbers(1, 22) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22])\n"
},
{
"path": "coding_interviews/leetcode/easy/semi-ordered-permutation/semi-ordered-permutation.js",
"content": "// https://leetcode.com/problems/semi-ordered-permutation\n\nfunction semiOrderedPermutation(nums) {\n let N = nums.length;\n let indexFirst;\n let indexLast;\n\n for (let index = 0; index < N; index++) {\n if (nums[index] === 1) indexFirst = index;\n if (nums[index] === N) indexLast = index;\n }\n\n let swaps = indexFirst;\n\n if (indexFirst > indexLast) swaps += N - indexLast - 2;\n else swaps += N - indexLast - 1;\n\n return swaps;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/separate-the-digits-in-an-array/separate-the-digits-in-an-array.js",
"content": "function separateDigits(nums) {\n const answer = [];\n\n for (let num of nums) {\n const numString = num.toString();\n\n for (let charNum of numString) {\n answer.push(Number(charNum));\n }\n }\n\n return answer;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/shortest_to_char/shortest_to_char.py",
"content": "# https://leetcode.com/problems/shortest-distance-to-a-character\n\ndef shortest_to_char(s, c):\n all_c_indexes = []\n \n for index, char in enumerate(s):\n if char == c:\n all_c_indexes.append(index)\n \n answer = []\n \n for index, char in enumerate(s):\n if char == c:\n answer.append(0)\n else:\n answer_index = float('Inf')\n \n for c_index in all_c_indexes:\n answer_index = min(answer_index, abs(c_index - index))\n \n answer.append(answer_index)\n \n return answer\n\ndef shortest_to_char(s, c):\n previous = float('-Inf')\n answer = []\n \n for index, char in enumerate(s):\n if char == c:\n previous = index\n \n answer.append(index - previous)\n \n previous = float('Inf')\n \n for index in range(len(s) - 1, -1, -1):\n if s[index] == c:\n previous = index\n \n answer[index] = min(answer[index], previous - index)\n \n return answer"
},
{
"path": "coding_interviews/leetcode/easy/shuffle_string/shuffle_string.py",
"content": "# shuffle string\n# https://leetcode.com/problems/shuffle-string\n\n\ndef restore_string(s, indices):\n index_to_char_mapper = {}\n\n for index in range(len(s)):\n index_to_char_mapper[indices[index]] = s[index]\n\n return ''.join([index_to_char_mapper[index] for index in range(len(s))])\n"
},
{
"path": "coding_interviews/leetcode/easy/shuffle_the_array/shuffle_the_array.py",
"content": "def shuffle(nums, n):\n first_half = nums[:n]\n last_half = nums[n:]\n final_list = []\n\n for index in range(len(first_half)):\n final_list.append(first_half[index])\n final_list.append(last_half[index])\n\n return final_list\n"
},
{
"path": "coding_interviews/leetcode/easy/sign_of_the_product_of_an_array/sign_of_the_product_of_an_array.py",
"content": "# https://leetcode.com/problems/sign-of-the-product-of-an-array\n\ndef array_sign(nums):\n product = 1\n \n for num in nums:\n if num == 0: return 0\n product *= num\n \n if product > 0:\n return 1\n\n if product < 0:\n return -1"
},
{
"path": "coding_interviews/leetcode/easy/single-number/single-number.js",
"content": "function singleNumber(nums) {\n let hashmap = {};\n\n for (let num of nums) {\n if (hashmap[num]) {\n hashmap[num]++;\n } else {\n hashmap[num] = 1;\n }\n }\n\n for (let num of nums) {\n if (hashmap[num] === 1) {\n return num;\n }\n }\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/single_number/single_number.py",
"content": "# https://leetcode.com/problems/single-number\n\ndef single_number(nums):\n counter = {}\n \n for num in nums:\n if num in counter:\n counter[num] += 1\n else:\n counter[num] = 1\n \n for num in nums:\n if counter[num] == 1: return num\n"
},
{
"path": "coding_interviews/leetcode/easy/slowest-key/slowest-key.js",
"content": "function isLexicographicallyLarger(keysPressed, keyPressedIndex, index) {\n return keysPressed[index] > keysPressed[keyPressedIndex];\n}\n\nfunction slowestKey(releaseTimes, keysPressed) {\n let longestDuration = releaseTimes[0];\n let previousRelease = releaseTimes[0];\n let keyPressedIndex = 0;\n\n for (let index = 1; index < releaseTimes.length; index++) {\n let currentRelease = releaseTimes[index];\n let currentDuration = currentRelease - previousRelease;\n\n if (currentDuration > longestDuration) {\n longestDuration = currentDuration;\n keyPressedIndex = index;\n }\n\n if (\n currentDuration === longestDuration &&\n isLexicographicallyLarger(keysPressed, keyPressedIndex, index)\n ) {\n longestDuration = currentDuration;\n keyPressedIndex = index;\n }\n\n previousRelease = currentRelease;\n }\n\n return keysPressed[keyPressedIndex];\n}\n\nfunction slowestKey(releaseTimes, keysPressed) {\n let longestDuration = releaseTimes[0];\n let previousRelease = releaseTimes[0];\n let keyPressedIndex = 0;\n\n for (let index = 1; index < releaseTimes.length; index++) {\n let currentRelease = releaseTimes[index];\n let currentDuration = currentRelease - previousRelease;\n\n if (\n currentDuration > longestDuration ||\n (currentDuration === longestDuration &&\n isLexicographicallyLarger(keysPressed, keyPressedIndex, index))\n ) {\n longestDuration = currentDuration;\n keyPressedIndex = index;\n }\n\n previousRelease = currentRelease;\n }\n\n return keysPressed[keyPressedIndex];\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/smallest-even-multiple/smallest-even-multiple.js",
"content": "function smallestEvenMultiple(n) {\n return n % 2 === 0 ? n : n * 2;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/smallest-index-with-equal-value/smallest-index-with-equal-value.js",
"content": "function smallestEqual(nums) {\n for (let [index, num] of nums.entries()) {\n if (index % 10 === num) {\n return index;\n }\n }\n\n return -1;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/smallest-range-i/optimized-smallest-range-i.js",
"content": "// https://leetcode.com/problems/smallest-range-i\n\nfunction minMax(nums) {\n let min = Infinity;\n let max = -Infinity;\n\n for (let num of nums) {\n min = Math.min(min, num);\n max = Math.max(max, num);\n }\n\n return [min, max];\n}\n\nfunction smallestRangeI(nums, k) {\n let [min, max] = minMax(nums);\n return Math.max(0, max - k - (min + k));\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/smallest-range-i/smallest-range-i.js",
"content": "// https://leetcode.com/problems/smallest-range-i\n\nfunction smallestRangeI(nums, k) {\n let smaller = Infinity;\n let bigger = -Infinity;\n\n for (let num of nums) {\n smaller = Math.min(smaller, num);\n bigger = Math.max(bigger, num);\n }\n\n let middle = Math.floor((bigger + smaller) / 2);\n let min = Infinity;\n let max = -Infinity;\n\n if (k > bigger - middle) {\n max = middle;\n } else {\n max = bigger - k;\n }\n\n if (k > middle - smaller) {\n min = middle;\n } else {\n min = smaller + k;\n }\n\n return max - min;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/smallest-range-i/smallest-range-iI.js",
"content": "// https://leetcode.com/problems/smallest-range-i\n\nfunction smallestRangeI(nums, k) {\n let min = Math.min(...nums);\n let max = Math.max(...nums);\n return Math.max(0, max - k - (min + k));\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/smallest_numbers/smallest_numbers.py",
"content": "# https://leetcode.com/problems/how-many-numbers-are-smaller-than-the-current-number\n\n'''\nnums = [8,1,2,2,3]\n[4,0,1,1,3]\n\nnums = [6,5,4,8]\n[2,1,0,3]\n'''\n\n\n'''\nO(Nˆ2): Runtime / O(N): Space\n'''\n\n\ndef smaller_numbers_than_current(nums):\n smaller_numbers_counters = []\n\n for num in nums:\n counter = 0\n\n for compared_num in nums:\n if compared_num < num:\n counter += 1\n\n smaller_numbers_counters.append(counter)\n\n return smaller_numbers_counters\n\n\n'''\nO(NlogN): Runtime / O(N): Space\n'''\n\n\ndef smaller_numbers_than_current_2(nums):\n smaller_numbers_counters = {}\n\n for index, num in enumerate(sorted(nums)):\n if num not in smaller_numbers_counters:\n smaller_numbers_counters[num] = index\n\n return [smaller_numbers_counters[num] for num in nums]\n\n\ndata_tests = [\n ([8, 1, 2, 2, 3], [4, 0, 1, 1, 3]),\n ([6, 5, 4, 8], [2, 1, 0, 3])\n]\n\nfor numbers, expected in data_tests:\n result = smaller_numbers_than_current(numbers)\n print(result, result == expected)\n\n result = smaller_numbers_than_current_2(numbers)\n print(result, result == expected)\n"
},
{
"path": "coding_interviews/leetcode/easy/sort-array-by-increasing-frequency/sort-array-by-increasing-frequency.js",
"content": "function buildCounter(nums) {\n let counter = new Map();\n\n for (let num of nums) {\n if (counter.has(num)) counter.set(num, counter.get(num) + 1);\n else counter.set(num, 1);\n }\n\n return counter;\n}\n\nfunction toPairs(counter) {\n const pairs = [];\n\n for (let [key, value] of counter.entries()) {\n pairs.push([key, value]);\n }\n\n return pairs;\n}\n\nfunction byCount(pair1, pair2) {\n if (pair1[1] < pair2[1]) return -1;\n if (pair1[1] === pair2[1] && pair1[0] >= pair2[0]) return -1;\n if (pair1[1] === pair2[1] && pair1[0] < pair2[0]) return 1;\n if (pair1[1] > pair2[1]) return 1;\n return 0;\n}\n\nfunction buildResult(pairs) {\n const result = [];\n\n for (let [num, count] of pairs) {\n for (let counter = 1; counter <= count; counter++) {\n result.push(num);\n }\n }\n\n return result;\n}\n\nfunction frequencySort(nums) {\n const counter = buildCounter(nums);\n const pairs = toPairs(counter);\n pairs.sort(byCount);\n return buildResult(pairs);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/sort-array-by-parity/sort-array-by-parity-two-loops.js",
"content": "// https://leetcode.com/problems/sort-array-by-parity\n\nfunction sortArrayByParity(nums) {\n let output = [];\n\n for (let num of nums) {\n if (num % 2 === 0) output.push(num);\n }\n\n for (let num of nums) {\n if (num % 2 !== 0) output.push(num);\n }\n\n return output;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/sort-array-by-parity/sort-array-by-parity.js",
"content": "// https://leetcode.com/problems/sort-array-by-parity\n\nfunction sortArrayByParity(nums) {\n let odd = [];\n let even = [];\n\n for (let num of nums) {\n if (num % 2 === 0) even.push(num);\n else odd.push(num);\n }\n\n return [...even, ...odd];\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/sort-array-by-parity-ii/sort-array-by-parity-ii.js",
"content": "function isEven(num) {\n return num % 2 === 0;\n}\n\nfunction separateIntoEvensAndOdds(nums) {\n let evens = [];\n let odds = [];\n\n for (let num of nums) {\n if (isEven(num)) evens.push(num);\n else odds.push(num);\n }\n\n return [evens, odds];\n}\n\nexport function sortArrayByParityII(nums) {\n let [evens, odds] = separateIntoEvensAndOdds(nums);\n let result = [];\n\n for (let index = 0; index < evens.length; index++) {\n result.push(evens[index]);\n result.push(odds[index]);\n }\n\n return result;\n}\n\nexport function sortArrayByParityIIInPlace(nums) {\n for (let index = 0; index < nums.length - 1; index++) {\n if (isEven(index) !== isEven(nums[index])) {\n for (let index2 = index + 1; index2 < nums.length; index2++) {\n if (isEven(index) === isEven(nums[index2])) {\n let num = nums[index];\n nums[index] = nums[index2];\n nums[index2] = num;\n break;\n }\n }\n }\n }\n\n return nums;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/sort-array-by-parity-ii/tests/sort-array-by-parity-ii.test.js",
"content": "import { describe, it, expect } from 'vitest';\nimport {\n sortArrayByParityII,\n sortArrayByParityIIInPlace,\n} from '../sort-array-by-parity-ii';\n\ndescribe('sortArrayByParityII', () => {\n it('', () => {\n expect(sortArrayByParityII([4, 2, 5, 7])).toEqual([4, 5, 2, 7]);\n });\n\n it('', () => {\n expect(sortArrayByParityII([2, 3])).toEqual([2, 3]);\n });\n\n it('', () => {\n expect(sortArrayByParityII([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])).toEqual([\n 2, 1, 4, 3, 6, 5, 8, 7, 10, 9,\n ]);\n });\n\n it('', () => {\n expect(sortArrayByParityII([2, 3, 1, 1, 4, 0, 0, 4, 3, 3])).toEqual([\n 2, 3, 4, 1, 0, 1, 0, 3, 4, 3,\n ]);\n });\n});\n\ndescribe('sortArrayByParityIIInPlace', () => {\n it('', () => {\n expect(sortArrayByParityIIInPlace([4, 2, 5, 7])).toEqual([4, 5, 2, 7]);\n });\n\n it('', () => {\n expect(sortArrayByParityIIInPlace([2, 3])).toEqual([2, 3]);\n });\n\n it('', () => {\n expect(sortArrayByParityIIInPlace([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])).toEqual(\n [2, 1, 4, 3, 6, 5, 8, 7, 10, 9]\n );\n });\n\n it('', () => {\n expect(sortArrayByParityIIInPlace([2, 3, 1, 1, 4, 0, 0, 4, 3, 3])).toEqual([\n 2, 3, 4, 1, 0, 1, 0, 3, 4, 3,\n ]);\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/easy/sort-even-and-odd-indices-independently/sort-even-and-odd-indices-independently.js",
"content": "function decreasing(a, b) {\n return b - a;\n}\n\nfunction increasing(a, b) {\n return a - b;\n}\n\nfunction sortEvenOdd(nums) {\n let evens = [];\n let odds = [];\n\n for (let index = 0; index < nums.length; index++) {\n if (index % 2 === 0) evens.push(nums[index]);\n else odds.push(nums[index]);\n }\n\n evens.sort(increasing);\n odds.sort(decreasing);\n\n let result = [];\n let biggerLength = evens.length > odds.length ? evens.length : odds.length;\n\n for (let index = 0; index < biggerLength; index++) {\n if (index < evens.length) result.push(evens[index]);\n if (index < odds.length) result.push(odds[index]);\n }\n\n return result;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/sort-integers-by-the-number-of-1-bits/sort-integers-by-the-number-of-1-bits.js",
"content": "function toBinary(num) {\n if (num === 0) return { binary: '0', numberOfOneBits: 0 };\n\n let binary = [];\n let numberOfOneBits = 0;\n let numCopy = num;\n\n while (numCopy > 0) {\n const binaryDigit = numCopy % 2;\n if (binaryDigit) numberOfOneBits++;\n binary.unshift(String(binaryDigit));\n numCopy = Math.floor(numCopy / 2);\n }\n\n return { num, binary: binary.join(''), numberOfOneBits };\n}\n\nfunction byNumberOfOneBits(binary1, binary2) {\n if (binary1.numberOfOneBits < binary2.numberOfOneBits) return -1;\n if (binary1.numberOfOneBits > binary2.numberOfOneBits) return 1;\n if (\n binary1.numberOfOneBits === binary2.numberOfOneBits &&\n binary1.num < binary2.num\n )\n return -1;\n return 0;\n}\n\nfunction sortByBits(nums) {\n const hashmap = new Map();\n const binaries = [];\n const result = [];\n\n for (let num of nums) {\n const binary = toBinary(num);\n hashmap.set(binary.binary, num);\n binaries.push(binary);\n }\n\n binaries.sort(byNumberOfOneBits);\n\n for (let { binary } of binaries) {\n result.push(hashmap.get(binary));\n }\n\n return result;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/sort-the-people/sort-the-people.js",
"content": "function sortPeople(names, heights) {\n const heightToName = new Map();\n\n for (let index = 0; index < names.length; index++) {\n const name = names[index];\n const height = heights[index];\n heightToName.set(height, name);\n }\n\n return heights\n .sort((height1, height2) => height2 - height1)\n .map((height) => heightToName.get(height));\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/sort_array_by_parity/sort_array_by_parity.py",
"content": "# https://leetcode.com/problems/sort-array-by-parity/submissions/\n\n'''\nGiven an array A of non-negative integers,\nreturn an array consisting of all the even elements of A,\nfollowed by all the odd elements of A.\n\nYou may return any answer array that satisfies this condition.\n\nExample:\nInput: [3,1,2,4]\nOutput: [2,4,3,1]\n'''\n\n\ndef sort_array_by_parity(A):\n even_numbers = []\n odd_numbers = []\n\n for number in A:\n if number % 2 == 0:\n even_numbers.append(number)\n else:\n odd_numbers.append(number)\n\n return even_numbers + odd_numbers\n\n\ndata_tests = [\n ([1, 2, 3, 4], [2, 4, 1, 3]),\n ([3, 1, 2, 4], [2, 4, 3, 1]),\n]\n\nfor numbers, expected in data_tests:\n result = sort_array_by_parity(numbers)\n print(result, result == expected)\n"
},
{
"path": "coding_interviews/leetcode/easy/sort_sentence/sort_sentence.py",
"content": "# https://leetcode.com/problems/sorting-the-sentence\n\ndef sort_sentence(s):\n words = s.split()\n index_to_word = {}\n\n for word in words:\n index = int(word[-1])\n actual_word = word[:len(word) - 1]\n index_to_word[index] = actual_word\n \n sentence = []\n \n for index in range(1, len(words) + 1):\n sentence.append(index_to_word[index])\n \n return ' '.join(sentence)\n"
},
{
"path": "coding_interviews/leetcode/easy/special-positions-in-a-binary-matrix/special-positions-in-a-binary-matrix-cache.js",
"content": "function countOnesInRow(matrix, row) {\n let ones = 0;\n\n for (let col = 0; col < matrix[row].length; col++) {\n if (matrix[row][col] === 1) ones++;\n }\n\n return ones;\n}\n\nfunction countOnesInCol(matrix, col) {\n let ones = 0;\n\n for (let row = 0; row < matrix.length; row++) {\n if (matrix[row][col] === 1) ones++;\n }\n\n return ones;\n}\n\nfunction numSpecial(matrix) {\n let specialPositions = 0;\n let hashmapRow = new Map();\n let hashmapCol = new Map();\n\n for (let row = 0; row < matrix.length; row++) {\n for (let col = 0; col < matrix[row].length; col++) {\n let rowOnes = hashmapRow.has(row)\n ? hashmapRow.get(row)\n : countOnesInRow(matrix, row);\n\n hashmapRow.set(row, rowOnes);\n\n let colOnes = hashmapCol.has(col)\n ? hashmapCol.get(col)\n : countOnesInCol(matrix, col);\n\n hashmapCol.set(col, colOnes);\n\n if (matrix[row][col] === 1 && rowOnes === 1 && colOnes === 1) {\n specialPositions++;\n }\n }\n }\n\n return specialPositions;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/special-positions-in-a-binary-matrix/special-positions-in-a-binary-matrix.js",
"content": "function countOnesInRow(matrix, row) {\n let ones = 0;\n\n for (let col = 0; col < matrix[row].length; col++) {\n if (matrix[row][col] === 1) ones++;\n }\n\n return ones;\n}\n\nfunction countOnesInCol(matrix, col) {\n let ones = 0;\n\n for (let row = 0; row < matrix.length; row++) {\n if (matrix[row][col] === 1) ones++;\n }\n\n return ones;\n}\n\nfunction numSpecial(matrix) {\n let specialPositions = 0;\n\n for (let row = 0; row < matrix.length; row++) {\n for (let col = 0; col < matrix[row].length; col++) {\n if (\n matrix[row][col] === 1 &&\n countOnesInRow(matrix, row) === 1 &&\n countOnesInCol(matrix, col) === 1\n ) {\n specialPositions++;\n }\n }\n }\n\n return specialPositions;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/split-strings-by-separator/split-strings-by-separator.js",
"content": "// https://leetcode.com/problems/split-strings-by-separator\n\nfunction splitWordsBySeparator(words, separator) {\n let output = [];\n\n for (let word of words) {\n let start = 0;\n\n for (let index = 0; index < word.length; index++) {\n if (word[index] === separator) {\n const str = word.slice(start, index);\n if (str.length) output.push(str);\n start = index + 1;\n } else if (index === word.length - 1) {\n output.push(word.slice(start, index + 1));\n start = index + 1;\n }\n }\n }\n\n return output;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/split-with-minimum-sum/split-with-minimum-sum.js",
"content": "function splitNum(num) {\n let numsString = num\n .toString()\n .split('')\n .sort((a, b) => a - b);\n\n let firstHalf = [];\n let lastHalf = [];\n let isFirstHalf = true;\n\n for (let charNum of numsString) {\n if (isFirstHalf) firstHalf.push(charNum);\n else lastHalf.push(charNum);\n isFirstHalf = !isFirstHalf;\n }\n\n return Number(firstHalf.join('')) + Number(lastHalf.join(''));\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/split_string_in_balanced_strings/split_string_in_balanced_strings.py",
"content": "# https://leetcode.com/problems/split-a-string-in-balanced-strings/\n\n\ndef balanced_string_split(s):\n els = 0\n ares = 0\n max = 0\n\n for char in s:\n if char == 'L':\n els += 1\n else:\n ares += 1\n\n if els == ares:\n max += 1\n els = 0\n ares = 0\n\n return max\n"
},
{
"path": "coding_interviews/leetcode/easy/squares-of-a-sorted-array/squares-of-a-sorted-array-on.js",
"content": "function buildArray(n) {\n const list = [];\n\n for (let i = 1; i <= n; i++) {\n list.push(0);\n }\n\n return list;\n}\n\nfunction sortedSquares(nums) {\n let sortedSquaresNumbers = buildArray(0);\n let leftIndex = 0;\n let rightIndex = nums.length - 1;\n let pointer = nums.length - 1;\n\n while (leftIndex <= rightIndex) {\n let left = nums[leftIndex];\n let right = nums[rightIndex];\n\n if (Math.abs(left) > Math.abs(right)) {\n sortedSquaresNumbers[pointer] = Math.pow(left, 2);\n leftIndex++;\n } else {\n sortedSquaresNumbers[pointer] = Math.pow(right, 2);\n rightIndex--;\n }\n\n pointer--;\n }\n\n return sortedSquaresNumbers;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/squares-of-a-sorted-array/squares-of-a-sorted-array.js",
"content": "function square(num) {\n return num * num;\n}\n\nfunction byIncreasingOrder(num1, num2) {\n return num1 - num2;\n}\n\nfunction sortedSquares(nums) {\n return nums.map(square).sort(byIncreasingOrder);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/squares_of_a_sorted_array/squares_of_a_sorted_array.py",
"content": "# https://leetcode.com/problems/squares-of-a-sorted-array\n\n'''\nGiven an array of integers A sorted in non-decreasing order,\nreturn an array of the squares of each number, also in sorted non-decreasing order.\n\nExample 1:\nInput: [-4,-1,0,3,10]\nOutput: [0,1,9,16,100]\n\nExample 2:\nInput: [-7,-3,2,3,11]\nOutput: [4,9,9,49,121]\n'''\n\n\ndef squares_of_a_sorted_array(A):\n new_array = []\n\n for number in A:\n new_array.append(number * number)\n\n return sorted(new_array)\n\n\ndef squares_of_a_sorted_array_in_place(A):\n for index in range(len(A)):\n A[index] = A[index] * A[index]\n\n return sorted(A)\n\n\ndata_tests = [\n ([-4, -1, 0, 3, 10], [0, 1, 9, 16, 100]),\n ([-7, -3, 2, 3, 11], [4, 9, 9, 49, 121])\n]\n\nfor numbers, expected in data_tests:\n result = squares_of_a_sorted_array(numbers)\n print(result, result == expected)\n\n result = squares_of_a_sorted_array_in_place(numbers)\n print(result, result == expected)\n"
},
{
"path": "coding_interviews/leetcode/easy/str_str/str_str.py",
"content": "'''\nhttps://leetcode.com/problems/implement-strstr\nImplement strStr().\n\nReturn the index of the first occurrence of needle in haystack,\nor -1 if needle is not part of haystack.\n\n- Example 1:\n\nInput: haystack = \"hello\", needle = \"ll\"\nOutput: 2\n\n- Example 2:\n\nInput: haystack = \"aaaaa\", needle = \"bba\"\nOutput: -1\n'''\n\n\ndef strStr(haystack, needle):\n if needle == '':\n return 0\n\n neddle_length = len(needle)\n\n for index in range(len(haystack) - neddle_length + 1):\n if haystack[index:index+neddle_length] == needle:\n return index\n\n return -1\n\n\ntest_data = [\n (\"hello\", \"ll\", 2),\n (\"aaaaa\", \"bba\", -1),\n (\"other\", \"\", 0),\n]\n\nfor haystack, needle, expected in test_data:\n result = strStr(haystack, needle)\n print('result as expected?', result == expected)\n"
},
{
"path": "coding_interviews/leetcode/easy/string-matching-in-an-array/string-matching-in-an-array.js",
"content": "function isSubstring(subword, word) {\n for (let index = 0; index <= word.length - subword.length; index++) {\n if (subword === word.slice(index, index + subword.length)) {\n return true;\n }\n }\n\n return false;\n}\n\nfunction addSubstring(word1, word2, answer) {\n if (word1.length <= word2.length) {\n isSubstring(word1, word2) && answer.add(word1);\n } else {\n isSubstring(word2, word1) && answer.add(word2);\n }\n}\n\nfunction stringMatching(words) {\n let answer = new Set([]);\n\n for (let i = 0; i < words.length - 1; i++) {\n for (let j = i + 1; j < words.length; j++) {\n let word1 = words[i];\n let word2 = words[j];\n addSubstring(word1, word2, answer);\n }\n }\n\n return [...answer];\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/subarrays-distinct-element-sum-of-squares-i/subarrays-distinct-element-sum-of-squares-i.js",
"content": "// https://leetcode.com/problems/subarrays-distinct-element-sum-of-squares-i\n\nfunction sumCounts(nums) {\n let sum = 0;\n\n for (let i = 0; i < nums.length; i++) {\n let set = new Set();\n\n for (let j = i; j < nums.length; j++) {\n set.add(nums[j]);\n sum += set.size ** 2;\n }\n }\n\n return sum;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/subdomain_visit_count.py",
"content": "'''\nhttps://leetcode.com/problems/subdomain-visit-count/description/\n\nExample 1:\nInput: [\"9001 discuss.leetcode.com\"]\nOutput: [\"9001 discuss.leetcode.com\", \"9001 leetcode.com\", \"9001 com\"]\n\nExample 2:\nInput: [\"900 google.mail.com\", \"50 yahoo.com\", \"1 intel.mail.com\", \"5 wiki.org\"]\nOutput: [\"901 mail.com\", \"50 yahoo.com\", \"900 google.mail.com\", \"5 wiki.org\",\"5 org\", \"1 intel.mail.com\", \"951 com\"]\n'''\n\ndef update_subdomain_counter(sc, s, c):\n if s in sc:\n sc[s] += int(c)\n else:\n sc[s] = int(c)\n\ndef subdomain_visits(cpdomains):\n subdomain_counter = {}\n\n for cpdomain in cpdomains:\n code, subdomain = cpdomain.split(' ')\n update_subdomain_counter(subdomain_counter, subdomain, code)\n\n while subdomain.find(\".\") != -1:\n subdomain = subdomain.split('.', 1)[1]\n update_subdomain_counter(subdomain_counter, subdomain, code)\n\n return [str(counter) + \" \" + subdomain for subdomain, counter in subdomain_counter.items()]\n\nprint(subdomain_visits([\"9001 discuss.leetcode.com\"]))\nprint(subdomain_visits([\"900 google.mail.com\", \"50 yahoo.com\", \"1 intel.mail.com\", \"5 wiki.org\"]))\n"
},
{
"path": "coding_interviews/leetcode/easy/substrings-of-size-three-with-distinct-characters/substrings-of-size-three-with-distinct-characters.js",
"content": "function isGoodString(string) {\n let [char1, char2, char3] = string;\n return char1 !== char2 && char1 !== char3 && char2 !== char3;\n}\n\nfunction countGoodSubstrings(string) {\n let goodSubstringsCounter = 0;\n\n for (let index = 0; index < string.length - 2; index++) {\n const substring = string.slice(index, index + 3);\n\n if (isGoodString(substring)) {\n goodSubstringsCounter++;\n }\n }\n\n return goodSubstringsCounter;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/subtract_product_and_sum/subtract_product_and_sum.py",
"content": "# https://leetcode.com/problems/subtract-the-product-and-sum-of-digits-of-an-integer\n\n'''\nGiven an integer number n, return the difference between the product of its\ndigits and the sum of its digits.\n\nInput: n = 234\nOutput: 15\n\nInput: n = 4421\nOutput: 21\n'''\n\n\ndef subtract_product_and_sum(num):\n multiplications = 1\n additions = 0\n\n for digit in str(num):\n multiplications *= int(digit)\n additions += int(digit)\n\n return multiplications - additions\n\n\ndata_tests = [\n (234, 15),\n (4421, 21)\n]\n\n\nfor num, expected in data_tests:\n result = subtract_product_and_sum(num)\n print(result, result == expected)\n"
},
{
"path": "coding_interviews/leetcode/easy/subtree-of-another-tree/subtree-of-another-tree.js",
"content": "function isSame(root, subRoot) {\n if (!root && !subRoot) return true;\n if (!root || !subRoot || root.val !== subRoot.val) return false;\n return isSame(root.left, subRoot.left) && isSame(root.right, subRoot.right);\n}\n\nfunction isSubtree(root, subRoot) {\n return root\n ? isSame(root, subRoot) ||\n isSubtree(root.left, subRoot) ||\n isSubtree(root.right, subRoot)\n : false;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/sum-multiples/sum-multiples.js",
"content": "function sumOfMultiples(n) {\n let sum = 0;\n\n for (let num = 1; num <= n; num++) {\n if (num % 7 === 0 || num % 5 === 0 || num % 3 === 0) {\n sum += num;\n }\n }\n\n return sum;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/sum-of-all-subset-xor-totals/sum-of-all-subset-xor-totals.js",
"content": "function getAllSubsets(subset, nums, output, index) {\n if (index == nums.length) {\n subset.push(output);\n return;\n }\n\n getAllSubsets(subset, nums, [...output], index + 1);\n output.push(nums[index]);\n getAllSubsets(subset, nums, [...output], index + 1);\n}\n\nfunction calculateTotalXOR(nums) {\n let totalXOR = nums[0];\n\n for (let i = 1; i < nums.length; i++) {\n totalXOR = totalXOR ^ nums[i];\n }\n\n return totalXOR;\n}\n\nfunction subsetXORSum(nums) {\n let total = 0;\n let subset = [];\n\n getAllSubsets(subset, nums, [], 0);\n\n for (let list of subset) {\n if (list.length) total += calculateTotalXOR(list);\n }\n\n return total;\n}\n\nconsole.log(subsetXORSum([1, 2, 3]));\n"
},
{
"path": "coding_interviews/leetcode/easy/sum-of-digits-in-base-k/sum-of-digits-in-base-k.js",
"content": "function fromDecimalToK(n, k) {\n const baseKN = [];\n\n while (n) {\n baseKN.push(n % k);\n n = Math.floor(n / k);\n }\n\n return baseKN;\n}\n\nfunction sumBase(n, k) {\n return fromDecimalToK(n, k).reduce((num, sum) => sum + num, 0);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/sum-of-digits-of-string-after-convert/sum-of-digits-of-string-after-convert.js",
"content": "function toNum(char) {\n return char.charCodeAt() - 96;\n}\n\nfunction getNumbers(s) {\n let numbers = [];\n\n for (let char of s) {\n numbers.push(toNum(char));\n }\n\n return numbers;\n}\n\nfunction sum(charNums) {\n return charNums.reduce(\n (sumOfNums, charNum) => sumOfNums + Number(charNum),\n 0\n );\n}\n\nfunction getLucky(s, k) {\n let numbers = getNumbers(s);\n let digits = numbers.join('').split('');\n\n for (let index = 1; index <= k; index++) {\n digits = sum(digits).toString().split('');\n }\n\n return Number(digits.join(''));\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/sum-of-left-leaves/sum-of-left-leaves.js",
"content": "function sumOfLeftLeaves(root, isLeft = false) {\n if (!root) return 0;\n if (!root.left && !root.right && isLeft) return root.val;\n return sumOfLeftLeaves(root.left, true) + sumOfLeftLeaves(root.right, false);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/sum-of-squares-of-special-elements/sum-of-squares-of-special-elements.js",
"content": "// https://leetcode.com/problems/sum-of-squares-of-special-elements\n\nfunction sumOfSquares(nums) {\n let sum = 0;\n\n for (let i = 1; i <= nums.length; i++) {\n if (nums.length % i === 0) {\n sum += nums[i - 1] * nums[i - 1];\n }\n }\n\n return sum;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/sum-of-values-at-indices-with-k-set-bits/sum-of-values-at-indices-with-k-set-bits.js",
"content": "function toBinary(num) {\n if (num === 0) return '0';\n\n let binary = [];\n\n while (num > 0) {\n binary.unshift(num % 2);\n num = Math.floor(num / 2);\n }\n\n return binary.join('');\n}\n\nfunction checkSetBits(binary, k) {\n let countSetBits = 0;\n\n for (let digit of binary) {\n if (digit === '1') countSetBits++;\n }\n\n return countSetBits === k;\n}\n\nfunction sumIndicesWithKSetBits(nums, k) {\n let sum = 0;\n\n for (let index = 0; index < nums.length; index++) {\n let binary = toBinary(index);\n console.log(index, binary);\n let matchesKSetBits = checkSetBits(binary, k);\n if (matchesKSetBits) {\n sum += nums[index];\n }\n }\n\n return sum;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/sum_leaf_binary_numbers/sum_leaf_binary_numbers.py",
"content": "# https://leetcode.com/problems/sum-of-root-to-leaf-binary-numbers\n\ntotal_binary_sum = 0\n\ndef sum_root_to_leaf(root):\n if root is None: return\n helper(root, str(root.val))\n return total_binary_sum\n \ndef helper(node, path):\n if node.left:\n helper(node.left, path + str(node.left.val))\n \n if node.right:\n helper(node.right, path + str(node.right.val))\n\n if node.right is None and node.left is None:\n total_binary_sum += int(path, 2)\n\n"
},
{
"path": "coding_interviews/leetcode/easy/sum_of_all_odd_length_subarrays/sum_of_all_odd_length_subarrays.py",
"content": "# https://leetcode.com/problems/sum-of-all-odd-length-subarrays\n\n'''\nTime complexity: O(O*A*S) or O(N^3) to simplify, where O = number of odd numbers, A = length of arr, and S = sum of the subarrays\nSpace complexity: O(1)\n'''\n\ndef sum_odd_length_subarrays(arr):\n odd, sum_of_subarrays = 1, 0\n \n while (odd <= len(arr)):\n for index in range(0, len(arr) - odd + 1):\n sum_of_subarrays += sum(arr[index:index+odd])\n \n odd += 2\n \n return sum_of_subarrays\n\n'''\nTime complexity: O(N)\nSpace complexity: O(1)\n'''\n\ndef sum_odd_length_subarrays_optimized(A):\n sum_of_subarrays, length_of_A = 0, len(A)\n\n for index, num in enumerate(A):\n sum_of_subarrays += ((index + 1) * (length_of_A - index) + 1) // 2 * num\n\n return sum_odd_length_subarrays\n"
},
{
"path": "coding_interviews/leetcode/easy/sum_of_unique_elements/sum_of_unique_elements.py",
"content": "# https://leetcode.com/problems/sum-of-unique-elements\n\n\ndef sum_of_unique(nums):\n mapper = {}\n \n for num in nums:\n if num in mapper:\n mapper[num] += 1\n else:\n mapper[num] = 1\n \n sum_of_unique_nums = 0\n \n for key in mapper:\n if mapper[key] == 1:\n sum_of_unique_nums += key\n \n return sum_of_unique_nums"
},
{
"path": "coding_interviews/leetcode/easy/sum_zero/sum_zero.py",
"content": "def sum_zero(n):\n zero_sum_array = []\n counter = 1\n\n if n % 2 != 0:\n zero_sum_array.append(0)\n n -= 1\n\n while n:\n zero_sum_array.append(counter)\n zero_sum_array.append(-counter)\n counter += 1\n n -= 2\n\n return zero_sum_array\n"
},
{
"path": "coding_interviews/leetcode/easy/symmetric-tree/symmetric-tree.js",
"content": "function symmetricNodes(node1, node2) {\n if ((!node1 && node2) || (node1 && !node2)) {\n return false;\n }\n\n if (!node1 && !node2) {\n return true;\n }\n\n return (\n node1.val === node2.val &&\n symmetricNodes(node1.left, node2.right) &&\n symmetricNodes(node1.right, node2.left)\n );\n}\n\nfunction isSymmetric(root) {\n if (!root) {\n return true;\n }\n\n return symmetricNodes(root.left, root.right);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/take-gifts-from-the-richest-pile/take-gifts-from-the-richest-pile.js",
"content": "function pickGifts(gifts, k) {\n while (k--) {\n let maxIndex = -Infinity;\n let max = -Infinity;\n\n for (let index = 0; index < gifts.length; index++) {\n if (gifts[index] > max) {\n maxIndex = index;\n max = gifts[index];\n }\n }\n\n gifts[maxIndex] = Math.floor(Math.sqrt(gifts[maxIndex]));\n }\n\n return gifts.reduce((sum, gift) => sum + gift, 0);\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/three-consecutive-odds/three-consecutive-odds.js",
"content": "function threeConsecutiveOdds(nums) {\n let counter = 0;\n\n for (let num of nums) {\n if (num % 2 === 0) counter = 0;\n else counter++;\n if (counter >= 3) return true;\n }\n\n return false;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/time-needed-to-buy-tickets/time-needed-to-buy-tickets.js",
"content": "function timeRequiredToBuy(tickets, k) {\n let count = 0;\n let pointer = 0;\n\n while (tickets[k]) {\n if (tickets[pointer]) {\n tickets[pointer]--;\n count++;\n }\n\n pointer = (pointer + 1) % tickets.length;\n }\n\n return count;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/to_lower_case/to_lower_case.py",
"content": "# https://leetcode.com/problems/to-lower-case/\n\n'''\nImplement function ToLowerCase() that has a string parameter str,\nand returns the same string in lowercase.\n\nExample 1:\nInput: \"Hello\"\nOutput: \"hello\"\n\nExample 2:\nInput: \"here\"\nOutput: \"here\"\n\nExample 3:\nInput: \"LOVELY\"\nOutput: \"lovely\"\n'''\n\n\ndef lower_case_char(char):\n if ord(char) >= 65 and ord(char) <= 90:\n return chr(ord(char) + 32)\n\n return char\n\n\ndef lower_case(str):\n list_of_chars = []\n\n for char in str:\n list_of_chars.append(lower_case_char(char))\n\n return ''.join(list_of_chars)\n\n\ndata_tests = [\n ('Hello', 'hello'),\n ('here', 'here'),\n ('LOVELY', 'lovely'),\n ('al&phaBET', 'al&phabet')\n]\n\nfor string, expected in data_tests:\n result = lower_case(string)\n print(result, expected == result)\n"
},
{
"path": "coding_interviews/leetcode/easy/toeplitz-matrix/toeplitz-matrix.js",
"content": "function isDiagonalToeplitz(matrix, value, row, col) {\n if (row >= matrix.length || col >= matrix[row].length) return true;\n if (value !== matrix[row][col]) return false;\n return isDiagonalToeplitz(matrix, matrix[row][col], row + 1, col + 1);\n}\n\nfunction isToeplitzMatrix(matrix) {\n for (let row = 0; row < matrix.length - 1; row++) {\n for (let col = 0; col < matrix[row].length - 1; col++) {\n if (!isDiagonalToeplitz(matrix, matrix[row][col], row + 1, col + 1))\n return false;\n }\n }\n\n return true;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/transpose-matrix/transpose-matrix.js",
"content": "function transpose(matrix) {\n let newMatrix = [];\n\n for (let col = 0; col < matrix[0].length; col++) {\n let newRow = [];\n\n for (let row = 0; row < matrix.length; row++) {\n newRow.push(matrix[row][col]);\n }\n\n newMatrix.push(newRow);\n }\n\n return newMatrix;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/truncate_sentence/truncate_sentence.py",
"content": "# https://leetcode.com/problems/truncate-sentence\n\ndef truncate_sentence(s, k):\n start_index, end_index, words = 0, 0, []\n\n for index, char in enumerate(s):\n end_index = index\n\n if char == ' ':\n words.append(s[start_index:end_index])\n start_index = index + 1\n \n words.append(s[start_index:])\n \n truncated_words = []\n \n for word in words[:k]:\n truncated_words.append(word)\n\n return ' '.join(truncated_words)\n\ndef truncate_sentence(s, k):\n start_index, end_index, words = 0, 0, []\n \n for index, char in enumerate(s):\n end_index = index\n\n if char == ' ':\n words.append(s[start_index:end_index])\n start_index = index + 1\n \n words.append(s[start_index:])\n \n return ' '.join(words[:k])\n\ndef truncate_sentence(s, k):\n return ' '.join(s.split(' ')[0:k])\n"
},
{
"path": "coding_interviews/leetcode/easy/two-furthest-houses-with-different-colors/two-furthest-houses-with-different-colors.js",
"content": "function maxDistance(colors) {\n let startPointer = 0;\n let endPointer = colors.length - 1;\n let maximumDistance = -Infinity;\n\n while (endPointer > startPointer) {\n if (colors[startPointer] !== colors[endPointer]) {\n maximumDistance = endPointer - startPointer;\n break;\n }\n\n endPointer--;\n }\n\n endPointer = colors.length - 1;\n\n while (startPointer < endPointer) {\n if (\n colors[startPointer] !== colors[endPointer] &&\n endPointer - startPointer > maximumDistance\n ) {\n maximumDistance = endPointer - startPointer;\n break;\n }\n\n startPointer++;\n }\n\n return maximumDistance;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/two-out-of-three/two-out-of-three.js",
"content": "function buildHashmap(nums) {\n let hashmap = new Map();\n\n for (let num of nums) {\n hashmap.set(num, true);\n }\n\n return hashmap;\n}\n\nfunction checkAndAddNumbers(result, hashmap1, hashmap2, hashmap3) {\n hashmap1.forEach((_, num) => {\n if (hashmap2.has(num) || hashmap3.has(num)) {\n result.add(num);\n }\n });\n}\n\nfunction twoOutOfThree(nums1, nums2, nums3) {\n let hashmap1 = buildHashmap(nums1);\n let hashmap2 = buildHashmap(nums2);\n let hashmap3 = buildHashmap(nums3);\n let result = new Set();\n\n checkAndAddNumbers(result, hashmap1, hashmap2, hashmap3);\n checkAndAddNumbers(result, hashmap2, hashmap1, hashmap3);\n checkAndAddNumbers(result, hashmap3, hashmap2, hashmap1);\n\n return [...result];\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/two-sum/two-sum.js",
"content": "function twoSum(nums, target) {\n let numbersMap = {};\n\n for (let [index, num] of nums.entries()) {\n numbersMap[num] = index;\n }\n\n for (let [index, num] of nums.entries()) {\n let remainder = target - num;\n let remainderIndex = numbersMap[remainder];\n\n if (remainderIndex && index !== remainderIndex) {\n return [index, remainderIndex];\n }\n }\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/two-sum-iv-input-is-a-bst/two-sum-iv-input-is-a-bst.js",
"content": "function dfs(node, hashmap, values) {\n if (!node) {\n return node;\n }\n\n hashmap[node.val] = true;\n values.push(node.val);\n\n dfs(node.left, hashmap, values);\n dfs(node.right, hashmap, values);\n}\n\nfunction findTarget(root, k) {\n let hashmap = {};\n let values = [];\n\n dfs(root, hashmap, values);\n\n for (let value of values) {\n if (hashmap[k - value] && k - value !== value) {\n return true;\n }\n }\n\n return false;\n}\n\n// second try with better memory usage\n\nfunction dfs2(node, target, hashmap) {\n if (!node) {\n return false;\n }\n\n if (hashmap[target - node.val]) {\n return true;\n }\n\n hashmap[node.val] = true;\n\n return dfs2(node.left, target, hashmap) || dfs2(node.right, target, hashmap);\n}\n\nfunction findTarget2(root, k) {\n return dfs2(root, k, {});\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/two_sum.py",
"content": "# https://leetcode.com/problems/two-sum/description/\n\ndef two_sum(nums, target):\n for i in range(len(nums)):\n for j in range(i+1, len(nums)):\n if nums[i] + nums[j] == target:\n return [i, j]\n"
},
{
"path": "coding_interviews/leetcode/easy/uncommon-words-from-two-sentences/uncommon-words-from-two-sentences.js",
"content": "function buildCounter(sentence) {\n let counter = new Map();\n\n for (let word of sentence) {\n if (counter.has(word)) counter.set(word, counter.get(word) + 1);\n else counter.set(word, 1);\n }\n\n return counter;\n}\n\nfunction getOnceWords(counter) {\n const onceWords = [];\n\n for (let [word, count] of counter) {\n if (count === 1) onceWords.push(word);\n }\n\n return onceWords;\n}\n\nfunction getUncommonWords(onceWords, map) {\n return onceWords.filter((onceWord) => !map.has(onceWord));\n}\n\nfunction uncommonFromSentences(s1, s2) {\n const list1 = s1.split(' ');\n const list2 = s2.split(' ');\n const counter1 = buildCounter(list1);\n const counter2 = buildCounter(list2);\n const onceWords1 = getOnceWords(counter1);\n const onceWords2 = getOnceWords(counter2);\n\n return [\n ...getUncommonWords(onceWords1, counter2),\n ...getUncommonWords(onceWords2, counter1),\n ];\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/unique-number-of-occurrences/unique-number-of-occurrences.js",
"content": "function uniqueOccurrences(arr) {\n const hashmap = new Map();\n\n for (let num of arr) {\n if (hashmap.has(num)) {\n hashmap.set(num, hashmap.get(num) + 1);\n } else {\n hashmap.set(num, 1);\n }\n }\n\n const counts = [];\n\n hashmap.forEach((count, num) => {\n counts.push(count);\n });\n\n return counts.length === new Set(counts).size;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/unique_morse_code_words.py",
"content": "# https://leetcode.com/problems/unique-morse-code-words/description/\n\n# \"gin\" -> \"--...-.\"\n# \"zen\" -> \"--...-.\"\n# \"gig\" -> \"--...--.\"\n# \"msg\" -> \"--...--.\"\n\ndef unique_morse_representations(words):\n morse = [\".-\",\"-...\",\"-.-.\",\"-..\",\".\",\"..-.\",\"--.\",\"....\",\"..\",\".---\",\"-.-\",\".-..\",\"--\",\"-.\",\"---\",\".--.\",\"--.-\",\".-.\",\"...\",\"-\",\"..-\",\"...-\",\".--\",\"-..-\",\"-.--\",\"--..\"]\n alphabet = 'abcdefghijklmnopqrstuvwxyz'\n\n morse_code_mapper = {}\n\n for index, letter in enumerate(alphabet):\n morse_code_mapper[letter] = morse[index]\n\n unique_codes = set()\n\n for word in words:\n code = ''\n\n for letter in word:\n code += morse_code_mapper[letter]\n\n unique_codes.add(code)\n\n return len(unique_codes)\n\nprint(unique_morse_representations([\"gin\", \"zen\", \"gig\", \"msg\"]) == 2)\n"
},
{
"path": "coding_interviews/leetcode/easy/unique_number_of_occurrences/unique_number_of_occurrences.py",
"content": "# https://leetcode.com/problems/unique-number-of-occurrences\n\ndef unique_occurrences(arr):\n num_to_occurrences = {}\n \n for num in arr:\n if num in num_to_occurrences:\n num_to_occurrences[num] += 1\n else:\n num_to_occurrences[num] = 1\n\n return len(num_to_occurrences) == len(set(num_to_occurrences.values()))\n\nfrom collections import Counter\n\ndef unique_occurrences_2(arr):\n num_to_occurrences = Counter(arr)\n return len(num_to_occurrences) == len(set(num_to_occurrences.values()))\n"
},
{
"path": "coding_interviews/leetcode/easy/univalued-binary-tree/univalued-binary-tree.js",
"content": "function isUnivalTree(root) {\n if (!root) return true;\n\n const leftResult = isUnivalTree(root.left);\n const rightResult = isUnivalTree(root.right);\n\n let result = true;\n\n result = root.left ? root.val === root.left.val : result;\n result = root.right ? result && root.val === root.right.val : result;\n\n return result && leftResult && rightResult;\n}\n\nfunction isUnivalTree(root, value = root.val) {\n if (!root) return true;\n return (\n root.val === value &&\n isUnivalTree(root.left, value) &&\n isUnivalTree(root.right, value)\n );\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/valid-anagram/valid-anagram.js",
"content": "function isAnagram(s, t) {\n if (s.length !== t.length) {\n return false;\n }\n\n let charCount = {};\n\n for (let index = 0; index < s.length; index++) {\n let char = s[index];\n\n if (charCount[char]) {\n charCount[char]++;\n } else {\n charCount[char] = 1;\n }\n }\n\n for (let char of t) {\n if (charCount[char]) {\n charCount[char]--;\n } else {\n return false;\n }\n }\n\n return true;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/valid-palindrome/valid-palindrome-2.js",
"content": "function isPalindrome(s) {\n let string = s.toLowerCase().replace(/[^a-z0-9]/gi, '');\n let start = 0;\n let end = string.length - 1;\n\n while (start <= end) {\n if (string[start] !== string[end]) {\n return false;\n }\n\n start++;\n end--;\n }\n\n return true;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/valid-palindrome/valid-palindrome.js",
"content": "const alphanumeric = 'abcdefghijklmnopqrstuvwxyz0123456789';\n\nfunction downcase(string) {\n return string.toLowerCase();\n}\n\nfunction keepAlphanumeric(string) {\n let alphanumericOnlyString = [];\n\n for (let char of string) {\n if (alphanumeric.includes(char)) {\n alphanumericOnlyString.push(char);\n }\n }\n\n return alphanumericOnlyString.join('');\n}\n\nfunction isValidPalindrome(string) {\n let start = 0;\n let end = string.length - 1;\n\n while (start <= end) {\n if (string[start] !== string[end]) {\n return false;\n }\n\n start++;\n end--;\n }\n\n return true;\n}\n\nfunction isPalindrome(string) {\n return isValidPalindrome(keepAlphanumeric(downcase(string)));\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/valid-palindrome/valid_palindrome.py",
"content": "'''\nGiven a string, determine whether its palindrome if you are allowed to delete at most one character\n\nExample\n\"aba\" - True\n\"abca\" - True\n\"abccadsfa\" - False\n\"\" - True\n\n\"abca\" 0 => \"bca\"\n\"abca\" 1 => \"aca\"\n'''\n\n# Brute force\n\n\ndef is_palindrome(string):\n return string == string[::-1]\n\n\ndef build_new_string_variation(string, index):\n return string[:index] + string[index+1:]\n\n\ndef valid_palindrome(string):\n if string == '':\n return True\n\n if is_palindrome(string):\n return True\n\n for index in range(len(string)):\n new_string = build_new_string_variation(string, index)\n if is_palindrome(new_string):\n return True\n\n return False\n\n\ndata = [\n (\"aba\", True),\n (\"abca\", True),\n (\"abccadsfa\", False),\n (\"\", True)\n]\n\nfor string, expected in data:\n result = valid_palindrome(string)\n print(result == expected)\n\n\n# Greedy Solution: find if it is not palindrome\ndef valid_palindrome_2(string):\n if string == '':\n return True\n\n if is_palindrome(string):\n return True\n\n for i in range(len(string) // 2):\n last_current_index = len(string) - 1 - i\n\n if string[i] != string[last_current_index]:\n string_shifted_to_left = string[i:last_current_index]\n string_shifted_to_right = string[i + 1:last_current_index + 1]\n return is_palindrome(string_shifted_to_left) or is_palindrome(string_shifted_to_right)\n\n return True\n\n\ndata = [\n (\"aba\", True),\n (\"abc\", False),\n (\"abca\", True),\n (\"abccadsfa\", False),\n (\"\", True)\n]\n\nfor string, expected in data:\n result = valid_palindrome_2(string)\n print(result == expected)\n"
},
{
"path": "coding_interviews/leetcode/easy/valid-parentheses/valid-parentheses.js",
"content": "function matches(openBracket, closingBracket) {\n return (\n {\n '}': '{',\n ']': '[',\n ')': '(',\n }[closingBracket] === openBracket\n );\n}\n\nfunction isValid(s) {\n if (s.length === 1) {\n return false;\n }\n\n const stack = [];\n\n for (let char of s) {\n if (['(', '{', '['].includes(char)) {\n stack.push(char);\n } else {\n let top = stack.pop();\n\n if (!matches(top, char)) {\n return false;\n }\n }\n }\n\n return stack.length === 0;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/water-bottles/water-bottles.js",
"content": "function numWaterBottles(numBottles, numExchange) {\n let drinkNum = numBottles;\n\n while (numBottles >= numExchange) {\n let remainingBottles = numBottles % numExchange;\n let newBottles = Math.floor(numBottles / numExchange);\n drinkNum += newBottles;\n numBottles = remainingBottles + newBottles;\n }\n\n return drinkNum;\n}\n"
},
{
"path": "coding_interviews/leetcode/easy/weakest_rows/weakest_rows.py",
"content": "# https://leetcode.com/problems/the-k-weakest-rows-in-a-matrix\n\ndef k_weakest_rows(mat, k):\n sum_index_list = [[sum(row), index] for index, row in enumerate(mat)]\n return [sum_index[1] for sum_index in sorted(sum_index_list)][:k]"
},
{
"path": "coding_interviews/leetcode/easy/xor-operation-in-an-array/xor-operation-in-an-array.js",
"content": "function xorOperation(n, start) {\n let result = start;\n let number = start;\n\n for (let num = 1; num < n; num++) {\n number += 2;\n result ^= number;\n }\n\n return result;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/3sum/3sum-tle.js",
"content": "function sortTriplet(num1, num2, num3) {\n return [num1, num2, num3].sort((n1, n2) => n1 - n2);\n}\n\nfunction getSortedTripletString(num1, num2, num3) {\n let triplet = sortTriplet(num1, num2, num3);\n return `${triplet[0]}*${triplet[1]}*${triplet[2]}`;\n}\n\nfunction threeSum(nums) {\n if (nums.length < 3) {\n return [];\n }\n\n let triplets = [];\n let numberCount = {};\n let usedTriplets = {};\n let usedPairs = {};\n\n for (let num of nums) {\n if (numberCount[num]) {\n numberCount[num]++;\n } else {\n numberCount[num] = 1;\n }\n }\n\n for (let i = 0; i < nums.length - 1; i++) {\n for (let j = i + 1; j < nums.length; j++) {\n let num1 = nums[i];\n let num2 = nums[j];\n let pairSum = num1 + num2;\n let missingTriplet = pairSum * -1;\n let sortedPairString = `${Math.min(num1, num2)}*${Math.max(num1, num2)}`;\n\n if (usedPairs[sortedPairString]) {\n continue;\n }\n\n let sortedTripletString = getSortedTripletString(\n num1,\n num2,\n missingTriplet\n );\n\n if (usedTriplets[sortedTripletString]) {\n continue;\n }\n\n if (\n (missingTriplet === num1 &&\n missingTriplet === num2 &&\n numberCount[missingTriplet] &&\n numberCount[missingTriplet] >= 3) ||\n (((missingTriplet === num1 && missingTriplet !== num2) ||\n (missingTriplet !== num1 && missingTriplet === num2)) &&\n numberCount[missingTriplet] &&\n numberCount[missingTriplet] >= 2) ||\n (missingTriplet !== num1 &&\n missingTriplet !== num2 &&\n numberCount[missingTriplet])\n ) {\n triplets.push([num1, num2, missingTriplet]);\n usedTriplets[sortedTripletString] = true;\n usedPairs[sortedPairString] = true;\n continue;\n }\n }\n }\n\n return triplets;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/add_two_numbers/add_two_numbers.py",
"content": "# https://leetcode.com/problems/add-two-numbers/description/\n\n'''\n(1, 2, 3) + (2, 3, 4) = (3, 5, 7)\n(1, 2, 3) + (2, 9, 4) = (3, 1, 8)\n'''\n\nclass ListNode(object):\n def __init__(self, x):\n self.val = x\n self.next = None\n\ndef add_two_numbers(l1, l2):\n carry = False\n result_list = r_list = ListNode(0)\n\n while l1 or l2 or carry:\n if l1 and l2:\n value = l1.val + l2.val\n l1 = l1.next\n l2 = l2.next\n elif l1:\n value = l1.val\n l1 = l1.next\n elif l2:\n value = l2.val\n l2 = l2.next\n else:\n value = 0\n\n if carry:\n value += 1\n carry = False\n\n if value >= 10:\n value -= 10\n carry = True\n\n r_list.next = ListNode(value)\n r_list = r_list.next\n\n return result_list.next\n\n# Test 1:\n\nl1 = ListNode(1)\nl1.next = ListNode(2)\nl = l1.next\nl.next = ListNode(3)\n\nl2 = ListNode(2)\nl2.next = ListNode(9)\nl = l2.next\nl.next = ListNode(4)\n\nresult_list = add_two_numbers(l1, l2)\n\nwhile result_list:\n print result_list.val\n result_list = result_list.next\n\nprint \"--------------------\"\n\n# Test 2:\n\nl1 = ListNode(5)\nl2 = ListNode(5)\n\nresult_list = add_two_numbers(l1, l2)\n\nwhile result_list:\n print result_list.val\n result_list = result_list.next\n"
},
{
"path": "coding_interviews/leetcode/medium/all_elements_in_two_binary_search_trees/all_elements_in_two_binary_search_trees.py",
"content": "# https://leetcode.com/problems/all-elements-in-two-binary-search-trees\n\n\ndef get_all_elements(root1, root2):\n values = []\n get_sorted_list(root1, values)\n get_sorted_list(root2, values)\n return sorted(values)\n\n\ndef get_sorted_list(node, values):\n if node.left:\n get_sorted_list(node.left, values)\n\n values.append(node.val)\n\n if node.right:\n get_sorted_list(node.right, values)\n\n# ---------------------------------------------------------------------\n\ndef get_sorted_elements_from(node):\n if not node:\n return []\n \n elements = []\n \n if node.left:\n elements = get_sorted_elements_from(node.left)\n \n elements.append(node.val)\n \n if node.right:\n elements += get_sorted_elements_from(node.right)\n \n return elements\n \n\ndef get_all_elements(root1, root2):\n sorted_tree_1 = get_sorted_elements_from(root1)\n sorted_tree_2 = get_sorted_elements_from(root2)\n \n index_1, index_2 = 0, 0\n result = []\n \n while index_1 < len(sorted_tree_1) and index_2 < len(sorted_tree_2):\n value1 = sorted_tree_1[index_1]\n value2 = sorted_tree_2[index_2]\n \n if value1 <= value2:\n result.append(value1)\n index_1 += 1\n else:\n result.append(value2)\n index_2 += 1\n \n if index_1 < len(sorted_tree_1):\n result += sorted_tree_1[index_1:]\n \n if index_2 < len(sorted_tree_2):\n result += sorted_tree_2[index_2:]\n \n return result\n\n# ---------------------------------------------------------------------\n\ndef get_sorted_elements_from(node, elements):\n if not node: return []\n if node.left: get_sorted_elements_from(node.left, elements)\n elements.append(node.val)\n if node.right: get_sorted_elements_from(node.right, elements) \n\ndef get_all_elements(root1, root2):\n sorted_tree_1 = []\n get_sorted_elements_from(root1, sorted_tree_1)\n \n sorted_tree_2 = []\n get_sorted_elements_from(root2, sorted_tree_2)\n \n index_1, index_2 = 0, 0\n result = []\n \n while index_1 < len(sorted_tree_1) and index_2 < len(sorted_tree_2):\n value1 = sorted_tree_1[index_1]\n value2 = sorted_tree_2[index_2]\n \n if value1 <= value2:\n result.append(value1)\n index_1 += 1\n else:\n result.append(value2)\n index_2 += 1\n \n if index_1 < len(sorted_tree_1):\n result += sorted_tree_1[index_1:]\n \n if index_2 < len(sorted_tree_2):\n result += sorted_tree_2[index_2:]\n \n return result"
},
{
"path": "coding_interviews/leetcode/medium/arithmetic-subarrays/arithmetic-subarrays.py",
"content": "# https://leetcode.com/problems/arithmetic-subarrays\n\ndef check_arithmetic_subarrays(nums, l, r):\n answer = []\n\n for index in range(len(l)):\n l_value = l[index]\n r_value = r[index]\n nums_range = sorted(nums[l_value:r_value+1])\n is_arithmetic = True\n diff = nums_range[1] - nums_range[0]\n \n for i in range(2, len(nums_range)):\n if diff != nums_range[i] - nums_range[i-1]:\n is_arithmetic = False\n break\n\n answer.append(is_arithmetic)\n \n return answer\n"
},
{
"path": "coding_interviews/leetcode/medium/balance-a-binary-search-tree/balance-a-binary-search-tree.js",
"content": "function inorder(root, nodes) {\n if (root.left) inorder(root.left, nodes);\n nodes.push(root.val);\n if (root.right) inorder(root.right, nodes);\n}\n\nfunction toBST(start, end, nodes) {\n if (start > end) return null;\n\n const middle = Math.floor((start + end) / 2);\n const bst = new TreeNode(nodes[middle]);\n\n bst.left = toBST(start, middle - 1, nodes);\n bst.right = toBST(middle + 1, end, nodes);\n\n return bst;\n}\n\nfunction balanceBST(root) {\n const nodes = [];\n inorder(root, nodes);\n return toBST(0, nodes.length - 1, nodes);\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/binary-tree-inorder-traversal/binary-tree-inorder-traversal.py",
"content": "# https://leetcode.com/problems/binary-tree-inorder-traversal\n\nclass Solution:\n def __init__(self):\n self.inorder_list = []\n\n def inorder_traversal(self, root):\n if root:\n self.inorder_traversal(root.left)\n self.inorder_list.append(root.val)\n self.inorder_traversal(root.right)\n\n return self.inorder_list"
},
{
"path": "coding_interviews/leetcode/medium/binary-tree-level-order-traversal/binary-tree-level-order-traversal.js",
"content": "function levelOrder(root) {\n if (!root) {\n return [];\n }\n\n let queue = [root];\n let levelOrderTree = [];\n\n while (queue.length) {\n let levelNodes = [];\n let levels = queue.length;\n\n for (let level = 0; level < levels; level++) {\n let node = queue.shift();\n\n if (node.left) {\n queue.push(node.left);\n }\n\n if (node.right) {\n queue.push(node.right);\n }\n\n levelNodes.push(node.val);\n }\n\n levelOrderTree.push(levelNodes);\n }\n\n return levelOrderTree;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/bst_from_pre_order_traversal/bst_from_pre_order_traversal.py",
"content": "class TreeNode:\n def __init__(self, val=0, left=None, right=None):\n self.val = val\n self.left = left\n self.right = right\n\n\ndef bst_from_preorder(preorder):\n root = TreeNode(preorder[0])\n\n for value in preorder[1:]:\n helper(root, value)\n\n return root\n\n\ndef helper(node, value):\n if value < node.val and node.left:\n helper(node.left, value)\n elif value < node.val:\n node.left = TreeNode(value)\n\n if value > node.val and node.right:\n helper(node.right, value)\n elif value > node.val:\n node.right = TreeNode(value)\n\n return node\n"
},
{
"path": "coding_interviews/leetcode/medium/bst_to_greatest/bst_to_greatest.py",
"content": "def sum_and_list(node, total, values):\n left_total = 0\n right_total = 0\n left_values = []\n right_values = []\n\n if node.left:\n [left_total, left_values] = sum_and_list(node.left, total, values)\n\n if node.right:\n [right_total, right_values] = sum_and_list(node.right, total, values)\n\n return [\n total + left_total + node.val + right_total,\n values + left_values + [node.val] + right_values\n ]\n\n\ndef modify_helper(node, mapper):\n if node.left:\n modify_helper(node.left, mapper)\n\n if node.right:\n modify_helper(node.right, mapper)\n\n node.val = mapper[node.val]\n return node\n\n\ndef bst_to_gst(root):\n [total, values] = sum_and_list(root, 0, [])\n\n smaller_total = 0\n mapper = {}\n\n for value in values:\n mapper[value] = total - smaller_total\n smaller_total += value\n\n return modify_helper(root, mapper)\n\n\nvalue = 0\n\n\ndef bst_to_gst(node):\n if node.right:\n bst_to_gst(node.right)\n\n node.val = node.val + value\n value = node.val\n\n if node.left:\n bst_to_gst(node.left)\n\n return node\n"
},
{
"path": "coding_interviews/leetcode/medium/clone-graph/clone-graph.js",
"content": "/*\nCloning a graph using a Breadth-First Search\n— build a queue of all nodes in the graph\n— build a hashmap of all cloned nodes\n— if it's on the map: it's counted as visited & add to the neighbors' list \n— else create from scratch\n*/\n\nfunction cloneGraph(node) {\n if (!node) return;\n\n let clonedGraph = new Node(node.val);\n let queue = [node];\n let createdNodes = {\n 1: clonedGraph,\n };\n\n while (queue.length) {\n let currentNode = queue.shift();\n let clonedNode = createdNodes[currentNode.val];\n\n for (let neighbor of currentNode.neighbors) {\n if (createdNodes[neighbor.val]) {\n clonedNode.neighbors.push(createdNodes[neighbor.val]);\n } else {\n let createdNode = new Node(neighbor.val);\n createdNodes[neighbor.val] = createdNode;\n clonedNode.neighbors.push(createdNode);\n queue.push(neighbor);\n }\n }\n }\n\n return clonedGraph;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/cloned_binary_tree/cloned_binary_tree.py",
"content": "# https://leetcode.com/problems/find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree/\n\n\ndef get_target_copy(original, cloned, target):\n if cloned.val == target.val:\n return cloned\n\n if cloned.left:\n result = get_target_copy(original.left, cloned.left, target)\n\n if result:\n return result\n\n if cloned.right:\n result = get_target_copy(original.right, cloned.right, target)\n\n if result:\n return result\n"
},
{
"path": "coding_interviews/leetcode/medium/count-nodes-equal-to-average-of-subtree/count-nodes-equal-to-average-of-subtree.js",
"content": "function calculateAverage(totalValue, nodesCount) {\n return Math.floor(totalValue / nodesCount);\n}\n\nfunction averageHelper(node, count) {\n if (!node) {\n return { totalValue: 0, nodesCount: 0, equalToAverageCount: 0 };\n }\n\n const left = averageHelper(node.left, 1);\n const right = averageHelper(node.right, 1);\n\n const totalValue = node.val + left.totalValue + right.totalValue;\n const nodesCount = count + left.nodesCount + right.nodesCount;\n\n const average = calculateAverage(totalValue, nodesCount);\n\n const equalToAverageCount =\n (average === node.val ? 1 : 0) +\n left.equalToAverageCount +\n right.equalToAverageCount;\n\n return {\n totalValue,\n nodesCount,\n equalToAverageCount,\n };\n}\n\nfunction averageOfSubtree(root) {\n let totalValue = root.val;\n let nodesCount = 1;\n\n const left = averageHelper(root.left, nodesCount);\n const right = averageHelper(root.right, nodesCount);\n\n const average = calculateAverage(\n totalValue + left.totalValue + right.totalValue,\n nodesCount + left.nodesCount + right.nodesCount\n );\n\n return (\n (average === root.val ? 1 : 0) +\n left.equalToAverageCount +\n right.equalToAverageCount\n );\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/count-number-of-distinct-integers-after-reverse-operations/count-number-of-distinct-integers-after-reverse-operations-numbers.js",
"content": "// https://leetcode.com/problems/count-number-of-distinct-integers-after-reverse-operations\n\nfunction reverseDigits(num) {\n let digits = 0;\n\n while (num > 0) {\n digits = digits * 10 + (num % 10);\n num = Math.floor(num / 10);\n }\n\n return digits;\n}\n\nfunction countDistinctIntegers(nums) {\n let set = new Set();\n let N = nums.length;\n\n for (let index = 0; index < N; index++) {\n let num = nums[index];\n set.add(num);\n let reversedDigitsNum = reverseDigits(num);\n set.add(reversedDigitsNum);\n }\n\n return set.size;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/count-number-of-distinct-integers-after-reverse-operations/count-number-of-distinct-integers-after-reverse-operations.js",
"content": "// https://leetcode.com/problems/count-number-of-distinct-integers-after-reverse-operations\n\nfunction reverseDigits(num) {\n let digits = [];\n\n while (num > 0) {\n digits.push((num % 10).toString());\n num = Math.floor(num / 10);\n }\n\n return Number(digits.join(''));\n}\n\nfunction countDistinctIntegers(nums) {\n let set = new Set();\n let N = nums.length;\n\n for (let index = 0; index < N; index++) {\n let num = nums[index];\n set.add(num);\n let reversedDigitsNum = reverseDigits(num);\n set.add(reversedDigitsNum);\n }\n\n return set.size;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/count-sorted-vowel-strings/count-sorted-vowel-strings.js",
"content": "function countVowelStrings(n) {\n let a = 1,\n e = 1,\n i = 1,\n o = 1,\n u = 1;\n\n for (let counter = 1; counter < n; counter++) {\n o += u;\n i += o;\n e += i;\n a += e;\n }\n\n return a + e + i + o + u;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/count-sub-islands/count-sub-islands-tle.js",
"content": "/**\n- getting all islands in grid2\n - store the rows and columns of each island\n - this can be stored in a list\n - e.g. [[[3,0]], [[4,1]], [2,1]]\n- iterate through the list of islands of grid2\n - if all rows and cols from an island of grid2 match the cells in the grid1\n - increment the number of sub-islands\n- return number of sub islands\n*/\nfunction isInsideTheGrid(grid, row, col) {\n return row >= 0 && row < grid.length && col >= 0 && col < grid[0].length;\n}\n\nfunction dfs(grid, row, col) {\n if (!isInsideTheGrid(grid, row, col)) {\n return [];\n }\n\n if (grid[row][col]) {\n grid[row][col] = 0;\n\n return [\n [row, col],\n ...dfs(grid, row - 1, col),\n ...dfs(grid, row + 1, col),\n ...dfs(grid, row, col - 1),\n ...dfs(grid, row, col + 1),\n ];\n }\n\n return [];\n}\n\nfunction countSubIslands(grid1, grid2) {\n let islands = [];\n\n for (let row = 0; row < grid2.length; row++) {\n for (let col = 0; col < grid2[row].length; col++) {\n let cell = grid2[row][col];\n\n if (cell) {\n grid2[row][col] = 0;\n\n let island = [\n [row, col],\n ...dfs(grid2, row - 1, col),\n ...dfs(grid2, row + 1, col),\n ...dfs(grid2, row, col - 1),\n ...dfs(grid2, row, col + 1),\n ];\n\n islands.push(island);\n }\n }\n }\n\n let numberOfSubIslands = 0;\n\n for (let island of islands) {\n let isSubIsland = true;\n\n for (let [row, col] of island) {\n if (grid1[row][col] === 0) {\n isSubIsland = false;\n break;\n }\n }\n\n if (isSubIsland) {\n numberOfSubIslands++;\n }\n }\n\n return numberOfSubIslands;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/count-sub-islands/count-sub-islands.js",
"content": "function dfs(grid1, grid2, row, col) {\n if (\n row < 0 ||\n row >= grid2.length ||\n col < 0 ||\n col >= grid2[0].length ||\n grid2[row][col] == 0\n ) {\n return 1;\n }\n\n grid2[row][col] = 0;\n\n let numberOfSubIslands = 1;\n\n numberOfSubIslands &= dfs(grid1, grid2, row - 1, col);\n numberOfSubIslands &= dfs(grid1, grid2, row + 1, col);\n numberOfSubIslands &= dfs(grid1, grid2, row, col - 1);\n numberOfSubIslands &= dfs(grid1, grid2, row, col + 1);\n\n return numberOfSubIslands & grid1[row][col];\n}\n\nfunction countSubIslands(grid1, grid2) {\n let numberOfSubIslands = 0;\n\n for (let row = 0; row < grid2.length; row++) {\n for (let col = 0; col < grid2[row].length; col++) {\n if (grid2[row][col]) {\n numberOfSubIslands += dfs(grid1, grid2, row, col);\n }\n }\n }\n\n return numberOfSubIslands;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/count_points/count_points.py",
"content": "# https://leetcode.com/problems/queries-on-number-of-points-inside-a-circle\n\ndef is_point_within_circuference(qx, qy, qr, px, py):\n return qr ** 2 >= abs(qx - px) ** 2 + abs(qy - py) ** 2\n\ndef count_points(points, queries):\n answer = []\n \n for [qx, qy, qr] in queries:\n count = 0\n \n for [px, py] in points:\n if is_point_within_circuference(qx, qy, qr, px, py):\n count += 1\n\n answer.append(count)\n \n return answer\n"
},
{
"path": "coding_interviews/leetcode/medium/counter_number_of_teams/counter_number_of_teams.py",
"content": "def num_teams(rating):\n counter = 0\n\n for i in range(len(rating) - 2):\n for j in range(i + 1, len(rating) - 1):\n for k in range(j + 1, len(rating)):\n if (rating[i] < rating[j] and rating[j] < rating[k]) or (\n rating[i] > rating[j] and rating[j] > rating[k]):\n counter += 1\n\n return counter\n\n\ndef num_teams(rating):\n asc = desc = 0\n\n for index, value in enumerate(rating):\n llc = rgc = lgc = rlc = 0\n\n for left in rating[:index]:\n if left > value:\n lgc += 1\n if left < value:\n llc += 1\n\n for right in rating[index + 1:]:\n if right > value:\n rgc += 1\n if right < value:\n rlc += 1\n\n asc += llc * rgc\n desc += lgc * rlc\n\n return asc + desc\n"
},
{
"path": "coding_interviews/leetcode/medium/deck_revealed_increasing/deck_revealed_increasing.py",
"content": "# https://leetcode.com/problems/reveal-cards-in-increasing-order\n\nimport queue\n\ndef deck_revealed_increasing(deck):\n q = queue.Queue()\n sorted_deck = sorted(deck)\n \n for index in range(len(deck)): q.put(index)\n \n result = [0] * len(deck)\n index = 0\n\n while not q.empty():\n result[q.get()] = sorted_deck[index]\n index += 1\n if not q.empty(): q.put(q.get())\n \n return result\n"
},
{
"path": "coding_interviews/leetcode/medium/decode-string/decode-string.js",
"content": "const isNum = (char) => !isNaN(Number(char));\n\nexport function decodeString(encodedString) {\n const stack = [];\n let index = 0;\n\n while (index < encodedString.length) {\n const char = encodedString[index];\n\n if (isNum(char)) {\n const number = [];\n\n while (isNum(encodedString[index])) {\n number.push(encodedString[index]);\n index++;\n }\n\n stack.push(Number(number.join('')));\n continue;\n }\n\n if (char === ']') {\n let str = '';\n\n while (stack[stack.length - 1] !== '[') {\n str = stack.pop() + str;\n }\n\n stack.pop();\n stack.push(str.repeat(stack.pop()));\n index++;\n continue;\n }\n\n stack.push(char);\n index++;\n }\n\n return stack.join('');\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/decode-string/tests/decode-string.test.js",
"content": "import { describe, it, expect } from 'vitest';\nimport { decodeString } from '../decode-string';\n\ndescribe('decodeString', () => {\n it('', () => {\n expect(decodeString('3[a]2[bc]')).toEqual('aaabcbc');\n });\n\n it('', () => {\n expect(decodeString('2[abc]3[cd]ef')).toEqual('abcabccdcdcdef');\n });\n\n it('', () => {\n expect(decodeString('3[a2[c]]')).toEqual('accaccacc');\n });\n\n it('', () => {\n expect(decodeString('100[leetcode]')).toEqual(\n 'leetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcodeleetcode'\n );\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/medium/deepest_leaves_sum/deepest_leaves_sum.py",
"content": "# https://leetcode.com/problems/deepest-leaves-sum\n\n'''\nGiven a binary tree, return the sum of values of its deepest leaves.\n\nInput: root = [1,2,3,4,5,null,6,7,null,null,null,null,8]\nOutput: 15\n'''\n\n\ndef sum_deepest_leaves(root):\n mapper = helper(root, {}, 1)\n deepest_level = 1\n\n for level in mapper:\n if level > deepest_level:\n deepest_level = level\n\n deepest_level_nodes_values = mapper[deepest_level]\n\n nodes_values_sum = 0\n\n for node_value in deepest_level_nodes_values:\n nodes_values_sum += node_value\n\n return nodes_values_sum\n\n\ndef helper(node, mapper, level):\n if level in mapper:\n mapper[level] = mapper[level] + [node.val]\n else:\n mapper[level] = [node.val]\n\n if node.left:\n mapper = helper(node.left, mapper, level + 1)\n\n if node.right:\n mapper = helper(node.right, mapper, level + 1)\n\n return mapper\n"
},
{
"path": "coding_interviews/leetcode/medium/delete-node-in-a-linked-list/better-delete-node-in-a-linked-list.js",
"content": "// https://leetcode.com/problems/delete-node-in-a-linked-list\n\n/**\n * Definition for singly-linked list.\n * function ListNode(val) {\n * this.val = val;\n * this.next = null;\n * }\n * @param {ListNode} node\n * @return {void} Do not return anything, modify node in-place instead.\n */\nfunction deleteNode(node) {\n node.val = node.next.val;\n node.next = node.next.next;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/delete-node-in-a-linked-list/delete-node-in-a-linked-list.js",
"content": "// https://leetcode.com/problems/delete-node-in-a-linked-list\n\n/**\n * Definition for singly-linked list.\n * function ListNode(val) {\n * this.val = val;\n * this.next = null;\n * }\n * @param {ListNode} node\n * @return {void} Do not return anything, modify node in-place instead.\n */\nfunction deleteNode(node) {\n if (node.next && !node.next.next) {\n node.val = node.next.val;\n node.next = null;\n return;\n }\n\n node.val = node.next.val;\n deleteNode(node.next);\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/design-a-stack-with-increment-operation/design-a-stack-with-increment-operation.js",
"content": "export const CustomStack = function (maxSize) {\n this.maxSize = maxSize;\n this.items = [];\n};\n\nCustomStack.prototype.push = function (x) {\n if (this.items.length < this.maxSize) {\n this.items.push(x);\n }\n};\n\nCustomStack.prototype.pop = function () {\n return this.items.length > 0 ? this.items.pop() : -1;\n};\n\nCustomStack.prototype.increment = function (k, val) {\n for (let i = 0; i < k; i++) {\n if (i <= this.items.length - 1) this.items[i] += val;\n }\n};\n"
},
{
"path": "coding_interviews/leetcode/medium/design-a-stack-with-increment-operation/tests/design-a-stack-with-increment-operation.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport { CustomStack } from '../design-a-stack-with-increment-operation';\n\ndescribe('CustomStack', () => {\n it('', () => {\n const customStack = new CustomStack(3);\n\n customStack.push(1);\n customStack.push(2);\n\n expect(customStack.pop()).toEqual(2);\n\n customStack.push(2);\n customStack.push(3);\n customStack.push(4);\n\n customStack.increment(5, 100);\n customStack.increment(2, 100);\n\n expect(customStack.pop()).toEqual(103);\n expect(customStack.pop()).toEqual(202);\n expect(customStack.pop()).toEqual(201);\n expect(customStack.pop()).toEqual(-1);\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/medium/design-add-and-search-words-data-structure/design-add-and-search-words-data-structure.js",
"content": "function isTheSame(word, wordFromDict) {\n if (word.length !== wordFromDict.length) return false;\n\n for (let index = 0; index < word.length; index++) {\n let wordChar = word[index];\n let wordFromDictChar = wordFromDict[index];\n\n if (wordChar === '.') {\n continue;\n }\n\n if (wordChar !== wordFromDictChar) {\n return false;\n }\n }\n\n return true;\n}\n\nconst WordDictionary = function () {\n this.hashmap = {};\n};\n\nWordDictionary.prototype.addWord = function (word) {\n if (!this.hashmap[word]) {\n this.hashmap[word] = true;\n }\n};\n\nWordDictionary.prototype.search = function (word) {\n if (this.hashmap[word]) {\n return this.hashmap[word];\n }\n\n let words = Object.keys(this.hashmap);\n\n for (let wordFromDict of words) {\n if (isTheSame(word, wordFromDict)) {\n return true;\n }\n }\n\n return false;\n};\n"
},
{
"path": "coding_interviews/leetcode/medium/difference-between-ones-and-zeros-in-row-and-column/difference-between-ones-and-zeros-in-row-and-column.js",
"content": "function traverseGridRow(grid, row) {\n let diff = 0;\n\n for (let col = 0; col < grid[row].length; col++) {\n let cell = grid[row][col];\n\n if (cell) {\n diff++;\n } else {\n diff--;\n }\n }\n\n return diff;\n}\n\nfunction traverseGridCol(grid, col) {\n let diff = 0;\n\n for (let row = 0; row < grid.length; row++) {\n let cell = grid[row][col];\n\n if (cell) {\n diff++;\n } else {\n diff--;\n }\n }\n\n return diff;\n}\n\nfunction onesMinusZeros(grid) {\n let rows = [];\n let cols = [];\n let diffGrid = [];\n\n for (let row = 0; row < grid.length; row++) {\n let diffRow = [];\n\n for (let col = 0; col < grid[row].length; col++) {\n let rowDiff;\n let colDiff;\n\n if (row < rows.length) {\n rowDiff = rows[row];\n } else {\n rowDiff = traverseGridRow(grid, row);\n rows.push(rowDiff);\n }\n\n if (col < cols.length) {\n colDiff = cols[col];\n } else {\n colDiff = traverseGridCol(grid, col);\n cols.push(colDiff);\n }\n\n diffRow.push(rowDiff + colDiff);\n }\n\n diffGrid.push(diffRow);\n }\n\n return diffGrid;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/encode_and_decode_tinyurl/encode_and_decode_tinyurl.py",
"content": "# https://leetcode.com/problems/encode-and-decode-tinyurl\n\nclass Codec:\n count = 0\n tiny_to_url = {}\n url_to_tiny = {}\n tiny_url_prefix = 'http://tinyurl.com/'\n\n def encode(self, longUrl: str) -> str:\n if longUrl in self.url_to_tiny:\n return self.url_to_tiny[longUrl]\n\n tiny_url = self.tiny_url_prefix + str(self.count)\n self.url_to_tiny[longUrl] = tiny_url\n self.tiny_to_url[tiny_url] = longUrl\n self.count += 1\n return tiny_url\n\n def decode(self, shortUrl: str) -> str:\n return self.tiny_to_url[shortUrl]\n"
},
{
"path": "coding_interviews/leetcode/medium/execution-of-all-suffix-instructions-staying-in-a-grid/execution-of-all-suffix-instructions-staying-in-a-grid.js",
"content": "// https://leetcode.com/problems/execution-of-all-suffix-instructions-staying-in-a-grid\n\nfunction isOffGrid(row, col, n) {\n return row < 0 || row >= n || col < 0 || col >= n;\n}\n\nfunction executeInstructions(n, startPos, s) {\n let answer = [];\n\n for (let index = 0; index < s.length; index++) {\n let instructionIndex = index;\n let instruction = s[instructionIndex];\n let row = startPos[0];\n let col = startPos[1];\n let numOfInstructions = 0;\n\n if (instruction === 'R') col++;\n if (instruction === 'L') col--;\n if (instruction === 'U') row--;\n if (instruction === 'D') row++;\n\n while (instructionIndex < s.length && !isOffGrid(row, col, n)) {\n instructionIndex++;\n instruction = s[instructionIndex];\n if (instruction === 'R') col++;\n if (instruction === 'L') col--;\n if (instruction === 'U') row--;\n if (instruction === 'D') row++;\n numOfInstructions++;\n }\n\n answer.push(numOfInstructions);\n }\n\n return answer;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/find-the-original-array-of-prefix-xor/README.md",
"content": "# Find The Original Array of Prefix Xor\n\n[Problem link](https://leetcode.com/problems/find-the-original-array-of-prefix-xor)\n\n- If you want `5 ^ ? = 2`, you can do a reverse xor using `5 ^ 2 = ?`, which in this case `? = 7`\n- If you want to do consecutive XOR operations like `5 ^ 7 ^ 2 ^ 3 ^ 2`, you can replace that with the previous `pref` item\n - e.g. `5 ^ 7 ^ ? = 0.`, you want to find `?`\n - so you need to do `5 ^ 7 ^ 0 = ?` but at that point, if you don't store the previous result, you don't have `5 ^ 7`\n - but you can get this calculation from the previous `pref` item because it can replace `5 ^ 7`, in this case, it is `2`\n- Runtime complexity: O(N), where N is prev.length\n"
},
{
"path": "coding_interviews/leetcode/medium/find-the-original-array-of-prefix-xor/find-the-original-array-of-prefix-xor.js",
"content": "function findArray(pref) {\n let output = [pref[0]];\n\n for (let index = 1; index < pref.length; index++) {\n output.push(pref[index - 1] ^ pref[index]);\n }\n\n return output;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/find-the-winner-of-the-circular-game/find-the-winner-of-the-circular-game.js",
"content": "// https://leetcode.com/problems/find-the-winner-of-the-circular-game\n\nfunction toArray(n) {\n let list = [];\n\n for (let num = 1; num <= n; num++) {\n list.push(num);\n }\n\n return list;\n}\n\nfunction findTheWinner(n, k) {\n let list = toArray(n);\n let index = 0;\n\n while (list.length > 1) {\n index = (index + k - 1) % list.length;\n list.splice(index, 1);\n }\n\n return list[0];\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/find-the-winner-of-the-circular-game/queue-find-the-winner-of-the-circular-game.js",
"content": "// https://leetcode.com/problems/find-the-winner-of-the-circular-game\n\nfunction buildQueue(n) {\n let queue = [];\n\n for (let num = 1; num <= n; num++) {\n queue.push(num);\n }\n\n return queue;\n}\n\nfunction findTheWinner(n, k) {\n let queue = buildQueue(n);\n\n while (queue.length > 1) {\n let count = 1;\n\n while (count < k) {\n queue.push(queue.shift());\n count++;\n }\n\n queue.shift();\n }\n\n return queue[0];\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/find-triangular-sum-of-an-array/find-triangular-sum-of-an-array.js",
"content": "function calculate(num1, num2) {\n return (num1 + num2) % 10;\n}\n\nexport function triangularSum(nums) {\n let numsCopy = [...nums];\n let newNums = [];\n let N = nums.length;\n\n for (let i = 0; i < N - 1; i++) {\n newNums = [];\n\n for (let index = 0; index < numsCopy.length - 1; index++) {\n newNums.push(calculate(numsCopy[index], numsCopy[index + 1]));\n }\n\n numsCopy = newNums;\n }\n\n return numsCopy;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/find-triangular-sum-of-an-array/tests/find-triangular-sum-of-an-array.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport { triangularSum } from '../find-triangular-sum-of-an-array';\n\ndescribe('triangularSum', () => {\n it('', () => {\n expect(triangularSum([1, 2, 3, 4, 5])).toEqual([8]);\n });\n\n it('', () => {\n expect(triangularSum([5])).toEqual([5]);\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/medium/find-valid-matrix-given-row-and-column-sums/find-valid-matrix-given-row-and-column-sums.js",
"content": "function buildMatrix(rows, cols) {\n const matrix = [];\n\n for (let row = 0; row < rows; row++) {\n let matrixRow = [];\n\n for (let col = 0; col < cols; col++) {\n matrixRow.push(0);\n }\n\n matrix.push(matrixRow);\n }\n\n return matrix;\n}\n\nfunction restoreMatrix(rowSum, colSum) {\n const matrix = buildMatrix(rowSum.length, colSum.length);\n\n for (let row = 0; row < matrix.length; row++) {\n for (let col = 0; col < matrix[0].length; col++) {\n const min = Math.min(rowSum[row], colSum[col]);\n matrix[row][col] = min;\n rowSum[row] -= min;\n colSum[col] -= min;\n }\n }\n\n return matrix;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/find_and_replace_pattern/find_and_replace_pattern.py",
"content": "# https://leetcode.com/problems/find-and-replace-pattern\n\ndef find_and_replace_pattern(words, pattern):\n matchers = []\n \n for word in words:\n mapper = {}\n match = True\n used_pattern_letters = set()\n \n for index in range(len(word)):\n word_letter = word[index]\n pattern_letter = pattern[index]\n \n if word_letter in mapper and mapper[word_letter] != pattern_letter or (pattern_letter in used_pattern_letters and word_letter not in mapper):\n match = False\n break\n \n if word_letter not in mapper:\n used_pattern_letters.add(pattern_letter)\n mapper[word_letter] = pattern_letter\n \n if match: matchers.append(word)\n \n return matchers\n"
},
{
"path": "coding_interviews/leetcode/medium/finding_pairs_with_a_certain_sum/finding_pairs_with_a_certain_sum.py",
"content": "# https://leetcode.com/problems/finding-pairs-with-a-certain-sum\n\nclass FindSumPairs:\n def __init__(self, nums1, nums2):\n self.nums1 = nums1\n self.nums2 = nums2\n self.nums2_freq = Counter(nums2)\n\n def add(self, index, val):\n self.nums2_freq[self.nums2[index]] -= 1\n self.nums2[index] += val\n self.nums2_freq[self.nums2[index]] += 1\n\n def count(self, total):\n count = 0\n\n for num in self.nums1:\n if (total - num) in self.nums2_freq:\n count += self.nums2_freq[total - num]\n \n return count\n\n"
},
{
"path": "coding_interviews/leetcode/medium/finding_the_users_active_minutes/finding_the_users_active_minutes.py",
"content": "# https://leetcode.com/problems/finding-the-users-active-minutes\n\ndef build_unique_actions_by_id(logs):\n unique_actions_by_id = {} \n \n for [id, minute] in logs:\n if id in unique_actions_by_id:\n unique_actions_by_id[id].add(minute)\n else:\n unique_actions_by_id[id] = set({minute})\n \n return unique_actions_by_id\n\ndef build_count_by_actions_number(unique_actions_by_id):\n count = {}\n \n for _, actions in unique_actions_by_id.items():\n if len(actions) in count:\n count[len(actions)] += 1\n else:\n count[len(actions)] = 1\n \n return count\n\ndef build_answer(count_by_actions_number, k):\n answer = []\n\n for num in range(1, k + 1):\n if num in count_by_actions_number:\n answer.append(count_by_actions_number[num])\n else:\n answer.append(0)\n \n return answer\n\ndef finding_users_active_minutes(logs, k):\n unique_actions_by_id = build_unique_actions_by_id(logs)\n count_by_actions_number = build_count_by_actions_number(unique_actions_by_id)\n return build_answer(count_by_actions_number, k)\n\n# -------------------------------------------------------------------------------\n\ndef finding_users_active_minutes(logs, k):\n d = defaultdict(set)\n\n for id, minute in logs:\n d[id].add(minute)\n \n answer = [0] * k\n\n for _, actions in d.items():\n count = len(actions)\n answer[count - 1] += 1\n \n return answer"
},
{
"path": "coding_interviews/leetcode/medium/fraction_to_decimal/fraction_to_decimal.py",
"content": "def fraction_to_decimal(numerator, denominator):\n if numerator == 0:\n return '0'\n\n if numerator % denominator == 0:\n return str(numerator // denominator)\n\n result = ''\n\n if ('-' in str(numerator)) ^ ('-' in str(denominator)):\n result += '-'\n\n numerator = abs(numerator)\n denominator = abs(denominator)\n\n number = str(numerator // denominator)\n\n result += number\n result += '.'\n\n mapper = {}\n remainder = numerator % denominator\n\n while True:\n if remainder == 0:\n break\n\n if remainder in mapper:\n result = result[:mapper[remainder]] + \\\n '(' + result[mapper[remainder]:] + ')'\n break\n\n mapper[remainder] = len(result)\n remainder *= 10\n result += str(remainder // denominator)\n remainder %= denominator\n\n return result\n\n\ndata_test = [\n (1, 2, \"0.5\"),\n (2, 1, \"2\"),\n (2, 3, \"0.(6)\"),\n (4, 333, \"0.(012)\"),\n (1, 4, \"0.25\"),\n (1, 6, \"0.1(6)\"),\n (-1, 6, \"-0.1(6)\"),\n (1, -6, \"-0.1(6)\"),\n (-50, 8, \"-6.25\"),\n (1, 214748364, \"0.00(000000465661289042462740251655654056577585848337359161441621040707904997124914069194026549138227660723878669455195477065427143370461252966751355553982241280310754777158628319049732085502639731402098131932683780538602845887105337854867197032523144157689601770377165713821223802198558308923834223016478952081795603341592860749337303449725)\")\n]\n\nfor numerator, denominator, expected in data_test:\n result = fraction_to_decimal(numerator, denominator)\n print(result, result == expected)\n"
},
{
"path": "coding_interviews/leetcode/medium/group-anagrams/group-anagrams.js",
"content": "function sort(string) {\n return [...string].sort((c1, c2) => c1.localeCompare(c2)).join('');\n}\n\nfunction groupAnagrams(strs) {\n let hashmap = {};\n\n for (let string of strs) {\n let sortedString = sort(string);\n\n if (hashmap[sortedString]) {\n hashmap[sortedString].push(string);\n } else {\n hashmap[sortedString] = [string];\n }\n }\n\n return Object.values(hashmap);\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/group_the_people/group_the_people.py",
"content": "# https://leetcode.com/problems/group-the-people-given-the-group-size-they-belong-to/\n\n\ndef group_the_people(groupSizes):\n grouped_by_size = {}\n\n for index in range(len(groupSizes)):\n size = groupSizes[index]\n\n if size in grouped_by_size:\n grouped_by_size[size] += [index]\n else:\n grouped_by_size[size] = [index]\n\n grouped_by_ids = []\n\n for size, indices in grouped_by_size.items():\n for index in range(0, len(indices), size):\n grouped_by_ids.append(indices[index:index+size])\n\n return grouped_by_ids\n"
},
{
"path": "coding_interviews/leetcode/medium/insert-greatest-common-divisors-in-linked-list/insert-greatest-common-divisors-in-linked-list.js",
"content": "/**\n * https://leetcode.com/problems/insert-greatest-common-divisors-in-linked-list\n *\n * Definition for singly-linked list.\n * function ListNode(val, next) {\n * this.val = (val===undefined ? 0 : val)\n * this.next = (next===undefined ? null : next)\n * }\n */\n\nfunction calculateGCD(x, y) {\n x = Math.abs(x);\n y = Math.abs(y);\n while (y) {\n var t = y;\n y = x % y;\n x = t;\n }\n return x;\n}\n\nfunction insertGreatestCommonDivisors(head) {\n if (!head.next) return head;\n\n let curr = head;\n let next = head.next;\n\n while (next) {\n let newNode = new ListNode(calculateGCD(curr.val, next.val), next);\n curr.next = newNode;\n curr = next;\n next = next.next;\n }\n\n return head;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/insert-into-a-binary-search-tree/insert-into-a-binary-search-tree.js",
"content": "function insertIntoBST(root, val) {\n if (!root) {\n return new TreeNode(val);\n }\n\n if (val < root.val) {\n root.left = insertIntoBST(root.left, val);\n }\n\n if (val > root.val) {\n root.right = insertIntoBST(root.right, val);\n }\n\n return root;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/insert_bst/insert_bst.py",
"content": "class TreeNode:\n def __init__(self, val=0, left=None, right=None):\n self.val = val\n self.left = left\n self.right = right\n\n\ndef insert_into_BST(root, val):\n if root is None:\n return TreeNode(val)\n\n if val < root.val:\n root.left = insert_into_BST(root.left, val)\n\n if val > root.val:\n root.right = insert_into_BST(root.right, val)\n\n return root\n"
},
{
"path": "coding_interviews/leetcode/medium/keep_city_skyline/keep_city_skyline.py",
"content": "# https://leetcode.com/problems/max-increase-to-keep-city-skyline/description/\n\n# input: grid = [[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,3,1,0]]\n# output: 35\n\ndef build_top_or_bottom(grid):\n top_or_bottom = []\n\n for i in range(len(grid[0])):\n highest_building = 0\n\n for j in range(len(grid)):\n if grid[j][i] > highest_building:\n highest_building = grid[j][i]\n\n top_or_bottom.append(highest_building)\n\n return top_or_bottom\n\ndef build_left_or_right(grid):\n left_or_right = []\n\n for line in grid:\n highest_building = 0\n\n for building_height in line:\n if building_height > highest_building:\n highest_building = building_height\n\n left_or_right.append(highest_building)\n\n return left_or_right\n\ndef max_increase_keeping_skyline(grid):\n top_or_bottom = build_top_or_bottom(grid)\n left_or_right = build_left_or_right(grid)\n\n increased_number = 0\n\n for i in range(len(grid)):\n for j in range(len(grid[i])):\n if left_or_right[i] < top_or_bottom[j]:\n increased_number += (left_or_right[i] - grid[i][j])\n else:\n increased_number += (top_or_bottom[j] - grid[i][j])\n\n return increased_number\n\nprint(max_increase_keeping_skyline([[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,3,1,0]]))\n"
},
{
"path": "coding_interviews/leetcode/medium/kth-smallest-element-in-a-bst/kth-smallest-element-in-a-bst-1.js",
"content": "function traverse(node, list) {\n return node\n ? [\n ...list,\n ...traverse(node.left, list),\n node.val,\n ...traverse(node.right, list),\n ]\n : [];\n}\n\nfunction kthSmallest(root, k) {\n return traverse(root, [])[k - 1];\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/kth-smallest-element-in-a-bst/kth-smallest-element-in-a-bst-2.js",
"content": "let counter;\nlet nodeValue;\n\nfunction traverseAndGetKthSmallest(node, k) {\n if (!node) return;\n\n traverseAndGetKthSmallest(node.left, k);\n counter++;\n\n if (counter === k) {\n nodeValue = node.val;\n }\n\n traverseAndGetKthSmallest(node.right, k);\n}\n\nfunction kthSmallest(root, k) {\n counter = 0;\n nodeValue = -1;\n traverseAndGetKthSmallest(root, k);\n return nodeValue;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/kth-smallest-element-in-a-bst/kth-smallest-element-in-a-bst.js",
"content": "// Solution 1\n// additional memory usage: array\n\nfunction traverse(node, list) {\n return node\n ? [\n ...list,\n ...traverse(node.left, list),\n node.val,\n ...traverse(node.right, list),\n ]\n : [];\n}\n\nfunction kthSmallest(root, k) {\n return traverse(root, [])[k - 1];\n}\n\n// =========================== // ===========================\n\n// Solution 2\n// Less memory\nlet counter;\nlet nodeValue;\n\nfunction traverseAndGetKthSmallest(node, k) {\n if (!node) return;\n\n traverseAndGetKthSmallest(node.left, k);\n counter++;\n\n if (counter === k) {\n nodeValue = node.val;\n }\n\n traverseAndGetKthSmallest(node.right, k);\n}\n\nfunction kthSmallest(root, k) {\n counter = 0;\n nodeValue = -1;\n traverseAndGetKthSmallest(root, k);\n return nodeValue;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/letter_tile_possibilities/letter_tile_possibilities.py",
"content": "# https://leetcode.com/problems/letter-tile-possibilities\n\ndef num_tile_possibilities(tiles):\n res = set()\n\n def dfs(path, tile):\n if path not in res:\n if path: res.add(path)\n for i in range(len(tile)):\n dfs(path + tile[i], tile[:i] + tile[i+1:])\n \n dfs('', tiles)\n\n return len(res)\n"
},
{
"path": "coding_interviews/leetcode/medium/longest-substring-without-repeating-characters/longest-substring-without-repeating-characters.js",
"content": "/**\nabcadccb => abc / bcad / cad / adc / dc / c / cb\n=> 4\n\n\"abcadccb\"\n ^ ^\n\nlocalCount = 0 -> 1 -> 2 -> 1 -> 2 -> 3;\nmaxCount = 0 -> 1 -> 2 -> 3;\nset = ['b', 'c'] -> ['c', 'd', 'a'] -> ['c', 'd', 'a', 'b']\n*/\n\nfunction lengthOfLongestSubstring(s) {\n let leftPointer = 0;\n let maxCount = 0;\n let charToIndex = {};\n\n for (let rightPointer = 0; rightPointer < s.length; rightPointer++) {\n let num = s[rightPointer];\n let index = charToIndex[num];\n\n if (index == undefined) {\n maxCount = Math.max(maxCount, rightPointer - leftPointer + 1);\n } else {\n if (index >= leftPointer) {\n leftPointer = index + 1;\n } else {\n maxCount = Math.max(maxCount, rightPointer - leftPointer + 1);\n }\n }\n\n charToIndex[num] = rightPointer;\n }\n\n return maxCount;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/max-area-of-island/max-area-of-island.js",
"content": "function isOffTheGrid(grid, row, col) {\n let gridRows = grid.length;\n let gridCols = grid[0].length;\n return row < 0 || row >= gridRows || col < 0 || col >= gridCols;\n}\n\nfunction dfs(grid, row, col, maximumLocalIslandArea = 0) {\n if (isOffTheGrid(grid, row, col) || grid[row][col] === 0) {\n return 0;\n }\n\n grid[row][col] = 0; // visited\n\n return (\n 1 +\n dfs(grid, row - 1, col, maximumLocalIslandArea) + // top\n dfs(grid, row + 1, col, maximumLocalIslandArea) + // bottom\n dfs(grid, row, col + 1, maximumLocalIslandArea) + // right\n dfs(grid, row, col - 1, maximumLocalIslandArea) // left\n );\n}\n\nfunction maxAreaOfIsland(grid) {\n let maximumIslandArea = 0;\n\n for (let row = 0; row < grid.length; row++) {\n for (let col = 0; col < grid[row].length; col++) {\n let maximumLocalIslandArea = dfs(grid, row, col);\n maximumIslandArea = Math.max(maximumIslandArea, maximumLocalIslandArea);\n }\n }\n\n return maximumIslandArea;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/max_coins/max_coins.py",
"content": "# https://leetcode.com/problems/maximum-number-of-coins-you-can-get\n\n\ndef max_coins(piles):\n piles = sorted(piles)\n bob = 0\n me = len(piles) - 2\n alice = len(piles) - 1\n counter = 0\n\n while me > bob:\n counter += piles[me]\n bob += 1\n me -= 2\n alice -= 2\n\n return counter\n"
},
{
"path": "coding_interviews/leetcode/medium/maximum-sum-of-an-hourglass/maximum-sum-of-an-hourglass.js",
"content": "// https://leetcode.com/problems/maximum-sum-of-an-hourglass\n\nfunction maxRowSum(grid, row, col) {\n return (\n grid[row][col] +\n grid[row][col + 1] +\n grid[row][col + 2] +\n grid[row + 1][col + 1] +\n grid[row + 2][col] +\n grid[row + 2][col + 1] +\n grid[row + 2][col + 2]\n );\n}\n\nfunction maxSum(grid) {\n let maxSumOfAnHourglass = 0;\n\n for (let row = 0; row + 2 < grid.length; row++) {\n for (let col = 0; col + 2 < grid[row].length; col++) {\n maxSumOfAnHourglass = Math.max(\n maxSumOfAnHourglass,\n maxRowSum(grid, row, col)\n );\n }\n }\n\n return maxSumOfAnHourglass;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/maximum_binary_tree/maximum_binary_tree.py",
"content": "'''\nhttps://leetcode.com/problems/maximum-binary-tree/description/\n\nInput: [3,2,1,6,0,5]\nOutput: return the tree root node representing the following tree:\n\n 6\n / \\\n 3 5\n \\ /\n 2 0\n \\\n 1\n'''\n\nclass TreeNode(object):\n def __init__(self, x):\n self.val = x\n self.left = None\n self.right = None\n\ndef construct_maximum_binary_tree(nums):\n if not nums: return None\n root_node = TreeNode(max(nums))\n root_node.left = construct_maximum_binary_tree(nums[0:nums.index(max(nums))])\n root_node.right = construct_maximum_binary_tree(nums[nums.index(max(nums))+1:])\n return root_node\n"
},
{
"path": "coding_interviews/leetcode/medium/median_tree/median_tree.py",
"content": "class Node:\n def __init__(self, value, left, right):\n self.value = value\n self.left = left\n self.right = right\n\n\ndef sum_and_count_nodes(node, sum_of_values, count):\n if node is None:\n return sum_of_values, count\n \n sum_of_values, count = sum_and_count_nodes(node.left, sum_of_values + node.value, count + 1)\n sum_of_values, count = sum_and_count_nodes(node.right, sum_of_values + node.value, count + 1)\n return sum_of_values, count\n \n\ndef median(tree):\n sum_of_values, count = sum_and_count_nodes(tree, 0, 0)\n if count == 0: return 0\n return sum_of_values / count\n\n\nleft = Node(1, None, None)\nright = Node(2, None, None)\nroot = Node(3, left, right)\n\nresult = median(root)\nprint(result)\n"
},
{
"path": "coding_interviews/leetcode/medium/merge-nodes-in-between-zeros/merge-nodes-in-between-zeros.js",
"content": "export class ListNode {\n constructor(val, next) {\n this.val = val === undefined ? 0 : val;\n this.next = next === undefined ? null : next;\n }\n}\n\nexport function mergeNodes(head) {\n let nonZeroHead;\n let node;\n let nextNode;\n let currentNode = head.next;\n let valueSum = 0;\n let gotFirstNode = false;\n\n while (currentNode) {\n valueSum += currentNode.val;\n\n if (currentNode.val === 0) {\n nextNode = new ListNode(valueSum);\n valueSum = 0;\n\n if (gotFirstNode) {\n node.next = nextNode;\n node = node.next;\n } else {\n node = nextNode;\n nonZeroHead = nextNode;\n gotFirstNode = true;\n }\n }\n\n currentNode = currentNode.next;\n }\n\n return nonZeroHead;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/merge-nodes-in-between-zeros/tests/merge-nodes-in-between-zeros.test.js",
"content": "import { describe, it, expect } from 'vitest';\nimport { ListNode, mergeNodes } from '../merge-nodes-in-between-zeros';\n\nfunction buildList(nums, initValue = 0) {\n let head = new ListNode(initValue);\n let node = head;\n let nextNode;\n\n for (let i = 1; i < nums.length; i++) {\n nextNode = new ListNode(nums[i]);\n node.next = nextNode;\n node = node.next;\n }\n\n return head;\n}\n\ndescribe('mergeNodes', () => {\n it('removes zeros and merges nodes', () => {\n const head = buildList([0, 3, 1, 0, 4, 5, 2, 0]);\n const result = buildList([4, 11], 4);\n expect(mergeNodes(head)).toEqual(result);\n });\n\n it('removes zeros and merges nodes', () => {\n const head = buildList([0, 1, 0, 3, 0, 2, 2, 0]);\n const result = buildList([1, 3, 4], 1);\n expect(mergeNodes(head)).toEqual(result);\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/medium/min-cost-climbing-stairs/min-cost-climbing-stairs.js",
"content": "// https://leetcode.com/problems/min-cost-climbing-stairs\n// https://leetcode.com/problems/min-cost-climbing-stairs/solutions/476388/4-ways-step-by-step-from-recursion-top-down-dp-bottom-up-dp-fine-tuning\n\nfunction getMinCost(stairs, index, dp) {\n if (index < 0) return 0;\n if (index === 0 || index === 1) return stairs[index];\n if (dp[index]) return dp[index];\n\n dp[index] =\n stairs[index] +\n Math.min(\n getMinCost(stairs, index - 1, dp),\n getMinCost(stairs, index - 2, dp)\n );\n\n return dp[index];\n}\n\nfunction minCostClimbingStairs(cost) {\n let dp = [];\n let minCostFirst = getMinCost(cost, cost.length - 1, dp);\n let minCostSecond = getMinCost(cost, cost.length - 2, dp);\n return Math.min(minCostFirst, minCostSecond);\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/min_operations/min_operations.py",
"content": "def min_operations(n):\n operations = 0\n\n for index in range(n // 2):\n operations += n - (2 * index + 1)\n\n return operations\n"
},
{
"path": "coding_interviews/leetcode/medium/min_pair_sum/min_pair_sum.py",
"content": "# https://leetcode.com/problems/minimize-maximum-pair-sum-in-array\n\ndef min_pair_sum(nums):\n sorted_nums = sorted(nums)\n maximum_pair_sum = float('-Inf')\n \n for i in range(len(nums) // 2):\n pair_sum = sorted_nums[i] + sorted_nums[len(sorted_nums) - i - 1]\n maximum_pair_sum = max(maximum_pair_sum, pair_sum)\n \n return maximum_pair_sum\n"
},
{
"path": "coding_interviews/leetcode/medium/min_partitions/min_partitions.py",
"content": "# https://leetcode.com/problems/partitioning-into-minimum-number-of-deci-binary-numbers\n\ndef min_partitions(n):\n count = '0'\n\n for digit_char in n:\n if digit_char > count:\n count = digit_char\n\n return int(count)\n\ndef min_partitions(n):\n return int(max(n))\n"
},
{
"path": "coding_interviews/leetcode/medium/minimum-add-to-make-parentheses-valid/minimum-add-to-make-parentheses-valid.js",
"content": "/*\n\"(\" => 1\n\")\" => 1\n\"()\" => 0\n\"(()\" => 1\n\"())\" => 1\n\"(((\" => 3\n\")))\" => 3\n\")(\" => 2 => \"()(\" => \"()()\"\n\"()))((\" => 4\n*/\n\nfunction minAddToMakeValid(s) {\n let closeParenthesisCount = 0;\n let openParenthesisStack = [];\n\n for (let stringIndex = 0; stringIndex < s.length; stringIndex++) {\n const char = s[stringIndex];\n\n if (char === '(') {\n openParenthesisStack.push(char);\n } else {\n if (openParenthesisStack.length) {\n openParenthesisStack.pop();\n } else {\n closeParenthesisCount++;\n }\n }\n }\n\n return closeParenthesisCount + openParenthesisStack.length;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/minimum-amount-of-time-to-collect-garbage/minimum-amount-of-time-to-collect-garbage.js",
"content": "function measure(garbage, travel, garbageType) {\n let minutes = 0;\n let lastGarbageItem = -1;\n\n for (let [index, garbageItems] of garbage.entries()) {\n let itemCount = 0;\n\n for (let item of garbageItems) {\n if (item === garbageType) {\n lastGarbageItem = index;\n itemCount++;\n }\n }\n\n minutes += itemCount;\n }\n\n for (let index = 0; index < lastGarbageItem; index++) {\n minutes += travel[index];\n }\n\n return minutes;\n}\n\nfunction garbageCollection(garbage, travel) {\n let minutes = 0;\n minutes += measure(garbage, travel, 'G');\n minutes += measure(garbage, travel, 'M');\n minutes += measure(garbage, travel, 'P');\n return minutes;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/minimum-cost-of-buying-candies-with-discount/minimum-cost-of-buying-candies-with-discount.js",
"content": "// https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount\n\nfunction sum(cost) {\n let sumOfAllCost = 0;\n\n for (let c of cost) {\n sumOfAllCost += c;\n }\n\n return sumOfAllCost;\n}\n\nfunction minimumCost(cost) {\n if (cost.length <= 2) return sum(cost);\n cost.sort((a, b) => a - b);\n\n let allCost = 0;\n let index;\n\n for (index = cost.length - 1; index > 1; index -= 3) {\n if (cost[index] <= cost[index - 2]) {\n allCost += cost[index - 1] + cost[index - 2];\n } else {\n allCost += cost[index] + cost[index - 1];\n }\n }\n\n allCost += sum(cost.slice(0, index + 1));\n\n return allCost;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/minimum-number-of-steps-to-make-two-strings-anagram/README.md",
"content": "# Minimum Number of Steps to Make Two Strings Anagram\n\n[Problem link](https://leetcode.com/problems/minimum-number-of-steps-to-make-two-strings-anagram)\n\n- Using the hash map data structure\n- Runtime complexity: O(N), where N is the length of `s` and `t`\n- Counting and comparing characters require hash maps to get the count based on each character\n - key: characters\n - value: count of each character\n"
},
{
"path": "coding_interviews/leetcode/medium/minimum-number-of-steps-to-make-two-strings-anagram/minimum-number-of-steps-to-make-two-strings-anagram.js",
"content": "function buildMap(string) {\n let map = new Map();\n\n for (let char of string) {\n if (map.has(char)) map.set(char, map.get(char) + 1);\n else map.set(char, 1);\n }\n\n return map;\n}\n\nfunction minSteps(s, t) {\n let sMap = buildMap(s);\n let tMap = buildMap(t);\n let minimumSteps = 0;\n\n for (let [char, count] of sMap.entries()) {\n if (!tMap.has(char)) {\n minimumSteps += count;\n } else if (count > tMap.get(char)) {\n minimumSteps += count - tMap.get(char);\n }\n }\n\n return minimumSteps;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/minimum_number_of_operations_to_move_all_balls_to_each_box/minimum_number_of_operations_to_move_all_balls_to_each_box.py",
"content": "# https://leetcode.com/problems/minimum-number-of-operations-to-move-all-balls-to-each-box/\n\ndef min_operations(boxes):\n answer = []\n \n for index in range(len(boxes)):\n counter = 0\n for box_index in range(len(boxes)):\n if index != box_index and boxes[box_index] == '1':\n counter += abs(index - box_index)\n \n answer.append(counter)\n \n return answer\n\ndef sum_moves(answer, boxes, boxes_indices):\n moves, number_of_balls_seen = 0, 0\n \n for index in boxes_indices:\n answer[index] += moves\n\n if boxes[index] == '1':\n number_of_balls_seen += 1\n\n moves += number_of_balls_seen\n\n return answer\n\ndef min_operations(boxes):\n length_boxes = len(boxes)\n answer, moves, number_of_balls_seen = [0] * length_boxes, 0, 0\n answer = sum_moves(answer, boxes, range(length_boxes))\n return sum_moves(answer, boxes, reversed(range(length_boxes)))"
},
{
"path": "coding_interviews/leetcode/medium/number-of-closed-islands/number-of-closed-islands.js",
"content": "/**\n- is it in the border: no closed island\n- length == 1, 2: no closed island\n- visited data structure: map\n- iterate: [1,1] -> [n-1,n-1]\n - is it 0\n - go to top, bottom, left, right with a dfs fn\n - is it 0: go to top, bottom, left, right with recursive call to the dfs fn\n*/\nfunction generateVisitedKey(row, col) {\n return `${row}-${col}`;\n}\n\nfunction isInsideTheGrid(grid, row, col) {\n return row >= 0 && row < grid.length && col >= 0 && col < grid[0].length;\n}\n\nfunction dfs(grid, row, col, visited) {\n let key = generateVisitedKey(row, col);\n\n if (!isInsideTheGrid(grid, row, col)) {\n return false;\n }\n\n if (grid[row][col] === 1 || visited[key]) {\n return true;\n }\n\n if (grid[row][col] === 0 && !visited[key]) {\n visited[key] = true;\n\n let top = dfs(grid, row - 1, col, visited);\n let bottom = dfs(grid, row + 1, col, visited);\n let left = dfs(grid, row, col - 1, visited);\n let right = dfs(grid, row, col + 1, visited);\n\n return top && bottom && left && right;\n }\n}\n\nfunction closedIsland(grid) {\n if (grid.length <= 2 || grid[0].length <= 2) {\n return 0;\n }\n\n let visited = {};\n let closedIslandsNumber = 0;\n\n for (let row = 1; row < grid.length - 1; row++) {\n for (let col = 1; col < grid[row].length - 1; col++) {\n let cell = grid[row][col];\n let key = generateVisitedKey(row, col);\n\n if (cell === 0 && !visited[key]) {\n visited[key] = true;\n\n let top = dfs(grid, row - 1, col, visited);\n let bottom = dfs(grid, row + 1, col, visited);\n let left = dfs(grid, row, col - 1, visited);\n let right = dfs(grid, row, col + 1, visited);\n let isClosedIsland = top && bottom && left && right;\n\n if (isClosedIsland) {\n closedIslandsNumber++;\n }\n }\n }\n }\n\n return closedIslandsNumber;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/number-of-enclaves/number-of-enclaves.js",
"content": "/**\n - 0 => true\n - dfs => (top, bottom, left, right)\n - off the grid => false\n */\nfunction getVisitedKey(row, col) {\n return `${row}-${col}`;\n}\n\nfunction isOffTheGrid(grid, row, col) {\n return row < 0 || col < 0 || row >= grid.length || col >= grid[0].length;\n}\n\nfunction dfs(grid, row, col, visited) {\n if (isOffTheGrid(grid, row, col)) {\n return -1;\n }\n\n if (grid[row][col] === 0) {\n return 0;\n }\n\n let key = getVisitedKey(row, col);\n\n if (visited[key]) {\n return 0;\n }\n\n visited[key] = true;\n\n let top = dfs(grid, row - 1, col, visited);\n let bottom = dfs(grid, row + 1, col, visited);\n let left = dfs(grid, row, col - 1, visited);\n let right = dfs(grid, row, col + 1, visited);\n\n return top === -1 || bottom === -1 || left === -1 || right === -1\n ? -1\n : 1 + top + bottom + left + right;\n}\n\nfunction numEnclaves(grid) {\n let numberOfLands = 0;\n let visited = {};\n\n for (let row = 0; row < grid.length; row++) {\n for (let col = 0; col < grid[row].length; col++) {\n let cell = grid[row][col];\n let key = getVisitedKey(row, col);\n\n if (cell && !visited[key]) {\n visited[key] = true;\n\n let top = dfs(grid, row - 1, col, visited);\n let bottom = dfs(grid, row + 1, col, visited);\n let left = dfs(grid, row, col - 1, visited);\n let right = dfs(grid, row, col + 1, visited);\n\n numberOfLands +=\n top === -1 || bottom === -1 || left === -1 || right === -1\n ? 0\n : 1 + top + bottom + left + right;\n }\n }\n }\n\n return numberOfLands;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/number-of-islands/number-of-islands.js",
"content": "function isInsideTheGrid(grid, row, col) {\n return row >= 0 && row < grid.length && col >= 0 && col < grid[0].length;\n}\n\nfunction dfs(grid, row, col) {\n if (isInsideTheGrid(grid, row, col) && grid[row][col] === '1') {\n grid[row][col] = 0; // marked as visited\n dfs(grid, row - 1, col); // top\n dfs(grid, row + 1, col); // bottom\n dfs(grid, row, col - 1); // left\n dfs(grid, row, col + 1); // right\n }\n}\n\nfunction numIslands(grid) {\n let numberOfIslands = 0;\n\n for (let row = 0; row < grid.length; row++) {\n for (let col = 0; col < grid[row].length; col++) {\n if (grid[row][col] === '1') {\n numberOfIslands++;\n grid[row][col] = 0; // marked as visited\n\n dfs(grid, row - 1, col); // top\n dfs(grid, row + 1, col); // bottom\n dfs(grid, row, col - 1); // left\n dfs(grid, row, col + 1); // right\n }\n }\n }\n\n return numberOfIslands;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/number-of-laser-beams-in-a-bank/number-of-laser-beams-in-a-bank.js",
"content": "/*\nAnti-theft security devices are activated inside a bank. You are given a 0-indexed binary string array bank representing the floor plan of the bank, which is an m x n 2D matrix. bank[i] represents the ith row, consisting of '0's and '1's. '0' means the cell is empty, while'1' means the cell has a security device.\n\nThere is one laser beam between any two security devices if both conditions are met:\n\nThe two devices are located on two different rows: r1 and r2, where r1 < r2.\n- For each row i where r1 < i < r2, there are no security devices in the ith row.\n- Laser beams are independent, i.e., one beam does not interfere nor join with another.\n\nReturn the total number of laser beams in the bank.\n*/\n\nexport function numberOfBeams(bank) {\n let lasersCount = 0;\n const securityDevices = [];\n\n for (let row = 0; row < bank.length; row++) {\n let numberOfSecurityDevices = 0;\n\n for (let col = 0; col < bank[row].length; col++) {\n numberOfSecurityDevices += Number(bank[row][col]);\n }\n\n if (numberOfSecurityDevices) {\n securityDevices.push(numberOfSecurityDevices);\n }\n }\n\n for (let i = 0; i < securityDevices.length - 1; i++) {\n lasersCount += securityDevices[i] * securityDevices[i + 1];\n }\n\n return lasersCount;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/number-of-laser-beams-in-a-bank/tests/number-of-laser-beams-in-a-bank.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport { numberOfBeams } from '../number-of-laser-beams-in-a-bank';\n\ndescribe('numberOfBeams', () => {\n it('', () => {\n expect(numberOfBeams(['011001', '000000', '010100', '001000'])).toEqual(8);\n });\n\n it('', () => {\n expect(numberOfBeams(['000', '111', '000'])).toEqual(0);\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/medium/optimal-partition-of-string/optimal-partition-of-string.js",
"content": "// https://leetcode.com/problems/optimal-partition-of-string\n\nfunction partitionString(s) {\n let partition = [];\n let substring = '';\n let substringMap = new Map();\n\n for (let index = 0; index < s.length; index++) {\n if (substringMap.has(s[index])) {\n partition.push(substring);\n substring = s[index];\n substringMap = new Map([[s[index], 1]]);\n } else {\n substring += s[index];\n substringMap.set(s[index], 1);\n }\n\n if (index === s.length - 1) {\n partition.push(substring);\n }\n }\n\n return partition.length;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/optimal-partition-of-string/optimized-optimal-partition-of-string.js",
"content": "// https://leetcode.com/problems/optimal-partition-of-string\n\nfunction partitionString(s) {\n let substringMap = new Map([[s[0], 1]]);\n let count = 1;\n\n for (let index = 1; index < s.length; index++) {\n if (substringMap.has(s[index])) {\n substringMap = new Map([[s[index], 1]]);\n count++;\n } else {\n substringMap.set(s[index], 1);\n }\n }\n\n return count;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/pair-sum/pair-sum.js",
"content": "/*\nIn a linked list of size n, where n is even, the ith node (0-indexed) of the linked list is known as the twin of the (n-1-i)th node, if 0 <= i <= (n / 2) - 1.\n\nFor example, if n = 4, then node 0 is the twin of node 3, and node 1 is the twin of node 2. These are the only nodes with twins for n = 4.\nThe twin sum is defined as the sum of a node and its twin.\n\nGiven the head of a linked list with even length, return the maximum twin sum of the linked list.\n\nInput: head = [5,4,2,1]\nOutput: 6\n\nInput: head = [4,2,2,3]\nOutput: 7\n\nInput: head = [1,100000]\nOutput: 100001\n*/\n\nexport function pairSum(list) {\n let maximumTwin = 0;\n\n for (let i = 0; i < Math.floor(list.length / 2); i++) {\n maximumTwin = Math.max(maximumTwin, list[i] + list[list.length - 1 - i]);\n }\n\n return maximumTwin;\n}\n\nexport function pairSumLinkedList(head) {\n const list = [];\n\n while (head) {\n list.push(head.val);\n head = head.next;\n }\n\n return pairSum(list);\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/pair-sum/tests/pair-sum.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport { pairSum } from '../pair-sum';\n\ndescribe('pairSum', () => {\n it('', () => {\n expect(pairSum([5, 4, 2, 1])).toEqual(6);\n });\n\n it('', () => {\n expect(pairSum([4, 2, 2, 3])).toEqual(7);\n });\n\n it('', () => {\n expect(pairSum([1, 100000])).toEqual(100001);\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/medium/partition-array-according-to-given-pivot/partition-array-according-to-given-pivot.js",
"content": "/*\nYou are given a 0-indexed integer array nums and an integer pivot. Rearrange nums such that the following conditions are satisfied:\n\nEvery element less than pivot appears before every element greater than pivot.\nEvery element equal to pivot appears in between the elements less than and greater than pivot.\nThe relative order of the elements less than pivot and the elements greater than pivot is maintained.\nMore formally, consider every pi, pj where pi is the new position of the ith element and pj is the new position of the jth element. For elements less than pivot, if i < j and nums[i] < pivot and nums[j] < pivot, then pi < pj. Similarly for elements greater than pivot, if i < j and nums[i] > pivot and nums[j] > pivot, then pi < pj.\n\nReturn nums after the rearrangement.\n*/\n\nexport function pivotArray(nums, pivot) {\n const lessThanPivot = [];\n const equalToPivot = [];\n const greaterThanPivot = [];\n\n nums.forEach((num) => {\n if (num === pivot) {\n equalToPivot.push(num);\n }\n\n if (num < pivot) {\n lessThanPivot.push(num);\n }\n\n if (num > pivot) {\n greaterThanPivot.push(num);\n }\n });\n\n return [...lessThanPivot, ...equalToPivot, ...greaterThanPivot];\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/partition-array-according-to-given-pivot/tests/partition-array-according-to-given-pivot.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport { pivotArray } from '../partition-array-according-to-given-pivot';\n\ndescribe('pivotArray', () => {\n it('', () => {\n expect(pivotArray([9, 12, 5, 10, 14, 3, 10], 10)).toEqual([\n 9, 5, 3, 10, 10, 12, 14,\n ]);\n });\n\n it('', () => {\n expect(pivotArray([-3, 4, 3, 2], 2)).toEqual([-3, 2, 4, 3]);\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/medium/permutation-in-string/permutation-in-string-sliding-window.js",
"content": "function buildCharCount(string) {\n let charCount = {};\n\n for (let char of string) {\n if (charCount[char]) {\n charCount[char]++;\n } else {\n charCount[char] = 1;\n }\n }\n\n return charCount;\n}\n\nfunction isPermutation(possiblePermutation, string) {\n let charCount = buildCharCount(string);\n\n for (let char of possiblePermutation) {\n if (charCount[char]) {\n charCount[char]--;\n } else {\n return false;\n }\n }\n\n return true;\n}\n\nfunction checkInclusion(s1, s2) {\n for (let pointer1 = 0; pointer1 <= s2.length - s1.length; pointer1++) {\n let pointer2 = pointer1 + s1.length;\n let possiblePermutation = s2.substring(pointer1, pointer2);\n\n if (isPermutation(possiblePermutation, s1)) {\n return true;\n }\n }\n\n return false;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/permutation-in-string/permutation-in-string.js",
"content": "function buildCharCount(string) {\n let charCount = {};\n\n for (let char of string) {\n if (charCount[char]) {\n charCount[char]++;\n } else {\n charCount[char] = 1;\n }\n }\n\n return charCount;\n}\n\nfunction isPermutation(possiblePermutation, string) {\n let charCount = buildCharCount(string);\n\n for (let char of possiblePermutation) {\n if (charCount[char]) {\n charCount[char]--;\n } else {\n return false;\n }\n }\n\n return true;\n}\n\nfunction checkInclusion(s1, s2) {\n let char = s1[0];\n let charIndices = [];\n\n for (let index = 0; index < s2.length; index++) {\n if (s2[index] === char) {\n charIndices.push(index);\n }\n }\n\n let possiblePermutations = [];\n\n for (let index of charIndices) {\n for (let pointer = 1; pointer <= s1.length; pointer++) {\n let startIndex = index - s1.length + pointer;\n let endIndex = index + pointer;\n let substring = s2.substring(startIndex, endIndex);\n\n if (substring.length === s1.length) {\n possiblePermutations.push(substring);\n }\n }\n }\n\n for (let possiblePermutation of possiblePermutations) {\n if (isPermutation(possiblePermutation, s1)) {\n return true;\n }\n }\n\n return false;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/populating-next-right-pointers-in-each-node/populating-next-right-pointers-in-each-node-simpler.js",
"content": "function dfs(node, next) {\n if (!node) return;\n\n node.next = next;\n\n dfs(node.left, node.right);\n dfs(node.right, next && next.left);\n}\n\nfunction connect(root) {\n dfs(root, null);\n return root;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/populating-next-right-pointers-in-each-node/populating-next-right-pointers-in-each-node.js",
"content": "function connectHelperRight(node) {\n if (!node) {\n return;\n }\n\n connectHelper(node.left, node.right);\n connectHelperRight(node.right);\n}\n\nfunction connectHelper(node, next) {\n if (!node || !next) {\n return;\n }\n\n node.next = next;\n\n connectHelper(node.left, node.right);\n connectHelper(node.right, next.left);\n}\n\nfunction connect(root) {\n if (!root) {\n return root;\n }\n\n connectHelper(root.left, root.right);\n connectHelperRight(root.right);\n\n return root;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/process_queries/process_queries.py",
"content": "def process_queries(queries, m):\n result = []\n list_m = list(range(1, m + 1))\n\n for index in range(len(queries)):\n for index_m in range(len(list_m)):\n if queries[index] == list_m[index_m]:\n result.append(index_m)\n list_m = [list_m[index_m]\n ] + list_m[:index_m] + list_m[index_m + 1:]\n break\n\n return result\n"
},
{
"path": "coding_interviews/leetcode/medium/product-of-array-except-self/product-of-array-except-self.js",
"content": "function productExceptSelf(nums) {\n let zeros = 0;\n let answer = [];\n let product = 1;\n\n for (let num of nums) {\n if (num) product *= num;\n else zeros++;\n }\n\n for (let num of nums) {\n if (num) {\n answer.push(zeros ? 0 : product / num);\n } else {\n answer.push(zeros > 1 ? 0 : product);\n }\n }\n\n return answer;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/rearrange-array-elements-by-sign/rearrange-array-elements-by-sign.js",
"content": "/*\nYou are given a 0-indexed integer array nums of even length consisting of an equal number of positive and negative integers.\n\nYou should rearrange the elements of nums such that the modified array follows the given conditions:\n\nEvery consecutive pair of integers have opposite signs.\nFor all integers with the same sign, the order in which they were present in nums is preserved.\nThe rearranged array begins with a positive integer.\nReturn the modified array after rearranging the elements to satisfy the aforementioned conditions.\n\nExample 1:\nInput: nums = [3,1,-2,-5,2,-4]\nOutput: [3,-2,1,-5,2,-4]\nExplanation:\nThe positive integers in nums are [3,1,2]. The negative integers are [-2,-5,-4].\nThe only possible way to rearrange them such that they satisfy all conditions is [3,-2,1,-5,2,-4].\nOther ways such as [1,-2,2,-5,3,-4], [3,1,2,-2,-5,-4], [-2,3,-5,1,-4,2] are incorrect because they do not satisfy one or more conditions. \n\nExample 2:\nInput: nums = [-1,1]\nOutput: [1,-1]\nExplanation:\n1 is the only positive integer and -1 the only negative integer in nums.\nSo nums is rearranged to [1,-1].\n*/\n\nfunction isPositive(num) {\n return num > 0;\n}\n\nexport function rearrangeArray(nums) {\n const negative = [];\n const positive = [];\n\n nums.forEach((num) => {\n if (isPositive(num)) {\n positive.push(num);\n } else {\n negative.push(num);\n }\n });\n\n const rearrangeArray = [];\n\n for (let i = 0; i < negative.length; i++) {\n rearrangeArray.push(positive[i]);\n rearrangeArray.push(negative[i]);\n }\n\n return rearrangeArray;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/rearrange-array-elements-by-sign/tests/rearrange-array-elements-by-sign.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport { rearrangeArray } from '../rearrange-array-elements-by-sign';\n\ndescribe('rearrangeArray', () => {\n it('', () => {\n expect(rearrangeArray([3, 1, -2, -5, 2, -4])).toEqual([\n 3, -2, 1, -5, 2, -4,\n ]);\n });\n\n it('', () => {\n expect(rearrangeArray([-1, 1])).toEqual([1, -1]);\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/medium/reduce_array_size_to_the_half/reduce_array_size_to_the_half.py",
"content": "# https://leetcode.com/problems/reduce-array-size-to-the-half\n\n'''\nTime Complexity: O(NlogN)\nSpace Complexity: O(N)\n'''\n\ndef min_set_size(arr):\n num_to_count, counts, min_size, current_length = {}, [], 0, len(arr)\n \n for num in arr:\n if num in num_to_count:\n num_to_count[num] += 1\n else:\n num_to_count[num] = 1\n \n for num in num_to_count:\n counts.append(num_to_count[num])\n \n counts = reversed(sorted(counts))\n \n if len(arr) % 2 == 0:\n cut = len(arr) / 2\n else:\n cut = len(arr + 1) / 2\n \n for count in counts:\n min_size += 1\n current_length -= count\n \n if current_length <= cut:\n return min_size\n \n return min_size\n"
},
{
"path": "coding_interviews/leetcode/medium/remove-nth-node-from-end-of-list/remove-nth-node-from-end-of-list-fast-slow.js",
"content": "function removeNthFromEnd(head, n) {\n fast = head;\n slow = head;\n\n while (n) {\n fast = fast.next;\n n--;\n }\n\n if (!fast) {\n return head.next;\n }\n\n while (fast.next) {\n fast = fast.next;\n slow = slow.next;\n }\n\n slow.next = slow.next.next;\n\n return head;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/remove-nth-node-from-end-of-list/remove-nth-node-from-end-of-list.js",
"content": "/**\n * function ListNode(val, next) {\n * this.val = (val===undefined ? 0 : val)\n * this.next = (next===undefined ? null : next)\n * }\n */\n\nfunction countNodes(head) {\n let count = 0;\n\n while (head) {\n count++;\n head = head.next;\n }\n\n return count;\n}\n\nfunction removeNthFromEnd(head, n) {\n let count = countNodes(head);\n let nth = count - n;\n let node = head;\n\n if (nth === 0) {\n head = head.next;\n return head;\n }\n\n while (node) {\n if (nth === 1) {\n node.next = node.next.next;\n }\n\n nth--;\n node = node.next;\n }\n\n return head;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/rotate-array/rotate-array-optimized.js",
"content": "function reverseInPlace(nums, start, end) {\n while (start < end) {\n let temporaryStart = nums[start];\n nums[start] = nums[end];\n nums[end] = temporaryStart;\n start++;\n end--;\n }\n}\n\nfunction rotate(nums, k) {\n if (k <= 0) {\n return;\n }\n\n let start = 0;\n let end = nums.length - 1;\n let limit = k % nums.length;\n\n reverseInPlace(nums, start, end - limit);\n reverseInPlace(nums, end - limit + 1, end);\n reverseInPlace(nums, start, end);\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/rotate-array/rotate-array.js",
"content": "function rotate(nums, k) {\n let count = 0;\n\n while (count < k) {\n const num = nums.pop();\n nums.unshift(num);\n count++;\n }\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/rotate-image/rotate-image.js",
"content": "function setupMatrix(matrix) {\n const newMatrix = [];\n\n for (let row = 0; row < matrix.length; row++) {\n const newRow = [];\n\n for (let col = 0; col < matrix[row].length; col++) {\n newRow.push(matrix[row][col]);\n }\n\n newMatrix.push(newRow);\n }\n\n return newMatrix;\n}\n\nfunction rotateBorder(newMatrix, matrix, minRow, minCol, maxRow, maxCol) {\n if (minRow >= maxRow && minCol >= maxCol) {\n return;\n }\n\n // top\n let row = minRow;\n\n for (let col = minCol; col <= maxCol; col++) {\n const value = newMatrix[minRow][col];\n matrix[row][maxCol] = value;\n row++;\n }\n\n // right\n let col = maxCol;\n\n for (let row = minRow; row <= maxRow; row++) {\n const value = newMatrix[row][maxCol];\n matrix[maxRow][col] = value;\n col--;\n }\n\n // bottom\n row = minRow;\n\n for (let col = minCol; col <= maxCol; col++) {\n const value = newMatrix[maxRow][col];\n matrix[row][minCol] = value;\n row++;\n }\n\n // left\n col = maxCol;\n\n for (let row = minRow; row <= maxRow; row++) {\n const value = newMatrix[row][minCol];\n matrix[minRow][col] = value;\n col--;\n }\n\n rotateBorder(\n newMatrix,\n matrix,\n minRow + 1,\n minCol + 1,\n maxRow - 1,\n maxCol - 1\n );\n}\n\nfunction rotate(matrix) {\n const newMatrix = setupMatrix(matrix);\n const minRow = 0;\n const minCol = 0;\n const maxRow = matrix.length - 1;\n const maxCol = matrix[0].length - 1;\n\n rotateBorder(newMatrix, matrix, minRow, minCol, maxRow, maxCol);\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/search-a-2d-matrix/search-a-2d-matrix.js",
"content": "function getMiddle(start, end) {\n return Math.floor((start + end) / 2);\n}\n\nfunction binarySearch(list, target) {\n let start = 0;\n let end = list.length - 1;\n let middle = getMiddle(start, end);\n\n while (start <= end) {\n if (list[middle] === target) {\n return true;\n } else if (list[middle] > target) {\n end = middle - 1;\n middle = getMiddle(start, end);\n } else {\n start = middle + 1;\n middle = getMiddle(start, end);\n }\n }\n\n return false;\n}\n\nfunction searchMatrix(matrix, target) {\n let targetRow;\n\n for (let rowIndex = 0; rowIndex < matrix.length; rowIndex++) {\n let rowFirstNum = matrix[rowIndex][0];\n let rowLastNum = matrix[rowIndex][matrix[rowIndex].length - 1];\n\n if (target >= rowFirstNum && target <= rowLastNum) {\n targetRow = rowIndex;\n }\n }\n\n return matrix[targetRow] ? binarySearch(matrix[targetRow], target) : false;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/search-a-2d-matrix/search-a-2d-matrix.py",
"content": "# https://leetcode.com/problems/search-a-2d-matrix\n\n'''\nRuntime Complexity: O(logNM)\nSpace Complexity: O(1)\n'''\n\ndef search_matrix(matrix, target):\n rows, columns = len(matrix), len(matrix[0])\n start, end = 0, rows * columns - 1\n\n while start <= end:\n middle = (start + end) // 2\n number = matrix[middle // columns][middle % columns]\n \n if number == target:\n return True\n \n if target < number:\n end = middle - 1\n else:\n start = middle + 1\n \n return False\n"
},
{
"path": "coding_interviews/leetcode/medium/search-a-2d-matrix-ii/search-a-2d-matrix-ii.py",
"content": "# https://leetcode.com/problems/search-a-2d-matrix-ii\n\n'''\nRuntime Complexity: O(NlogM), where N is the number of rows and M is the number of columns\nSpace Complexity: O(1)\n'''\n\ndef search_matrix(matrix, target):\n for row in matrix:\n if target_in_row(row, target):\n return True\n \n return False\n\ndef target_in_row(array, target):\n start, end = 0, len(array) - 1\n \n while start <= end:\n middle = (start + end) // 2\n number = array[middle]\n \n if number == target:\n return True\n \n if number > target:\n end = middle - 1\n else:\n start = middle + 1\n \n return False"
},
{
"path": "coding_interviews/leetcode/medium/set-matrix-zeroes/set-matrix-zeroes.js",
"content": "function updateRow(matrix, row, visited) {\n for (let col = 0; col < matrix[row].length; col++) {\n if (matrix[row][col]) {\n matrix[row][col] = 0;\n visited[`${row}-${col}`] = true;\n }\n }\n}\n\nfunction updateCol(matrix, col, visited) {\n for (let row = 0; row < matrix.length; row++) {\n if (matrix[row][col]) {\n matrix[row][col] = 0;\n visited[`${row}-${col}`] = true;\n }\n }\n}\n\nfunction setZeroes(matrix) {\n let visited = {};\n\n for (let row = 0; row < matrix.length; row++) {\n for (let col = 0; col < matrix[row].length; col++) {\n let cell = matrix[row][col];\n\n if (cell === 0 && !visited[`${row}-${col}`]) {\n if (!visited[`row-${row}`]) {\n updateRow(matrix, row, visited);\n }\n\n if (!visited[`col-${col}`]) {\n updateCol(matrix, col, visited);\n }\n\n visited[`row-${row}`] = true;\n visited[`col-${col}`] = true;\n }\n }\n }\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/sort-the-students-by-their-kth-score/sort-the-students-by-their-kth-score.js",
"content": "function sortTheStudents(score, k) {\n let column = [];\n let sortedScores = [];\n\n for (let row = 0; row < score.length; row++) {\n column.push([row, score[row][k]]);\n }\n\n column.sort((pair1, pair2) => pair2[1] - pair1[1]);\n\n for (let [row] of column) {\n sortedScores.push(score[row]);\n }\n\n return sortedScores;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/sort_the_matrix_diagonally/sort_the_matrix_diagonally.py",
"content": "def diagonal_sort(mat):\n for column in range(len(mat[0]) - 1):\n diagonal_list = []\n col = column\n\n for row in range(len(mat)):\n diagonal_list.append(mat[row][col])\n col += 1\n\n if col >= len(mat[0]):\n break\n\n diagonal_list = sorted(diagonal_list)\n col = column\n\n for row in range(len(mat)):\n mat[row][col] = diagonal_list[row]\n col += 1\n\n if col >= len(mat[0]):\n break\n\n for row in range(1, len(mat)):\n diagonal_list = []\n r = row\n\n for column in range(len(mat[0])):\n diagonal_list.append(mat[r][column])\n r += 1\n\n if r >= len(mat):\n break\n\n diagonal_list = sorted(diagonal_list)\n r = row\n\n for column in range(len(mat[0])):\n mat[r][column] = diagonal_list[column]\n r += 1\n\n if r >= len(mat):\n break\n\n return mat\n"
},
{
"path": "coding_interviews/leetcode/medium/string-compression/string-compression-copy.js",
"content": "// https://leetcode.com/problems/string-compression\n\nfunction compress(chars) {\n let counter = 1;\n let result = [];\n\n for (let index = 0; index < chars.length - 1; index++) {\n if (chars[index] === chars[index + 1]) counter++;\n else {\n result.push(chars[index]);\n if (counter > 1) result.push(...counter.toString());\n counter = 1;\n }\n\n if (index + 1 === chars.length - 1) {\n result.push(chars[index + 1]);\n if (counter > 1) result.push(...counter.toString());\n }\n }\n\n return result.length;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/string-compression/string-compression.js",
"content": "// https://leetcode.com/problems/string-compression\n\nfunction compress(chars) {\n let index = 0,\n p1 = 0;\n\n while (p1 < chars.length) {\n let p2 = p1;\n\n while (p2 < chars.length && chars[p1] === chars[p2]) {\n p2++;\n }\n\n let count = p2 - p1;\n chars[index++] = chars[p1];\n\n if (count > 1) {\n let countString = count.toString();\n\n for (let char of countString) {\n chars[index++] = char;\n }\n }\n\n p1 = p2;\n }\n\n while (chars.length > index) {\n chars.pop();\n }\n\n return chars.length;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/subrectangle_queries/subrectangle_queries.py",
"content": "# https://leetcode.com/problems/subrectangle-queries\n\n\nclass SubrectangleQueries:\n def __init__(self, rectangle):\n self.rectangle = rectangle\n\n def updateSubrectangle(self, row1, col1, row2, col2, newValue):\n for row in range(row1, row2 + 1):\n for col in range(col1, col2 + 1):\n self.rectangle[row][col] = newValue\n\n def getValue(self, row, col):\n return self.rectangle[row][col]\n"
},
{
"path": "coding_interviews/leetcode/medium/sum_of_nodes/sum_of_nodes.py",
"content": "# https://leetcode.com/problems/sum-of-nodes-with-even-valued-grandparent\n\n'''\nGiven a binary tree, return the sum of values of nodes with even-valued grandparent.\n(A grandparent of a node is the parent of its parent, if it exists.)\n\nIf there are no nodes with an even-valued grandparent, return 0.\n'''\n\n\ndef sum_even_grandparent(node):\n left = 0\n right = 0\n\n if node.left and node.left.left and node.val % 2 == 0:\n left += node.left.left.val\n\n if node.left and node.left.right and node.val % 2 == 0:\n left += node.left.right.val\n\n if node.left:\n left += sum_even_grandparent(node.left)\n\n if node.right and node.right.left and node.val % 2 == 0:\n right += node.right.left.val\n\n if node.right and node.right.right and node.val % 2 == 0:\n right += node.right.right.val\n\n if node.right:\n right += sum_even_grandparent(node.right)\n\n return right + left\n\n\ndef sum_even_grandparent_2(node):\n return helper(node, 1, 1)\n\n\ndef helper(node, parent, grandparent):\n if node is None:\n return 0\n\n return helper(node.left, node.val, parent) \\\n + helper(node.right, node.val, parent) \\\n + (node.val if grandparent % 2 == 0 else 0)\n"
},
{
"path": "coding_interviews/leetcode/medium/two-sum-ii-input-array-is-sorted/two-sum-ii-input-array-is-sorted-2.js",
"content": "function twoSum(numbers, target) {\n let start = 0;\n let end = numbers.length - 1;\n let result = [];\n\n while (start < end) {\n let sum = numbers[start] + numbers[end];\n\n if (sum === target) {\n result.push(start + 1);\n result.push(end + 1);\n break;\n }\n\n if (sum > target) end--;\n else start++;\n }\n\n return result;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/two-sum-ii-input-array-is-sorted/two-sum-ii-input-array-is-sorted.js",
"content": "function twoSum(numbers, target) {\n let numberMap = {};\n\n for (let index = 0; index < numbers.length; index++) {\n let number = numbers[index];\n numberMap[number] = index + 1;\n }\n\n let index1;\n let index2;\n\n for (let index = 0; index < numbers.length; index++) {\n let remainder = target - numbers[index];\n let remaindersIndex = numberMap[remainder];\n\n if (remaindersIndex) {\n index1 = index + 1;\n index2 = remaindersIndex;\n return [index1, index2];\n }\n }\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/valid-sudoku/valid-sudoku.js",
"content": "function isValidRow(board, row) {\n let allNumbersInRow = new Set();\n let countOfNumbersInRow = 0;\n\n for (let index = 0; index <= 8; index++) {\n let num = board[row][index];\n\n if (num !== '.') {\n allNumbersInRow.add(num);\n countOfNumbersInRow++;\n }\n }\n\n return allNumbersInRow.size === countOfNumbersInRow;\n}\n\nfunction isValidCol(board, col) {\n let allNumbersInCol = new Set();\n let countOfNumbersInCol = 0;\n\n for (let index = 0; index <= 8; index++) {\n let num = board[index][col];\n\n if (num !== '.') {\n allNumbersInCol.add(num);\n countOfNumbersInCol++;\n }\n }\n\n return allNumbersInCol.size === countOfNumbersInCol;\n}\n\nfunction isValidSquare(board, row, col) {\n let allNumbersInSquare = new Set();\n let countOfNumbersInSquare = 0;\n\n for (let rowIndex = row; rowIndex <= row + 2; rowIndex++) {\n for (let colIndex = col; colIndex <= col + 2; colIndex++) {\n let num = board[rowIndex][colIndex];\n\n if (num !== '.') {\n allNumbersInSquare.add(num);\n countOfNumbersInSquare++;\n }\n }\n }\n\n return allNumbersInSquare.size === countOfNumbersInSquare;\n}\n\nfunction isValidSudoku(board) {\n let isValid = true;\n\n for (let row = 0; row <= 8; row++) {\n isValid = isValid && isValidRow(board, row);\n }\n\n for (let col = 0; col <= 8; col++) {\n isValid = isValid && isValidCol(board, col);\n }\n\n for (let col = 0; col <= 6; col += 3) {\n for (let row = 0; row <= 6; row += 3) {\n isValid = isValid && isValidSquare(board, row, col);\n }\n }\n\n return isValid;\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/validate-binary-search-tree/validate-binary-search-tree-2.js",
"content": "function isValidBST(node, min = -Infinity, max = Infinity) {\n if (!node) return true;\n if (node.val <= min || node.val >= max) return false;\n return (\n isValidBST(node.left, min, node.val) &&\n isValidBST(node.right, node.val, max)\n );\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/validate-binary-search-tree/validate-binary-search-tree-almost-right.js",
"content": "function isValidLeft(node, left) {\n return node.val > left.val;\n}\n\nfunction isValidRight(node, right) {\n return node.val < right.val;\n}\n\nfunction isValid(node, left, right) {\n return isValidLeft(node, left) && isValidRight(node, right);\n}\n\nfunction compareNodeAndChildren(node, left, right) {\n if (left && right) {\n return (\n isValid(node, left, right) &&\n compareNodeAndChildren(left, left.left, left.right) &&\n compareNodeAndChildren(right, right.left, right.right)\n );\n }\n\n if (left) {\n return (\n isValidLeft(node, left) &&\n compareNodeAndChildren(left, left.left, left.right)\n );\n }\n\n if (right) {\n return (\n isValidRight(node, right) &&\n compareNodeAndChildren(right, right.left, right.right)\n );\n }\n\n return true;\n}\n\nfunction isValidBST(root) {\n return compareNodeAndChildren(root, root.left, root.right);\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/validate-binary-search-tree/validate-binary-search-tree.js",
"content": "function toList(node, treeList) {\n if (!node) {\n return;\n }\n\n treeList.push(node.val);\n\n toList(node.left, treeList);\n toList(node.right, treeList);\n}\n\nfunction dfs(node, value) {\n if (!node) {\n return new TreeNode(value);\n }\n\n if (value < node.val) {\n node.left = dfs(node.left, value);\n } else if (value > node.val) {\n node.right = dfs(node.right, value);\n }\n\n return node;\n}\n\nfunction buildTree(treeList) {\n let root = new TreeNode(treeList[0]);\n\n for (let value of treeList.slice(1)) {\n dfs(root, value);\n }\n\n return root;\n}\n\nfunction compareTrees(node1, node2) {\n if (!node1 && !node2) {\n return true;\n }\n\n if ((node1 && !node2) || (!node1 && node2)) {\n return false;\n }\n\n return (\n node1.val === node2.val &&\n compareTrees(node1.left, node2.left) &&\n compareTrees(node1.right, node2.right)\n );\n}\n\nfunction isValidBST(root) {\n let treeList = [];\n toList(root, treeList);\n let newTree = buildTree(treeList);\n return compareTrees(root, newTree);\n}\n"
},
{
"path": "coding_interviews/leetcode/medium/watering-plants/tests/watering-plants.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport { wateringPlants } from '../watering-plants';\n\ndescribe('wateringPlants', () => {\n it('', () => {\n expect(wateringPlants([2, 2, 3, 3], 5)).toEqual(14);\n });\n\n it('', () => {\n expect(wateringPlants([1, 1, 1, 4, 2, 3], 4)).toEqual(30);\n });\n\n it('', () => {\n expect(wateringPlants([7, 7, 7, 7, 7, 7, 7], 8)).toEqual(49);\n });\n\n it('', () => {\n expect(wateringPlants([2, 1], 2)).toEqual(4);\n });\n\n it('', () => {\n expect(wateringPlants([3, 2, 4, 2, 1], 6)).toEqual(17);\n });\n});\n"
},
{
"path": "coding_interviews/leetcode/medium/watering-plants/watering-plants.js",
"content": "/*\nYou want to water n plants in your garden with a watering can. The plants are arranged in a row and are labeled from 0 to n - 1 from left to right where the ith plant is located at x = i. There is a river at x = -1 that you can refill your watering can at.\n\nEach plant needs a specific amount of water. You will water the plants in the following way:\n\nWater the plants in order from left to right.\nAfter watering the current plant, if you do not have enough water to completely water the next plant, return to the river to fully refill the watering can.\nYou cannot refill the watering can early.\nYou are initially at the river (i.e., x = -1). It takes one step to move one unit on the x-axis.\n\nGiven a 0-indexed integer array plants of n integers, where plants[i] is the amount of water the ith plant needs, and an integer capacity representing the watering can capacity, return the number of steps needed to water all the plants.\n\nExample 1:\nInput: plants = [2,2,3,3], capacity = 5\nOutput: 14\n\nExample 2:\nInput: plants = [1,1,1,4,2,3], capacity = 4\nOutput: 30\n\nExample 3:\nInput: plants = [7,7,7,7,7,7,7], capacity = 8\nOutput: 49\n*/\n\n// [2, 2, 3, 3]\n// capacity: 5 -> 3 -> 1\n// steps: 1 -> 2 -> 4\n\nexport function wateringPlants(plants, capacity) {\n let steps = 0;\n const CAPACITY = capacity;\n\n for (let i = 0; i < plants.length; i++) {\n steps++;\n capacity -= plants[i];\n\n if (i < plants.length - 1 && capacity < plants[i + 1]) {\n steps += i + 1;\n steps += i + 1;\n capacity = CAPACITY;\n }\n }\n\n return steps;\n}\n"
},
{
"path": "coding_interviews/python/string.py",
"content": "# length of a string\nlen('a string') # 8\n\n# concatenate strings\ns1 = 'string 1'\ns2 = 'string 2'\ns3 = s1 + s2 # 'string 1string 2'\n\n# indexing\ns1 = 'string 1'\ns1[3] # 'i'\n\n# slicing\ns1 = 'string 1'\ns1[:3] # 'str'\ns1[2:] # 'ring 1'\n\n# striping a string\ns = ' a string '\ns.strip() # 'a string'\n\n# string in string\ns1 = 'string 1'\ns2 = 'string'\ns3 = 'other'\ns2 in s1 # True\ns3 in s1 # False\n"
},
{
"path": "coding_interviews/top-problems/are-anagrams.js",
"content": "// Time Complexity: O(N) where N is the size of the string\n// more precisely, it should be O(N1) + O(N2) where N1 = length of string1 and N2 = length of string2\n// Space Complexity: O(N) where N is the size of the string\n\nfunction hasDifferentLengths(string1, string2) {\n return string1.length !== string2.length;\n}\n\nfunction buildCharsCount(string) {\n let charactersCounter = {};\n\n for (let char of string) {\n if (charactersCounter[char]) {\n charactersCounter[char]++;\n } else {\n charactersCounter[char] = 1;\n }\n }\n\n return charactersCounter;\n}\n\nexport function areAnagrams(string1, string2) {\n if (hasDifferentLengths(string1, string2)) return false;\n\n let charactersCounter1 = buildCharsCount(string1);\n let charactersCounter2 = buildCharsCount(string2);\n\n for (let char of Object.keys(charactersCounter1)) {\n if (charactersCounter1[char] !== charactersCounter2[char]) {\n return false;\n }\n }\n\n return true;\n}\n"
},
{
"path": "coding_interviews/top-problems/first-and-last-index.js",
"content": "/*\nGiven a sorted array of integers `arr` and an integer target,\nfind the index of the first and last position of target in `arr`.\nIn target can't be found in `arr`, return [-1, -1]\n*/\n\n// Runtime: O(N)\n// Space: O(1)\n\nexport function firstAndLastIndex(list, target) {\n let first = -1;\n let last = -1;\n\n for (let index = 0; index < list.length; index++) {\n if (list[index] === target) {\n first = index;\n break;\n }\n }\n\n for (let index = list.length; index >= 0; index--) {\n if (list[index] === target) {\n last = index;\n break;\n }\n }\n\n return [first, last];\n}\n\n// Runtime: O(logN)\n// Space: O(1)\n\nfunction getMiddle(start, end) {\n return Math.floor((start + end) / 2);\n}\n\nfunction findIndex(list, target, type) {\n let start = 0;\n let end = list.length - 1;\n let middle = getMiddle(start, end);\n let index = -1;\n\n while (start <= end) {\n if (target > list[middle]) {\n start = middle + 1;\n middle = getMiddle(start, end);\n }\n\n if (target < list[middle]) {\n end = middle - 1;\n middle = getMiddle(start, end);\n }\n\n if (target === list[middle]) {\n index = middle;\n\n if (type === 'findFirst') {\n end = middle - 1;\n }\n\n if (type === 'findLast') {\n start = middle + 1;\n }\n\n middle = getMiddle(start, end);\n }\n }\n\n return index;\n}\n\nfunction findFirstIndex(list, target) {\n return findIndex(list, target, 'findFirst');\n}\n\nfunction findLastIndex(list, target) {\n return findIndex(list, target, 'findLast');\n}\n\nexport function firstAndLastIndexBinarySearch(list, target) {\n return [findFirstIndex(list, target), findLastIndex(list, target)];\n}\n"
},
{
"path": "coding_interviews/top-problems/kth-largest.js",
"content": "// Given an array of integers `arr` and an integer `k`, find the kth largest element\n\n// Runtime: O(NlogN)\n// Space: O(1)\nexport function kthLargest(list, k) {\n return list.sort((num1, num2) => num1 - num2)[list.length - k];\n}\n"
},
{
"path": "coding_interviews/top-problems/min-sliding-window.js",
"content": "function buildCharsCounter(s) {\n let charsCounter = {};\n\n for (let char of s) {\n if (charsCounter[char]) {\n charsCounter[char]++;\n } else {\n charsCounter[char] = 1;\n }\n }\n\n return charsCounter;\n}\n\nfunction compare(s1, s2) {\n let chars1 = buildCharsCounter(s1);\n let chars2 = buildCharsCounter(s2);\n\n for (let [char, counter] of Object.entries(chars1)) {\n if (chars2[char] == undefined || chars2[char] > counter) {\n return false;\n }\n }\n\n return true;\n}\n\nfunction minSlidingWindow(s, t) {\n for (let i = 0; i < s.length - t.length; i++) {\n for (let j = i + t.length; j < s.length; j++) {\n const substring = s.slice(i, j);\n }\n }\n}\n\nminSlidingWindow('adcfebeceabebadfcdfcbfcbead', 'abca');\n"
},
{
"path": "coding_interviews/top-problems/tests/are-anagrams.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport { areAnagrams } from '../are-anagrams';\n\ndescribe('areAnagrams', () => {\n it('', () => {\n expect(areAnagrams('', '')).toBeTruthy();\n });\n\n it('', () => {\n expect(areAnagrams('a', 'a')).toBeTruthy();\n });\n\n it('', () => {\n expect(areAnagrams('bla', 'alb')).toBeTruthy();\n });\n\n it('', () => {\n expect(areAnagrams('hahahehe', 'hehehaha')).toBeTruthy();\n });\n\n it('', () => {\n expect(areAnagrams('a', 'b')).toBeFalsy();\n });\n\n it('', () => {\n expect(areAnagrams('aa', 'a')).toBeFalsy();\n });\n\n it('', () => {\n expect(areAnagrams('bla', 'elb')).toBeFalsy();\n });\n\n it('', () => {\n expect(areAnagrams(' ', ' ')).toBeFalsy();\n });\n});\n"
},
{
"path": "coding_interviews/top-problems/tests/first-and-last-index.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport {\n firstAndLastIndex,\n firstAndLastIndexBinarySearch,\n} from '../first-and-last-index';\n\ndescribe('firstAndLastIndex', () => {\n it('', () => {\n expect(firstAndLastIndex([1, 1, 2, 3, 4, 5, 5, 5, 6, 7, 8, 9], 5)).toEqual([\n 5, 7,\n ]);\n });\n\n it('', () => {\n expect(firstAndLastIndex([1, 1, 2, 3, 4, 5, 5, 5, 6, 7, 8, 9], 4)).toEqual([\n 4, 4,\n ]);\n });\n\n it('', () => {\n expect(firstAndLastIndex([1, 1, 2, 3, 4, 5, 5, 5, 6, 8, 9], 7)).toEqual([\n -1, -1,\n ]);\n });\n});\n\ndescribe('firstAndLastIndexBinarySearch', () => {\n it('', () => {\n expect(\n firstAndLastIndexBinarySearch([1, 1, 2, 3, 4, 5, 5, 5, 6, 7, 8, 9], 5)\n ).toEqual([5, 7]);\n });\n\n it('', () => {\n expect(\n firstAndLastIndexBinarySearch([1, 1, 2, 3, 4, 5, 5, 5, 6, 7, 8, 9], 4)\n ).toEqual([4, 4]);\n });\n\n it('', () => {\n expect(\n firstAndLastIndexBinarySearch([1, 1, 2, 3, 4, 5, 5, 5, 6, 8, 9], 7)\n ).toEqual([-1, -1]);\n });\n});\n"
},
{
"path": "coding_interviews/top-problems/tests/kth-largest.test.js",
"content": "import { describe, expect, it } from 'vitest';\nimport { kthLargest } from '../kth-largest';\n\ndescribe('kthLargest', () => {\n it('', () => {\n expect(kthLargest([4, 2, 9, 7, 5, 6, 7, 1, 3], 4)).toEqual(6);\n });\n});\n"
},
{
"path": "college/graph/atoms.py",
"content": "import networkx as nx\nimport matplotlib.pyplot as plt\n\ndef plot_graph(graph, pos, title):\n plt.figure(figsize=(6, 6))\n nx.draw(graph, pos, with_labels=True, node_color='lightblue', node_size=2000, font_size=12, font_weight='bold', edge_color='gray')\n plt.title(title)\n plt.show()\n\n\n# H₂O\n# Adiciona vértices e conectas os átomos com arestas\n# Define as posições de cada átomo\n# Plota o grafo de água\nwater = nx.Graph()\nwater.add_nodes_from(['O', 'H1', 'H2'])\nwater.add_edges_from([('O', 'H1'), ('O', 'H2')])\nwater_pos = {'O': (0, 0), 'H1': (-1, -1), 'H2': (1, -1)}\nplot_graph(water, water_pos, '(H2O)')\n\n# CO₂\n# Adiciona vértices e conectas os átomos com arestas\n# Define as posições de cada átomo\n# Plota o grafo de CO₂\nco2 = nx.Graph()\nco2.add_nodes_from(['C', 'O1', 'O2'])\nco2.add_edges_from([('C', 'O1'), ('C', 'O2')])\nco2_pos = {'C': (0, 0), 'O1': (-1, 0), 'O2': (1, 0)}\nplot_graph(co2, co2_pos, '(CO2)')"
},
{
"path": "college/web/css/estilos.css",
"content": "body {\n background-color: #f7f9ac;\n}\n\nh1 {\n color: green;\n text-align: center;\n}\n\np.corpoDoTexto {\n color: blue;\n}\n\np.corpoDoTexto2 {\n color: red;\n}\n"
},
{
"path": "college/web/css/index.html",
"content": "\n\n \n \n CSS\n \n \n \n Título título título
\n \n Lorem Ipsum is simply dummy text of the printing and typesetting industry.\n
\n \n Lorem Ipsum is simply dummy text of the printing and typesetting industry.\n
\n \n\n"
},
{
"path": "college/web/index.html",
"content": "\n\n \n \n Título da página\n \n \n Título Principal - H1
\n Sub-título H2
\n Sub-título H3
\n Sub-título H4
\n Sub-título H5
\n Sub-título H6
\n Testando o parágrafo
\n \n\n"
},
{
"path": "college/web/js.js",
"content": "Math.max(1, 2); // 2\nMath.min(1, 2); // 1\nMath.pow(2, 2); // 4\nMath.sqrt(4); // 2\n"
},
{
"path": "college/web/loop.js",
"content": "let matrix = [];\n\nfor (let row = 1; row <= 4; row++) {\n let nums = [];\n let num = row + 1;\n\n for (let col = 1; col <= 5; col++) {\n nums.push(num);\n num += row + 1;\n }\n\n matrix.push(nums);\n}\n\nconsole.log(matrix);\n"
},
{
"path": "competitive-programming/4clojure/problem01.clj",
"content": "; http://www.4clojure.com/problem/1\n(= true true)\n"
},
{
"path": "competitive-programming/4clojure/problem02.clj",
"content": "; http://www.4clojure.com/problem/2\n(= (- 10 (* 2 3)) 4)\n"
},
{
"path": "competitive-programming/4clojure/problem03.clj",
"content": "; http://www.4clojure.com/problem/3#prob-title\n(= \"HELLO WORLD\" (.toUpperCase \"hello world\"))\n"
},
{
"path": "competitive-programming/4clojure/problem04.clj",
"content": ";; http://www.4clojure.com/problem/4\n\n(= (list :a :b :c) '(:a :b :c))\n"
},
{
"path": "competitive-programming/4clojure/problem05.clj",
"content": ";; http://www.4clojure.com/problem/5#prob-title\n\n(= '(1 2 3 4) (conj '(2 3 4) 1))\n(= '(1 2 3 4) (conj '(3 4) 2 1))\n"
},
{
"path": "competitive-programming/4clojure/problem06.clj",
"content": ";; http://www.4clojure.com/problem/6\n\n(= [:a :b :c] (list :a :b :c) (vec '(:a :b :c)) (vector :a :b :c))\n"
},
{
"path": "competitive-programming/4clojure/problem07.clj",
"content": ";; http://www.4clojure.com/problem/7\n\n(= [1 2 3 4] (conj [1 2 3] 4))\n(= [1 2 3 4] (conj [1 2] 3 4))\n"
},
{
"path": "competitive-programming/4clojure/problem19.clj",
"content": "; http://www.4clojure.com/problem/19\n\n; Solution 1\n(fn [coll]\n (loop [item (first coll)\n coll coll]\n (if (empty? (rest coll))\n item\n (recur (first (rest coll)) (rest coll)))))\n\n; Solution 2\n(fn [coll]\n (first (reverse coll)))\n\n; Solution 3\n#(first (reverse %))\n\n; Solution 4\n(comp first reverse)\n\n; Solution 5\n(fn [coll]\n (-> coll\n reverse\n first))\n\n; Solution 6\n(fn [coll]\n (loop [[item & remaining] coll]\n (if (empty? remaining)\n item\n (recur remaining))))\n"
},
{
"path": "competitive-programming/4clojure/problem20.clj",
"content": "; http://www.4clojure.com/problem/20\n\n(comp second reverse)\n"
},
{
"path": "competitive-programming/acm-icpc-br/regionals_2011/armstrong.cpp",
"content": "#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main()\n{\n\n long int n;\n scanf(\"%li\", &n);\n vector vetor;\n\n while (n != 0) {\n\n int total = 0, temp = n, teste, result=0;\n\n while (temp != 0) {\n teste = temp % 10;\n vetor.push_back(teste);\n temp = temp / 10;\n }\n\n for (int i = 2; i < 10; i++) {\n total = 0;\n for (int j = 0; j < vetor.size(); j++) {\n total += pow(vetor[j], i);\n }\n\n if (total == n) {\n result = i;\n break;\n }\n }\n\n if (result)\n cout << result << endl;\n else\n cout << \"N\" << endl;\n\n \tscanf(\"%li\", &n);\n vetor.clear();\n }\n\n return 0;\n}\n"
},
{
"path": "competitive-programming/acm-icpc-br/regionals_2011/calculadora.cpp",
"content": "#include\n#include \n\nusing namespace std;\n\nint main()\n{\n\n int ip1[4];\n int ip2[4];\n int mas[4];\n \n\n while (scanf(\"%i.%i.%i.%i %i.%i.%i.%i %i.%i.%i.%i\", &ip1[0],&ip1[1],&ip1[2],&ip1[3],&ip2[0],&ip2[1],&ip2[2],&ip2[3],&mas[0],&mas[1],&mas[2],&mas[3]) != -1) {\n int r = 1;\n int i = 0;\n for (i = 0; i < 4; i++)\n {\n \tif ((ip1[i] & mas[i]) != (ip2[i] & mas[i]))\n \t\tr = 0;\n }\n\n if (r)\n \tcout << \"S\" << endl;\n \telse\n \t\tcout << \"N\" << endl;\n }\n\n return 0;\n}\n"
},
{
"path": "competitive-programming/acm-icpc-br/regionals_2011/cartoes.cpp",
"content": "#include \n#include \n\nusing namespace std;\n\nint is_alberto_turn(int counter) {\n if (counter % 2 == 0)\n return 1;\n\n return 0;\n}\n\nint main() {\n\n int n, temp;\n vector v, vetor_a;\n\n cin >> n;\n\n for (int i = 0; i < n; i++) {\n cin >> temp;\n v.push_back(temp);\n }\n\n for (int i = 0; i < n; i++) {\n\n if (is_alberto_turn(i)) {\n if (v[0] > v.back()) {\n vetor_a.push_back(v[0]);\n v.erase(v.begin());\n } else {\n vetor_a.push_back(v.back());\n v.pop_back();\n }\n } else if (v.size() > 1) {\n if (v[0] > v.back())\n v.erase(v.begin());\n else\n v.pop_back();\n }\n }\n\n int total = 0;\n\n for (int i = 0; i < n; i++)\n total += vetor_a[i];\n\n cout << total << endl;\n\n return 0;\n}\n"
},
{
"path": "competitive-programming/acm-icpc-br/regionals_2011/concurso.cpp",
"content": "#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n\tint n, l, c, result;\n\tstring conto;\n\n\twhile (scanf(\"%d %d %d\", &n, &l, &c) != EOF) {\n\t\tcin.ignore();\n\t\tgetline(cin, conto);\n\n\t\tif (conto.size() == (l * c)) result = 1;\n\t\telse result = (conto.size() / (l * c)) + 1;\n\n\t\tcout << result << endl;\n\t}\n\n\treturn 0;\n}\n"
},
{
"path": "competitive-programming/acm-icpc-br/regionals_2011/coral.cpp",
"content": "#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nbool is_integer(float k) {\n return std::floor(k) == k;\n}\n\nbool all_equal(vector &vetorzin) {\n sort(vetorzin.begin(), vetorzin.end());\n\n return (vetorzin[0] == vetorzin.back());\n}\n\nint main() {\n\n int n, temp;\n float total=0;\n vector v;\n\n cin >> n;\n\n for (int i = 0; i < n; i++) {\n cin >> temp;\n total += temp;\n v.push_back(temp);\n }\n\n if (is_integer(total / n))\n cout << -1 << endl;\n else {\n if (all_equal(v))\n cout << 1 << endl;\n else {\n // algorithm to know how many times\n }\n }\n\n return 0;\n}\n"
},
{
"path": "competitive-programming/acm-icpc-br/regionals_2011/elevador.cpp",
"content": "#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nbool has_four(string number) {\n\t\n\tfor (int i = 0; i < number.length(); i++)\n\t\tif (number[i] == '4') return true;\n\n\treturn false;\n}\n\nbool has_thirteen(string number) {\t\n\n\tfor (int i = 0; i < number.length()-1; i++)\n\t\tif (number[i] == '1' && number[i+1] == '3') return true;\t\t\t\t\n\n\treturn false;\n}\n\nint main () {\n\n\tint n, total=0;\n\n\twhile (scanf(\"%d\", &n) != EOF) {\n\t\tostringstream converter;\n\t\tconverter << n;\n\t\tstring number = converter.str();\n\n\t\tfor (int i = 0; i < n; i++) {\n\t\t\tif (has_four(number) || has_thirteen(number)) total++;\n\t\t\tcout << total << endl;\n\t\t}\n\n\t\tcout << n + total << endl;\n\t\ttotal = 0;\n\t}\t\n\n\treturn 0;\n}"
},
{
"path": "competitive-programming/acm-icpc-br/regionals_2011/estacionamento.cpp",
"content": "#include \n#include \n\nusing namespace std;\n\nint main() {\n\n int v, p, result=0;\n\n cin >> v >> p;\n\n while (v + p != 0) {\n vector v1;\n vector< vector > v2;\n\n while (p--) {\n int he, me, hs, ms, found=0;\n cin >> he >> me >> hs >> ms;\n v1.push_back(he);\n v1.push_back(me);\n v1.push_back(hs);\n v1.push_back(ms);\n\n if (v > 0) {\n v2.push_back(v1);\n v--;\n } else {\n for (int i = 0; i < v2.size(); i++) {\n if (v1[0] > v2[i][2] || (v1[0] == v2[i][2] && v1[1] > v2[i][3])) {\n v2.push_back(v1);\n found = 1;\n break;\n }\n }\n\n if (!found) result++;\n }\n\n v1.clear();\n }\n\n cout << result << endl;\n cin >> v >> p;\n }\n\n return 0;\n}\n"
},
{
"path": "competitive-programming/acm-icpc-br/regionals_2011/extenso.cpp",
"content": "#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// stringstream ss;\n// string num1;\n// ss << n1[0];\n// ss >> num1;\n\nvoid split(string &n1, string &n2, string number) {\n\tint dot_index = number.find(\".\");\n\tn1 = number.substr(0, dot_index);\n\tn2 = number.substr(dot_index+1, number.size()-1);\n}\n\nstring transformNumberToCents(string cents) {\n\tstring result=\"\";\n\tstring ar[] = { \"DEZ\", \"ONZE\", \"DOZE\", \"TREZE\", \"QUATORZE\", \"QUINZE\", \"DEZESSEIS\", \"DEZESSETE\", \"DEZOITO\", \"DEZENOVE\" };\n\tstring um_a_nove[] = { \"UM\", \"DOIS\", \"TRES\", \"QUATRO\", \"CINCO\", \"SEIS\", \"SETE\", \"OITO\", \"NOVE\" };\n\tvector values(ar, ar + sizeof(ar)/sizeof(ar[0]));\n\tvector sec_values(um_a_nove, um_a_nove + sizeof(um_a_nove)/sizeof(um_a_nove[0]));\n\n\tstringstream ss;\n\tstring num1;\n\tss << cents[0];\n\tss >> num1;\n\tint cent_unit = stoi(num1);\n\n\tif \t\t\t(cents[0] == '0') result += sec_values[cent_unit-1];\n\telse if (cents[0] == '1') result += values[cent_unit];\n\telse if (cents[0] == '2') result += \"VINTE E \" + sec_values[cent_unit-1];\n\telse if (cents[0] == '3') result += \"TRINTA E \" + sec_values[cent_unit-1];\n\telse if (cents[0] == '4') result += \"QUARENTA E \" + sec_values[cent_unit-1];\n\telse if (cents[0] == '5') result += \"CINQUENTA E \" + sec_values[cent_unit-1];\n\telse if (cents[0] == '6') result += \"SESSENTA E \" + sec_values[cent_unit-1];\n\telse if (cents[0] == '7') result += \"SETENTA E \" + sec_values[cent_unit-1];\n\telse if (cents[0] == '8') result += \"OITENTA E \" + sec_values[cent_unit-1];\n\telse if (cents[0] == '9') result += \"NOVENTA E \" + sec_values[cent_unit-1];\n\n\treturn result;\n}\n\nstring transformNumberToReal(string reais) {\n\tstring result=\"\";\n\n\tstring um_a_nove[] = { \"UM\", \"DOIS\", \"TRES\", \"QUATRO\", \"CINCO\", \"SEIS\", \"SETE\", \"OITO\", \"NOVE\" };\n\tvector sec_values(um_a_nove, um_a_nove + sizeof(um_a_nove)/sizeof(um_a_nove[0]));\n\n\tstring ar[] = { \"DEZ\", \"ONZE\", \"DOZE\", \"TREZE\", \"QUATORZE\", \"QUINZE\", \"DEZESSEIS\", \"DEZESSETE\", \"DEZOITO\", \"DEZENOVE\" };\n\tvector values(ar, ar + sizeof(ar)/sizeof(ar[0]));\n\n\tstring dez_a_noventa[] = { \"VINTE\", \"TRINTA\", \"QUARENTA\", \"CINQUENTA\", \"SESSENTA\", \"SETENTA\", \"OITENTA\", \"NOVENTA\" };\n\tvector dicker(dez_a_noventa, dez_a_noventa + sizeof(dez_a_noventa)/sizeof(dez_a_noventa[0]));\n\n\tstring cem_a_novecentos[] = { \"CENTO\", \"DUZENTOS\", \"TREZENTOS\", \"QUATROCENTOS\", \"QUINHENTOS\", \"SEICENTOS\", \"SETECENTOS\", \"OITOCENTOS\", \"NOVECENTOS\" };\n\tvector hundred(cem_a_novecentos, cem_a_novecentos + sizeof(cem_a_novecentos)/sizeof(cem_a_novecentos[0]));\n\n\tif (reais.size() == 1) {\n\t\tresult += sec_values[stoi(reais)-1];\n\t}\telse if (reais.size() == 2) {\n\t\tstringstream ss; string n1, n2;\n\t\tss << reais[0]; ss >> n1;\n\t\tss << reais[1]; ss >> n2;\n\t\tif (reais[0] == '1') {\n\t\t\tresult += values[stoi(n2)];\n\t\t}\telse {\n\t\t\tresult += dicker[stoi(n1)-1] + \" E \" + sec_values[stoi(n2)-1];\n\t\t}\n\t} else if (reais.size() == 3) {\n\t\tstringstream ss; string n1, n2, n3;\n\t\tss << reais[0]; ss >> n1;\n\t\tss << reais[1]; ss >> n2;\n\t\tss << reais[2]; ss >> n3;\n\t\tresult += hundred[stoi(n1)-1] + \" E \" + dicker[stoi(n2)-1] + \" E \" + sec_values[stoi(n3)-1];\n\t}\telse if (reais.size() == 4){\n\t\tstringstream ss; string n1, n2, n3, n4;\n\t\tss << reais[0]; ss >> n1;\n\t\tss << reais[1]; ss >> n2;\n\t\tss << reais[2]; ss >> n3;\n\t\tss << reais[3]; ss >> n4;\n\t\tresult += sec_values[stoi(n1)-1] + \" MIL E \" + hundred[stoi(n2)-1] + \" E \" + dicker[stoi(n3)-1] + \" E \" + sec_values[stoi(n4)-1];\n\t}\telse if (reais.size() == 5) {\n\t\tstringstream ss; string n1, n2, n3, n4, n5;\n\t\tss << reais[0]; ss >> n1;\n\t\tss << reais[1]; ss >> n2;\n\t\tss << reais[2]; ss >> n3;\n\t\tss << reais[3]; ss >> n4;\n\t\tss << reais[4]; ss >> n5;\n\t\tif (reais[0] == '1') {\n\t\t\tresult += values[stoi(n2)] + \" MIL E \" + hundred[stoi(n3)-1] + \" E \" + dicker[stoi(n4)-1] + \" E \" + sec_values[stoi(n5)-1];\n\t\t}\telse {\n\t\t\tresult += dicker[stoi(n1)-1] + \" E \" + sec_values[stoi(n2)-1]; + \" MIL E \" + hundred[stoi(n3)-1] + \" E \" + dicker[stoi(n4)-1] + \" E \" + sec_values[stoi(n5)-1];\n\t\t}\n\t}\telse if (reais.size() == 6) {\n\t\tstringstream ss; string n1, n2, n3, n4, n5, n6;\n\t\tss << reais[0]; ss >> n1;\n\t\tss << reais[1]; ss >> n2;\n\t\tss << reais[2]; ss >> n3;\n\t\tss << reais[3]; ss >> n4;\n\t\tss << reais[4]; ss >> n5;\n\t\tss << reais[5]; ss >> n6;\n\t\tresult += hundred[stoi(n1)-1] + \" E \" + dicker[stoi(n2)-1] + \" E \" + sec_values[stoi(n3)-1] + \" MIL E\" + hundred[stoi(n4)-1] + \" E \" + dicker[stoi(n5)-1] + \" E \" + sec_values[stoi(n6)-1];\n\t}\telse {\n\t\tresult += \"UM MILHAO\";\n\t}\n\n\treturn result;\n}\n\nint main() {\n\n\tstring number;\n\tcin >> number;\n\n\twhile(number != \"0.00\") {\n\t\tstring n1, n2, result=\"\";\n\n\t\tsplit(n1, n2, number);\n\n\t\tn1 = transformNumberToReal(n1);\n\t\tn2 = transformNumberToCents(n2);\n\n\t\tif (n1 == \"0\") {\n\t\t\tif (n2 == \"01\")\n\t\t\t\tresult += n2 + \" CENTAVO\";\n\t\t\telse\n\t\t\t\tresult += n2 + \" CENTAVOS\";\n\t\t} else if (n1 == \"1\") {\n\t\t\tif (n2 == \"00\")\n\t\t\t\tresult += n1 + \" REAL\";\n\t\t\telse if (n2 == \"01\")\n\t\t\t\tresult += n1 + \" REAL E \" + n2 + \" CENTAVO\";\n\t\t\telse\n\t\t\t\tresult += n1 + \" REAL E \" + n2 + \" CENTAVOS\";\n\t\t} else {\n\t\t\tif (n2 == \"00\")\n\t\t\t\tresult += n1 + \" REAIS\";\n\t\t\telse if (n2 == \"01\")\n\t\t\t\tresult += n1 + \" REAIS E \" + n2 + \" CENTAVO\";\n\t\t\telse\n\t\t\t\tresult += n1 + \" REAIS E \" + n2 + \" CENTAVOS\";\n\t\t}\n\n\t\tcout << result;\n\t\tcin >> number;\n\t}\n\n\treturn 0;\n}\n"
},
{
"path": "competitive-programming/acm-icpc-br/regionals_2011/goldbach.cpp",
"content": "#include\n#include \n#include \n\nusing namespace std;\n\nint verifica_primo(int n) {\n\tint total_divisivel = 0;\n\n\n\tif (n == 2) {\n\t\treturn 1;\n\t}\n\tif ((n % 2) == 0)\n\t\treturn 0;\n\n\n\tint s = sqrt(n);\n\n\tfor (int i = 3; i <= s; i += 2) {\n\t\tif (n % i == 0){\n\t\t\treturn 0;\n\t\t}\n\t}\n\n\treturn 1;\n}\n\nint main()\n{\n \n\n int n, n1, n2;\n scanf(\"%i\", &n);\n\n while (n != 0) {\n\n \tif (n % 2 != 0)\n \t\tcout << \"erro\" << endl;\n \telse {\n \t\tfor (int i = 2; i <= n; i++) {\n \t\t\tif (verifica_primo(i)) {\n \t\t\t\tn1 = i;\n \t\t\t\tif (verifica_primo(n-n1)) {\n \t\t\t\t\tn2 = n - n1;\n \t\t\t\t\tbreak;\n \t\t\t\t}\n \t\t\t}\n \t\t}\n\n \t\tcout << n1 << \" \" << n2 << endl;\n \t}\n\n \tscanf(\"%i\", &n);\n }\n\n return 0;\n}\n"
},
{
"path": "competitive-programming/acm-icpc-br/regionals_2011/matriz_esparsa.cpp",
"content": "#include \n\nusing namespace std;\n\nint main() {\n\t\n\tint n, x, total, zeros, medium;\n\tcin >> n;\n\n\twhile (n--) {\n\t\tcin >> x;\n\t\ttotal = x * x;\n\t\tzeros = total - (3 * x - 2);\n\t\tmedium = total / 2;\n\t\tif (zeros > medium) cout << \"S \" << zeros << endl;\n\t\telse cout << \"N \" << zeros << endl;\n\t}\n\n\treturn 0;\n}"
},
{
"path": "competitive-programming/acm-icpc-br/regionals_2011/pascal.cpp",
"content": "#include \r\n\r\nusing namespace std;\r\n\r\nint triangulo_pascal(int n, int m) {\r\n\r\n\tif ((m == 0 || n == 0) || (m == 1 && n == 1) || (m == n))\r\n\t\treturn 1;\r\n\t\t\r\n\treturn triangulo_pascal(n - 1, m) + triangulo_pascal(n - 1, m - 1);\r\n}\r\n\r\nint main() {\r\n\r\n\tint n, x, y;\r\n\r\n\tcin >> n;\r\n\t\r\n\twhile (n--) {\r\n\r\n\t\tcin >> x;\r\n\t\tcin >> y;\r\n\t\t\r\n\t\tcout << triangulo_pascal(x, y) << endl;\r\n\t}\t\r\n\r\n\treturn 0;\r\n}"
},
{
"path": "competitive-programming/acm-icpc-br/regionals_2011/polinomio.cpp",
"content": "#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint solvePartEquation(string part_equation, int value) {\n int result, inicio=0, constante, expo;\n\n int x = part_equation.find(\"x\");\n stringstream ss1; ss1 << part_equation.substr(0, x); ss1 >> constante;\n stringstream ss2; ss2 << part_equation.substr(x+1, part_equation.size()-x); ss2 >> expo; \n\n result = constante * (pow(value, expo));\n\n return result;\n}\n\nint main() {\n\n int n, time=1, i_inicio=0, total;\n string temp;\n vector vetor_de_valores, vetor_de_variaveis, vetor_de_sinais;\n vector vetor_de_resultados;\n\n cin >> n;\n\n while (n--) {\n string equacao;\n int number_of_values;\n\n cin >> equacao;\n cin >> number_of_values;\n\n for (int i = 0; i < number_of_values; i++){\n cin >> temp;\n vetor_de_valores.push_back(temp);\n }\n\n for (int i = 0; i < equacao.size(); i++) {\n if (equacao[i] == '+' || equacao[i] == '-') {\n vetor_de_variaveis.push_back(equacao.substr(i_inicio, i-i_inicio));\n vetor_de_sinais.push_back(equacao.substr(i, 1));\n i_inicio = i+1;\n }\n }\n\n for (int i = 0; i < vetor_de_valores.size(); i++) {\n int valor;\n stringstream ss; ss << vetor_de_valores[i]; ss >> valor; \n total = solvePartEquation(vetor_de_variaveis[0], valor);\n for (int j = 1; j < vetor_de_variaveis.size(); j++){\n if (vetor_de_sinais[j-1] == \"+\")\n total += solvePartEquation(vetor_de_variaveis[j], valor);\n else\n total -= solvePartEquation(vetor_de_variaveis[j], valor);\n\n vetor_de_resultados.push_back(total);\n }\n }\n\n cout << \"Caso \" << time << \": \";\n for (int i = 0; vetor_de_resultados.size(); i++)\n cout << vetor_de_resultados[i] << \" \";\n\n cout << endl;\n time++;\n }\n\n\n return 0;\n}\n"
},
{
"path": "competitive-programming/acm-icpc-br/regionals_2011/quadrado.cpp",
"content": "#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n\n\tint n;\n\tvector v;\n\tcin >> n;\n\t\n\twhile (n--) {\n\t\tint temp;\n\t\t\n\t\tfor (int i = 0; i < 4; i++) {\n\t\t\tcin >> temp;\n\t\t\tv.push_back(temp);\n\t\t}\n\t\t\t\n\t\tsort(v);\n\t\t\n\t\tif (v[0] == v[1] && v[0] == v[2] && v[0] == v[3]) cout << \"quadrado\" << endl;\n\t\telse if (v[0] == v[1] && v[2] == v[3]) cout << \"retangulo\" << endl;\n\t\telse if (v[0] + v[1] + v[2] > v[3]) cout << \"quadrilatero\" << endl;\n\t\telse cout << \"invalido\" << endl;\n\t}\n\n\treturn 0;\n}"
},
{
"path": "competitive-programming/acm-icpc-br/regionals_2011/vagas.cpp",
"content": "#include \r\n\r\nusing namespace std;\r\n\r\nint main() {\r\n\r\n\tint c, total;\r\n\t\r\n\tcin >> c;\r\n\t\r\n\twhile (c != -1) {\r\n\t\r\n\t\ttotal = (c - 6) / 5;\r\n\t\tcout << total << endl;\r\n\t\t\r\n\t\tcin >> c;\r\n\t}\r\n\r\n\r\n\treturn 0;\r\n}"
},
{
"path": "competitive-programming/acm-icpc-br/regionals_2017_1/A.cpp",
"content": "#include \n\nusing namespace std;\n\n#define MAX_SIZE (1 << 20)\n\nint segtree[MAX_SIZE];\nint lazy[MAX_SIZE];\n\nvoid build_segtree(int A[], int node, int start, int end) {\n if (start == end) {\n segtree[node] = A[start];\n } else {\n int middle = (start + end) / 2;\n build_segtree(A, node * 2, start, middle);\n build_segtree(A, node * 2 + 1, middle + 1, end);\n }\n}\n\nvoid propagate(int p, int start, int end) {\n if (lazy[p] != 0) {\n segtree[p] += lazy[p];\n\n if (start != end) {\n lazy[p * 2] += lazy[p];\n lazy[p * 2 + 1] += lazy[p];\n }\n\n lazy[p] = 0;\n }\n}\n\nvoid lazy_update(int p, int start, int end, int left, int right, int inc) {\n propagate(p, start, end);\n\n if (start > end || end < left || start > right) return; // Totally out of range\n\n if (start >= left && end <= right) { // Totally in the range\n segtree[p] += inc;\n\n if (start != end) { // Not a leaf\n lazy[p * 2] += inc;\n lazy[p * 2 + 1] += inc;\n }\n\n return;\n }\n\n // Partially in the range\n int middle = (start + end) / 2;\n lazy_update(p * 2, start, middle, left, right, inc);\n lazy_update(p * 2 + 1, middle + 1, end, left, right, inc);\n}\n\nint lazy_query(int p, int start, int end, int left, int right) {\n if (start > end || left > end || right < start) return -1;\n\n propagate(p, start, end);\n\n if (start >= left && end <= right) return segtree[p];\n\n int middle = (end + start) / 2;\n int left_f = lazy_query(p * 2, start, middle, left, right);\n int right_f = lazy_query(p * 2 + 1, middle + 1, end, left, right);\n}\n\nvoid print_all_leaves(int p, int start, int end) {\n if (start > end) return;\n propagate(p, start, end);\n if (start == end) cout << segtree[p] << endl;\n\n int middle = (start + end) / 2;\n print_all_leaves(p * 2, start, middle);\n print_all_leaves(p * 2 + 1, middle + 1, end);\n}\n\nint main() {\n int N, C, left, right, most_frequent;\n cin >> N >> C;\n\n int A[N];\n for (int i = 0; i < N; i++) A[i] = 1;\n\n build_segtree(A, 1, 0, N - 1);\n\n while (C--) {\n cin >> left >> right;\n most_frequent = lazy_query(1, 0, N - 1, left, right);\n lazy_update(1, 0, N - 1, left, right, most_frequent);\n }\n\n //print_all_leaves(1, 0, N - 1);\n\n return 0;\n}\n"
},
{
"path": "competitive-programming/acm-icpc-br/regionals_2017_2/D.cpp",
"content": "#include \n\nusing namespace std;\n\nbool is_prime(int N) {\n return true;\n}\n\nint main() {\n int N;\n cin >> N;\n\n if (is_prime(N)) {\n cout << 0 << endl;\n } else {\n \n }\n\n return 0;\n}\n"
},
{
"path": "competitive-programming/acm-icpc-br/regionals_2017_2/F.cpp",
"content": "#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n int N, M, num;\n vector V;\n\n cin >> N >> M;\n\n while (N--) {\n cin >> num;\n V.push_back(num);\n }\n\n sort(V.begin(), V.end(), greater());\n\n int result = M;\n\n for (int i = M; i < V.size(); i++) {\n if (V[i] == V[i-1]) result++;\n else break;\n }\n\n cout << result << endl;\n\n return 0;\n}\n"
},
{
"path": "competitive-programming/acm-icpc-br/regionals_2017_2/J.py",
"content": "n = input()\nprint n % 3\n"
},
{
"path": "competitive-programming/acm-icpc-br/regionals_2017_2/M.cpp",
"content": "#include \n\nusing namespace std;\n\nint main() {\n int N1, N2, N3;\n\n cin >> N1 >> N2 >> N3;\n\n int one = N2 * 2 + N3 * 4,\n two = N1 * 2 + N3 * 2,\n three = N1 * 4 + N2 * 2;\n\n if (one <= two && one <= three) cout << one << endl;\n else if (two <= three) cout << two << endl;\n else cout << three << endl;\n\n return 0;\n}\n"
},
{
"path": "competitive-programming/codeforces/div2/black_square.cpp",
"content": "// http://codeforces.com/problemset/problem/828/B\n\n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n int N, M, black = 0,\n smaller_black_x = 101,\n smaller_black_y = 101,\n bigger_black_x = -1,\n bigger_black_y = -1,\n result_square,\n bigger_side;\n\n vector matrix;\n string line;\n cin >> N >> M;\n cin.ignore();\n\n for (int i = 0; i < N; i++) {\n getline(cin, line);\n matrix.push_back(line);\n }\n\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < M; j++) {\n if (matrix[i][j] == 'B') {\n if (i < smaller_black_y) smaller_black_y = i;\n if (i > bigger_black_y) bigger_black_y = i;\n if (j < smaller_black_x) smaller_black_x = j;\n if (j > bigger_black_x) bigger_black_x = j;\n black++;\n }\n }\n }\n\n if (black == 0) {\n cout << 1 << endl;\n return 0;\n }\n\n bigger_side = max(bigger_black_x - smaller_black_x + 1, bigger_black_y - smaller_black_y + 1);\n\n if (bigger_side > N || bigger_side > M) cout << -1 << endl;\n else cout << bigger_side * bigger_side - black << endl;\n\n return 0;\n}\n"
},
{
"path": "competitive-programming/codeforces/div2/karen_and_morning.cpp",
"content": "// http://codeforces.com/contest/816/problem/A\n\n#include \n#include \n\nusing namespace std;\n\nint to_digit(char c) {\n return c - '0';\n}\n\nint main() {\n string hour;\n cin >> hour;\n\n int hour_decimal = to_digit(hour[0]),\n hour_unit = to_digit(hour[1]),\n minute_decimal = to_digit(hour[3]),\n minute_unit = to_digit(hour[4]),\n hour_int, minute;\n\n hour_int = hour_decimal * 10 + hour_unit;\n minute = minute_decimal * 10 + minute_unit;\n\n if (hour_int == minute_unit * 10 + minute_decimal) cout << 0 << endl;\n else if (hour_int == 1 && minute < 10) cout << 10 - minute << endl;\n else if ((hour_int == 0 ||hour_int == 1 || hour_int == 2 || hour_int == 3 || hour_int == 4 || hour_int == 5 ||\n hour_int == 10 || hour_int == 11 || hour_int == 12 || hour_int == 13 || hour_int == 14 || hour_int == 15 ||\n hour_int == 20 || hour_int == 21 || hour_int == 22 || hour_int == 23)\n && minute > 10) cout << 70 - minute << endl;\n else if ((hour_int == 0 ||hour_int == 1 || hour_int == 2 || hour_int == 3 || hour_int == 4 ||\n hour_int == 10 || hour_int == 11 || hour_int == 12 || hour_int == 13 || hour_int == 14 ||\n hour_int == 20 || hour_int == 21 || hour_int == 22 || hour_int == 23)\n && minute > 10)\n\n return 0;\n}\n"
},
{
"path": "competitive-programming/codeforces/div2/keyboard_layouts.cpp",
"content": "// http://codeforces.com/problemset/problem/831/B\n\n#include \n#include \n\nusing namespace std;\n\nbool is_uppercase(char word) {\n string original_alphabet = \"ABCDEFGHIJKLMNOPQRSTUVXWYZabcdefghijklmnopqrstuvxwyz\";\n return original_alphabet.find(word) < 26;\n}\n\nchar build_new_word(char letter, string alpha1, string alpha2) {\n string original_alphabet = \"ABCDEFGHIJKLMNOPQRSTUVXWYZabcdefghijklmnopqrstuvxwyz\", numbers = \"0123456789\";\n\n if (numbers.find(letter) >= 0 && numbers.find(letter) <= 9)\n return letter;\n else if (is_uppercase(letter)) {\n char l = original_alphabet[original_alphabet.find(letter) + 26];\n int index = alpha1.find(l);\n char new_l = alpha2[index];\n return original_alphabet[original_alphabet.find(new_l) - 26];\n }\n\n return alpha2[alpha1.find(letter)];\n}\n\nint main() {\n string alpha1, alpha2, word, result;\n\n cin >> alpha1 >> alpha2 >> word;\n\n for (int i = 0; i < word.size(); i++) {\n result += build_new_word(word[i], alpha1, alpha2);\n }\n\n cout << result << endl;\n\n return 0;\n}\n"
},
{
"path": "competitive-programming/codeforces/div2/the_child_and_the_homework.cpp",
"content": "// http://codeforces.com/contest/437/problem/A\n\n#include \n\nusing namespace std;\n\nstring solve(string a, string b, string c, string d) {\n bool a_smaller = (a.size()-2 <= (b.size()-2) / 2) && (a.size()-2 <= (c.size()-2) / 2) && (a.size()-2 <= (d.size()-2) / 2),\n a_bigger = (a.size()-2 >= (b.size()-2) * 2) && (a.size()-2 >= (c.size()-2) * 2) && (a.size()-2 >= (d.size()-2) * 2),\n b_smaller = (b.size()-2 <= (a.size()-2) / 2) && (b.size()-2 <= (c.size()-2) / 2) && (b.size()-2 <= (d.size()-2) / 2),\n b_bigger = (b.size()-2 >= (a.size()-2) * 2) && (b.size()-2 >= (c.size()-2) * 2) && (b.size()-2 >= (d.size()-2) * 2),\n c_smaller = (c.size()-2 <= (a.size()-2) / 2) && (c.size()-2 <= (b.size()-2) / 2) && (c.size()-2 <= (d.size()-2) / 2),\n c_bigger = (c.size()-2 >= (a.size()-2) * 2) && (c.size()-2 >= (b.size()-2) * 2) && (c.size()-2 >= (d.size()-2) * 2),\n d_smaller = (d.size()-2 <= (a.size()-2) / 2) && (d.size()-2 <= (b.size()-2) / 2) && (d.size()-2 <= (c.size()-2) / 2),\n d_bigger = (d.size()-2 >= (b.size()-2) * 2) && (d.size()-2 >= (a.size()-2) * 2) && (d.size()-2 >= (c.size()-2) * 2);\n\n vector great_choices;\n if (a_bigger || a_smaller) great_choices.push_back(\"A\");\n if (b_bigger || b_smaller) great_choices.push_back(\"B\");\n if (c_bigger || c_smaller) great_choices.push_back(\"C\");\n if (d_bigger || d_smaller) great_choices.push_back(\"D\");\n if (great_choices.size() == 1) return great_choices[0];\n return \"C\";\n}\n\nint main() {\n string a, b, c, d;\n\n cin >> a >> b >> c >> d;\n\n cout << solve(a, b, c, d) << endl;\n\n return 0;\n}\n"
},
{
"path": "competitive-programming/codeforces/div2/the_child_and_toy.cpp",
"content": "// http://codeforces.com/contest/437/problem/C\n\n#include \n\nusing namespace std;\n\nint min(int x, int y, int values[]) {\n return values[x-1] < values[y-1] ? values[x-1] : values[y-1];\n}\n\nint main() {\n int n, m, x, y, value, min_energy = 0;\n cin >> n >> m;\n\n int values[n];\n\n for (int i = 0; i < n; i++) {\n cin >> value;\n values[i] = value;\n }\n\n while (m--) {\n cin >> x >> y;\n min_energy += min(x, y, values);\n }\n\n cout << min_energy << endl;\n\n return 0;\n}\n"
},
{
"path": "competitive-programming/codeforces/div2/valera_and_plates.cpp",
"content": "// http://codeforces.com/problemset/problem/369/A\n\n#include \n\nusing namespace std;\n\nint main() {\n int N, M, K, num, W = 0;\n cin >> N >> M >> K;\n\n while (N--) {\n cin >> num;\n\n if (num == 1) {\n if (M == 0) W++;\n else M--;\n } else {\n if (K == 0) {\n if (M == 0) W++;\n else M--;\n } else {\n K--;\n }\n }\n }\n\n cout << W << endl;\n\n return 0;\n}\n"
},
{
"path": "competitive-programming/exercism/clojure/armstrong-numbers/.exercism/metadata.json",
"content": "{\"track\":\"clojure\",\"exercise\":\"armstrong-numbers\",\"id\":\"c708010a47824f9daeddb51af2f51b2f\",\"url\":\"https://exercism.io/my/solutions/c708010a47824f9daeddb51af2f51b2f\",\"handle\":\"LeandroTk\",\"is_requester\":true,\"auto_approve\":false}"
},
{
"path": "competitive-programming/exercism/clojure/armstrong-numbers/.lein-failures",
"content": "{}"
},
{
"path": "competitive-programming/exercism/clojure/armstrong-numbers/.lein-repl-history",
"content": "(defn int->digits [int]\n (map (comp #(- % 48) int) (str int)))\n(defn power-by-two [digits]\n (map #(* % (count digits)) digits))\n(defn powered-sum [num]\n (->> num\n int->digits\n power-by-two\n (reduce +)))\n(defn armstrong? [num]\n (= (powered-sum num) num))\n(armstrong? 123)\n(int->digits 123)\nquit\n"
},
{
"path": "competitive-programming/exercism/clojure/armstrong-numbers/README.md",
"content": "# Armstrong Numbers\n\nAn [Armstrong number](https://en.wikipedia.org/wiki/Narcissistic_number) is a number that is the sum of its own digits each raised to the power of the number of digits.\n\nFor example:\n\n- 9 is an Armstrong number, because `9 = 9^1 = 9`\n- 10 is *not* an Armstrong number, because `10 != 1^2 + 0^2 = 1`\n- 153 is an Armstrong number, because: `153 = 1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153`\n- 154 is *not* an Armstrong number, because: `154 != 1^3 + 5^3 + 4^3 = 1 + 125 + 64 = 190`\n\nWrite some code to determine whether a number is an Armstrong number.\n## Source\n\nWikipedia [https://en.wikipedia.org/wiki/Narcissistic_number](https://en.wikipedia.org/wiki/Narcissistic_number)\n\n## Submitting Incomplete Solutions\nIt's possible to submit an incomplete solution so you can see how others have completed the exercise.\n"
},
{
"path": "competitive-programming/exercism/clojure/armstrong-numbers/project.clj",
"content": "(defproject armstrong-numbers \"0.1.0-SNAPSHOT\"\n :description \"armstrong-numbers exercise\"\n :url \"https://github.com/exercism/clojure/tree/master/exercises/armstrong-numbers\"\n :dependencies [[org.clojure/clojure \"1.10.0\"]])\n"
},
{
"path": "competitive-programming/exercism/clojure/armstrong-numbers/src/armstrong_numbers.clj",
"content": "(ns armstrong-numbers)\n\n(defn int->digits [num]\n (map (comp #(- % 48) int) (str num)))\n\n(defn power-by-two [digits digit]\n (reduce * (repeat (count digits) digit)))\n\n(defn power-all-by-two [digits]\n (map (partial power-by-two digits) digits))\n\n(defn powered-sum [num]\n (->> num\n int->digits\n power-all-by-two\n (reduce +)))\n\n(defn armstrong? [num]\n (= (powered-sum num) num))\n"
},
{
"path": "competitive-programming/exercism/clojure/armstrong-numbers/target/classes/META-INF/maven/armstrong-numbers/armstrong-numbers/pom.properties",
"content": "#Leiningen\n#Thu Jan 31 22:57:53 BRST 2019\ngroupId=armstrong-numbers\nartifactId=armstrong-numbers\nversion=0.1.0-SNAPSHOT\n"
},
{
"path": "competitive-programming/exercism/clojure/armstrong-numbers/target/stale/leiningen.core.classpath.extract-native-dependencies",
"content": "[{:dependencies {org.clojure/clojure {:vsn \"1.10.0\", :native-prefix nil}, org.clojure/spec.alpha {:vsn \"0.2.176\", :native-prefix nil}, org.clojure/core.specs.alpha {:vsn \"0.2.44\", :native-prefix nil}, nrepl {:vsn \"0.5.3\", :native-prefix nil}, nrepl/bencode {:vsn \"1.0.0\", :native-prefix nil}, clojure-complete {:vsn \"0.2.5\", :native-prefix nil}}, :native-path \"target/native\"} {:native-path \"target/native\", :dependencies {org.clojure/clojure {:vsn \"1.10.0\", :native-prefix nil, :native? false}, org.clojure/spec.alpha {:vsn \"0.2.176\", :native-prefix nil, :native? false}, org.clojure/core.specs.alpha {:vsn \"0.2.44\", :native-prefix nil, :native? false}, nrepl {:vsn \"0.5.3\", :native-prefix nil, :native? false}, nrepl/bencode {:vsn \"1.0.0\", :native-prefix nil, :native? false}, clojure-complete {:vsn \"0.2.5\", :native-prefix nil, :native? false}}}]"
},
{
"path": "competitive-programming/exercism/clojure/armstrong-numbers/test/armstrong_numbers_test.clj",
"content": "(ns armstrong-numbers-test\n (:require [clojure.test :refer [deftest is testing]]\n [armstrong-numbers :refer [armstrong?]]))\n\n(deftest armstrong-number-5\n (testing \"Single digit numbers are Armstrong numbers\"\n (is (armstrong? 5))))\n\n(deftest not-armstrong-number-10\n (testing \"There are no 2 digit Armstrong numbers\"\n (is (not (armstrong? 10)))))\n\n(deftest armstrong-number-153\n (testing \"Three digit number that is an Armstrong number\"\n (is (armstrong? 153))))\n\n(deftest not-armstrong-number-100\n (testing \"Three digit number that is not an Armstrong number\"\n (is (not (armstrong? 100)))))\n\n(deftest armstrong-number-9474\n (testing \"Four digit number that is an Armstrong number\"\n (is (armstrong? 9474))))\n\n(deftest not-armstrong-number-9475\n (testing \"Four digit number that is not an Armstrong number\"\n (is (not (armstrong? 9476)))))\n\n(deftest armstrong-number-9926315\n (testing \"Seven digit number that is an Armstrong number\"\n (is (armstrong? 9926315))))\n\n(deftest not-armstrong-number-9926314\n (testing \"Seven digit number that is not an Armstrong number\"\n (is (not (armstrong? 9926314)))))\n\n(deftest armstrong-number-21897142587612075\n (testing \"Seventeen digit number that is an Armstrong number\"\n (is (armstrong? 21897142587612075))))\n"
},
{
"path": "competitive-programming/exercism/clojure/hello-world/README.md",
"content": "# Hello World\n\nThe classical introductory exercise. Just say \"Hello, World!\".\n\n[\"Hello, World!\"](http://en.wikipedia.org/wiki/%22Hello,_world!%22_program) is\nthe traditional first program for beginning programming in a new language\nor environment.\n\nThe objectives are simple:\n\n- Write a function that returns the string \"Hello, World!\".\n- Run the test suite and make sure that it succeeds.\n- Submit your solution and check it at the website.\n\nIf everything goes well, you will be ready to fetch your first real exercise.\n\n### Project Structure\n\nClojure exercises in exercism use [leiningen](http://leiningen.org/) to configure and run your code\nand use [leiningen standard directory structure](https://github.com/technomancy/leiningen/blob/master/doc/TUTORIAL.md#directory-layout).\n\nYou will find a test file named `hello_world_test.clj` inside `test` directory.\nWrite your code in `src/hello_world.clj`. It should use the namespace `hello-world` so that tests can pick it up.\n\n### Running tests\n\nRun the tests using `lein test` command and make them pass:\n\n```\n$ lein test\n\nlein test hello-world-test\n\nRan 1 tests containing 1 assertions.\n0 failures, 0 errors.\n```\n\nThen submit the exercise using:\n\n```\n$ exercism submit src/hello_world.clj\n```\n\nFor more detailed instructions and learning resources refer [exercism's clojure language page](http://exercism.io/languages/clojure).\n\n## Source\n\nThis is an exercise to introduce users to using Exercism [http://en.wikipedia.org/wiki/%22Hello,_world!%22_program](http://en.wikipedia.org/wiki/%22Hello,_world!%22_program)\n\n## Submitting Incomplete Solutions\nIt's possible to submit an incomplete solution so you can see how others have completed the exercise.\n"
},
{
"path": "competitive-programming/exercism/clojure/hello-world/project.clj",
"content": "(defproject hello-world \"0.1.0-SNAPSHOT\"\n :description \"hello-world exercise.\"\n :url \"https://github.com/exercism/clojure/tree/master/exercises/hello-world\"\n :dependencies [[org.clojure/clojure \"1.9.0\"]])\n"
},
{
"path": "competitive-programming/exercism/clojure/hello-world/src/hello-world.clj",
"content": "(ns hello-world)\n\n(defn hello [] \"Hello, World!\")\n"
},
{
"path": "competitive-programming/exercism/clojure/hello-world/test/hello-world-test.clj",
"content": "(ns hello-world-test\n (:require [clojure.test :refer [deftest is]]\n hello-world))\n\n(deftest hello-world-test\n (is (= \"Hello, World!\" (hello-world/hello))))\n"
},
{
"path": "competitive-programming/exercism/clojure/two-fer/.exercism/metadata.json",
"content": "{\"track\":\"clojure\",\"exercise\":\"two-fer\",\"id\":\"13de8e46adaa41d68299dc2b4a20ff1c\",\"url\":\"https://exercism.io/my/solutions/13de8e46adaa41d68299dc2b4a20ff1c\",\"handle\":\"LeandroTk\",\"is_requester\":true,\"auto_approve\":false}"
},
{
"path": "competitive-programming/exercism/clojure/two-fer/.lein-failures",
"content": "{}"
},
{
"path": "competitive-programming/exercism/clojure/two-fer/.nrepl-port",
"content": "62204"
},
{
"path": "competitive-programming/exercism/clojure/two-fer/README.md",
"content": "# Two Fer\n\n`Two-fer` or `2-fer` is short for two for one. One for you and one for me.\n\nGiven a name, return a string with the message:\n\n```text\nOne for X, one for me.\n```\n\nWhere X is the given name.\n\nHowever, if the name is missing, return the string:\n\n```text\nOne for you, one for me.\n```\n\nHere are some examples:\n\n|Name | String to return \n|:------:|:-----------------: \n|Alice | One for Alice, one for me. \n|Bob | One for Bob, one for me.\n| | One for you, one for me.\n|Zaphod | One for Zaphod, one for me.\n## Source\n\n[https://github.com/exercism/problem-specifications/issues/757](https://github.com/exercism/problem-specifications/issues/757)\n\n## Submitting Incomplete Solutions\nIt's possible to submit an incomplete solution so you can see how others have completed the exercise.\n"
},
{
"path": "competitive-programming/exercism/clojure/two-fer/project.clj",
"content": "(defproject two-fer \"0.1.0-SNAPSHOT\"\n :description \"two-fer exercise.\"\n :url \"https://github.com/exercism/clojure/tree/master/exercises/two-fer\"\n :dependencies [[org.clojure/clojure \"1.8.0\"]])\n"
},
{
"path": "competitive-programming/exercism/clojure/two-fer/src/two_fer.clj",
"content": "(ns two-fer)\n\n(defn two-fer\n ([] \"One for you, one for me.\")\n ([name] (str \"One for \" name \", one for me.\")))\n"
},
{
"path": "competitive-programming/exercism/clojure/two-fer/target/classes/META-INF/maven/two-fer/two-fer/pom.properties",
"content": "#Leiningen\n#Sun Feb 03 05:19:15 BRST 2019\ngroupId=two-fer\nartifactId=two-fer\nversion=0.1.0-SNAPSHOT\n"
},
{
"path": "competitive-programming/exercism/clojure/two-fer/target/repl-port",
"content": "62204"
},
{
"path": "competitive-programming/exercism/clojure/two-fer/target/stale/leiningen.core.classpath.extract-native-dependencies",
"content": "[{:dependencies {org.clojure/clojure {:vsn \"1.8.0\", :native-prefix nil}, nrepl {:vsn \"0.5.3\", :native-prefix nil}, nrepl/bencode {:vsn \"1.0.0\", :native-prefix nil}, clojure-complete {:vsn \"0.2.5\", :native-prefix nil}}, :native-path \"target/native\"} {:native-path \"target/native\", :dependencies {org.clojure/clojure {:vsn \"1.8.0\", :native-prefix nil, :native? false}, clojure-complete {:vsn \"0.2.5\", :native-prefix nil, :native? false}, nrepl {:vsn \"0.5.3\", :native-prefix nil, :native? false}, nrepl/bencode {:vsn \"1.0.0\", :native-prefix nil, :native? false}}}]"
},
{
"path": "competitive-programming/exercism/clojure/two-fer/test/two_fer_test.clj",
"content": "(ns two-fer-test\n (:require [clojure.test :refer [deftest is]]\n two-fer))\n\n(deftest two-fer-test\n (is (= \"One for you, one for me.\" (two-fer/two-fer))))\n\n(deftest name-alice-test\n (is (= \"One for Alice, one for me.\" (two-fer/two-fer \"Alice\"))))\n\n(deftest name-bob-test\n (is (= \"One for Bob, one for me.\" (two-fer/two-fer \"Bob\"))))\n"
},
{
"path": "competitive-programming/exercism/javascript/allergies.js",
"content": "export class Allergies {\n constructor(score) {\n this.score = score;\n this.scores = [128, 64, 32, 16, 8, 4, 2, 1];\n this.scoreToFoodMapper = {\n 1: 'eggs',\n 2: 'peanuts',\n 4: 'shellfish',\n 8: 'strawberries',\n 16: 'tomatoes',\n 32: 'chocolate',\n 64: 'pollen',\n 128: 'cats',\n };\n }\n\n list() {\n this.listOfFoods = [];\n this.findMaxSmallerThanScore(this.score);\n return [...new Set(this.listOfFoods)];\n }\n\n findMaxSmallerThanScore(score) {\n if (score === 0) return;\n\n const maxSmallerThanScore = this.scores.find(\n (currentScore) => currentScore <= score\n );\n\n this.listOfFoods.unshift(this.scoreToFoodMapper[maxSmallerThanScore]);\n score -= maxSmallerThanScore;\n return this.findMaxSmallerThanScore(score);\n }\n\n allergicTo(food) {\n return this.list().includes(food);\n }\n}\n"
},
{
"path": "competitive-programming/exercism/javascript/collatz-conjecture.js",
"content": "export const steps = n => {\n if (n <= 0) throw \"Only positive numbers are allowed\";\n\n let times = 0;\n\n while (n !== 1) {\n if (n % 2 === 0) {\n n /= 2;\n } else {\n n = n * 3 + 1;\n }\n\n times++;\n }\n\n return times;\n};\n"
},
{
"path": "competitive-programming/exercism/javascript/count-words.js",
"content": "const SPECIAL_CHARACTERS = /[!@#\\$%\\^\\&*\\\".,;:?<>~`(\\){}[\\]\\\\/\\+=_-]/g;\nconst SPACE_CHARACTERS = /\\s+/g;\n\nfunction isEmptySpace(string) {\n return string !== '';\n}\n\nfunction removeOpenQuote(word) {\n return word.startsWith(\"'\") ? word.substring(1) : word;\n}\n\nfunction removeCloseQuote(word) {\n return word.endsWith(\"'\") ? word.substring(0, word.length - 1) : word;\n}\n\nfunction removeQuotes(word) {\n return removeCloseQuote(removeOpenQuote(word));\n}\n\nexport const countWords = (phrase) => {\n const words = phrase\n .toLowerCase()\n .replaceAll(SPECIAL_CHARACTERS, ' ')\n .split(SPACE_CHARACTERS)\n .filter(isEmptySpace)\n .map(removeQuotes);\n\n const wordCounter = {};\n\n for (const word of words) {\n wordCounter[word] = (wordCounter[word] || 0) + 1;\n }\n\n return wordCounter;\n};\n"
},
{
"path": "competitive-programming/exercism/javascript/etl.js",
"content": "export const transform = (scoreToLetters) => {\n const obj = {};\n\n Object.entries(scoreToLetters).forEach(([score, letters]) => {\n letters.forEach((letter) => {\n obj[letter.toLowerCase()] = Number(score);\n });\n });\n\n return obj;\n};\n"
},
{
"path": "competitive-programming/exercism/javascript/flatten-array.js",
"content": "export const flatten = (list) => {\n const result = [];\n\n list.forEach((item) => {\n if (Array.isArray(item)) {\n result.push(...flatten(item));\n } else if (item !== undefined && item !== null) {\n result.push(item);\n }\n });\n\n return result;\n};\n"
},
{
"path": "competitive-programming/exercism/javascript/gigasecond.js",
"content": "const year = date => date.getUTCFullYear();\nconst month = date => date.getUTCMonth();\nconst day = date => date.getUTCDate() + 11574;\nconst hours = date => date.getUTCHours() + 1;\nconst minutes = date => date.getUTCMinutes() + 46;\nconst second = date => date.getUTCSeconds() + 40;\n\nexport const gigasecond = date =>\n new Date(\n Date.UTC(\n year(date),\n month(date),\n day(date),\n hours(date),\n minutes(date),\n second(date)\n )\n );\n"
},
{
"path": "competitive-programming/exercism/javascript/hello-world.js",
"content": "export const hello = () => \"Hello, World!\";\n"
},
{
"path": "competitive-programming/exercism/javascript/leap.js",
"content": "// https://exercism.io/tracks/javascript/exercises/leap/solutions/0e7bcf1db4974d159ab9ebe9e961bcd1\n\nexport const isLeap = year =>\n (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;\n"
},
{
"path": "competitive-programming/exercism/javascript/perfect-numbers.js",
"content": "const getAllDivisibleNumbers = (number) => {\n const divisibleNumbers = [];\n\n for (let i = 1; i <= number / 2; i++) {\n if (number % i === 0) {\n divisibleNumbers.push(i);\n }\n }\n\n return divisibleNumbers;\n};\n\nconst sumAllNumbers = (numbers) =>\n numbers.reduce((sum, number) => sum + number, 0);\n\nexport const classify = (number) => {\n if (number <= 0) {\n throw new Error('Classification is only possible for natural numbers.');\n }\n\n const divisibleNumbers = getAllDivisibleNumbers(number);\n const sumOfNumbers = sumAllNumbers(divisibleNumbers);\n console.log('divisibleNumbers', divisibleNumbers);\n console.log('sumOfNumbers', sumOfNumbers);\n\n if (sumOfNumbers === number) {\n return 'perfect';\n }\n\n if (sumOfNumbers > number) {\n return 'abundant';\n }\n\n if (sumOfNumbers < number) {\n return 'deficient';\n }\n};\n"
},
{
"path": "competitive-programming/exercism/javascript/phone-number.js",
"content": "const isDigit = (char) => '0' <= char && char <= '9';\n\nconst getDigits = (phoneNumber) =>\n phoneNumber.split('').filter(isDigit).join('');\n\nconst verifyDigitsLength = (digits) => {\n if (digits.length < 10) {\n throw new Error('Incorrect number of digits');\n }\n\n if (digits.length >= 12) {\n throw new Error('More than 11 digits');\n }\n};\n\nconst verifyCountryCode = (digits) => {\n if (digits.length === 11 && digits[0] !== '1') {\n throw new Error('11 digits must start with 1');\n }\n};\n\nconst verifyAreaCode = (digits) => {\n if (digits.length === 10 && digits[0] === '0') {\n throw new Error('Area code cannot start with zero');\n }\n\n if (digits.length === 10 && digits[0] === '1') {\n throw new Error('Area code cannot start with one');\n }\n\n if (digits.length === 11 && digits[1] === '0') {\n throw new Error('Area code cannot start with zero');\n }\n\n if (digits.length === 11 && digits[1] === '1') {\n throw new Error('Area code cannot start with one');\n }\n};\n\nconst verifyExchangeCode = (digits) => {\n if (digits.length === 10 && digits[3] === '0') {\n throw new Error('Exchange code cannot start with zero');\n }\n\n if (digits.length === 10 && digits[3] === '1') {\n throw new Error('Exchange code cannot start with one');\n }\n\n if (digits.length === 11 && digits[4] === '0') {\n throw new Error('Exchange code cannot start with zero');\n }\n\n if (digits.length === 11 && digits[4] === '1') {\n throw new Error('Exchange code cannot start with one');\n }\n};\n\nconst verifyAlphabetChars = (digits) => {\n const alphabetChars = digits.match(/[A-Za-z]/g);\n\n if (alphabetChars && alphabetChars.length) {\n throw new Error('Letters not permitted');\n }\n};\n\nconst verifyPunctuationChars = (digits) => {\n const punctuationChars = digits.match(/[,\\/#!$%\\^&\\*;:{}=\\_`~]/g);\n\n if (punctuationChars && punctuationChars.length) {\n throw new Error('Punctuations not permitted');\n }\n};\n\nexport const clean = (phoneNumber) => {\n const digits = getDigits(phoneNumber);\n\n verifyAlphabetChars(phoneNumber);\n verifyPunctuationChars(phoneNumber);\n verifyDigitsLength(digits);\n verifyCountryCode(digits);\n verifyAreaCode(digits);\n verifyExchangeCode(digits);\n\n return digits.length === 11 ? digits.substring(1) : digits;\n};\n"
},
{
"path": "competitive-programming/exercism/javascript/resistor-color.js",
"content": "const colorCode = color => COLORS.indexOf(color);\n\nconst COLORS = [\n \"black\",\n \"brown\",\n \"red\",\n \"orange\",\n \"yellow\",\n \"green\",\n \"blue\",\n \"violet\",\n \"grey\",\n \"white\"\n];\n\nexport { colorCode, COLORS };\n"
},
{
"path": "competitive-programming/exercism/javascript/resistor-colors.js",
"content": "// https://exercism.io/my/solutions/0a95e6a8ebb94efeac42b2c6e065818b\n\nconst COLORS = [\n \"black\",\n \"brown\",\n \"red\",\n \"orange\",\n \"yellow\",\n \"green\",\n \"blue\",\n \"violet\",\n \"grey\",\n \"white\"\n];\n\nconst reducer = (acc, resistanceValue) => acc + resistanceValue;\nconst resistanceValuesString = (resistorsColors) =>\n resistorsColors\n .map((color) => COLORS.indexOf(color))\n .reduce(reducer, \"\");\n\nexport const value = (resistorsColors) => {\n return Number(resistanceValuesString(resistorsColors));\n};\n"
},
{
"path": "competitive-programming/exercism/javascript/reverse-string.js",
"content": "const lastChar = str => str[str.length - 1];\n\nexport const reverseString = str => {\n if (str.length <= 1) {\n return str;\n }\n\n return lastChar(str) + reverseString(str.substring(0, str.length - 1));\n};\n"
},
{
"path": "competitive-programming/exercism/javascript/sublist.js",
"content": "const COMPARISON = {\n EQUAL: 'EQUAL',\n SUBLIST: 'SUBLIST',\n SUPERLIST: 'SUPERLIST',\n UNEQUAL: 'UNEQUAL',\n};\n\nexport class List {\n constructor(numbers = []) {\n this.numbers = numbers;\n }\n\n compare(otherList) {\n const otherNumbers = otherList.numbers;\n const numbersLength = this.numbers.length;\n const otherLength = otherNumbers.length;\n\n if (numbersLength < otherLength) {\n return this.isSublist(otherNumbers)\n ? COMPARISON.SUBLIST\n : COMPARISON.UNEQUAL;\n }\n\n if (numbersLength > otherLength) {\n return this.isSuperList(this.numbers, otherNumbers)\n ? COMPARISON.SUPERLIST\n : COMPARISON.UNEQUAL;\n }\n\n return this.isIdentical(this.numbers, otherNumbers)\n ? COMPARISON.EQUAL\n : COMPARISON.UNEQUAL;\n }\n\n isIdentical(numbers, otherList) {\n if (numbers.length !== otherList.length) return false;\n\n for (let i = 0; i < numbers.length; i++) {\n if (numbers[i] !== otherList[i]) return false;\n }\n\n return true;\n }\n\n isSublist(otherNumbers) {\n const numbersLength = this.numbers.length;\n const otherLength = otherNumbers.length;\n\n for (let i = 0; i < otherLength - numbersLength + 1; i++) {\n if (\n this.isIdentical(this.numbers, otherNumbers.slice(i, i + numbersLength))\n ) {\n return true;\n }\n }\n\n return false;\n }\n\n isSuperList(numbers, otherNumbers) {\n const numbersLength = numbers.length;\n const otherLength = otherNumbers.length;\n\n for (let i = 0; i < numbersLength - otherLength + 1; i++) {\n if (this.isIdentical(numbers.slice(i, i + otherLength), otherNumbers)) {\n return true;\n }\n }\n\n return false;\n }\n}\n"
},
{
"path": "competitive-programming/exercism/javascript/sum-of-multiples.js",
"content": "export const sum = (multiples, limit) => {\n let sum = 0;\n let counted = {};\n\n multiples.forEach((multiple) => {\n if (!multiple) return;\n\n let increment = multiple;\n\n while (increment < limit) {\n if (!counted[increment]) sum += increment;\n counted[increment] = true;\n increment += multiple;\n }\n });\n\n return sum;\n};\n"
},
{
"path": "competitive-programming/exercism/javascript/triangle.js",
"content": "export function Triangle(side1, side2, side3) {\n this.side1 = side1;\n this.side2 = side2;\n this.side3 = side3;\n}\n\nTriangle.prototype.isEquilateral = function() {\n return this.side1 == this.side2 && this.side1 == this.side3;\n};\n\nTriangle.prototype.isIsosceles = function() {\n return (\n this.side1 == this.side2 ||\n this.side1 == this.side3 ||\n this.side2 == this.side3\n );\n};\n\nTriangle.prototype.anyNonPositiveSide = function() {\n return this.side1 <= 0 || this.side2 <= 0 || this.side3 <= 0;\n};\n\nTriangle.prototype.isInequality = function() {\n return (\n this.side1 > this.side2 + this.side3 ||\n this.side2 > this.side1 + this.side3 ||\n this.side3 > this.side2 + this.side1\n );\n};\n\nTriangle.prototype.kind = function() {\n if (this.anyNonPositiveSide() || this.isInequality()) {\n throw \"Not a triangle\";\n } else if (this.isEquilateral()) {\n return \"equilateral\";\n } else if (this.isIsosceles()) {\n return \"isosceles\";\n } else {\n return \"scalene\";\n }\n};\n"
},
{
"path": "competitive-programming/exercism/javascript/two-fer.js",
"content": "export const twoFer = (name = \"you\") => `One for ${name}, one for me.`;\n"
},
{
"path": "competitive-programming/hacker-rank/algorithms/strings/palindrome_index.py",
"content": "# https://www.hackerrank.com/challenges/palindrome-index\n\nimport sys\n\ndef is_palindrome(s):\n return s == s[::-1]\n\ndef palindrome_index(s):\n for i in range(len(s)):\n if is_palindrome(s[i+1:len(s)-i]):\n return i\n\n if is_palindrome(s[i:len(s)-i-1]):\n return len(s)-i-1\n\nq = int(raw_input().strip())\n\nfor num in range(q):\n s = raw_input().strip()\n result = palindrome_index(s)\n print(result)\n"
},
{
"path": "competitive-programming/hacker-rank/algorithms/warmup/birthday_cake_candles.py",
"content": "# https://www.hackerrank.com/challenges/birthday-cake-candles/problem\n\ndef birthday_cake_candles(n, ar):\n sorted_ar = sorted(ar, reverse = True)\n tallest = sorted_ar[0]\n result = 0\n\n for candle_height in sorted_ar:\n if tallest == candle_height:\n result += 1\n\n return result\n\nprint(birthday_cake_candles(int(raw_input()), map(int, raw_input().strip().split(' '))))\n"
},
{
"path": "competitive-programming/hacker-rank/algorithms/warmup/mini_max_sum.py",
"content": "def mini_max_sum(arr):\n sorted_arr = sorted(arr)\n print sum(sorted_arr[0:4]), sum(sorted_arr[1:5])\n\nif __name__ == \"__main__\":\n arr = map(int, raw_input().strip().split(' '))\n mini_max_sum(arr)\n"
},
{
"path": "competitive-programming/hacker-rank/cpp/introduction/angry_professor.cpp",
"content": "#include \n\nusing namespace std;\n\nint main() {\n\n\tint t, n, k, time, total_students_arrived_before_class=0;\n\n\tcin >> t;\n\n\twhile (t--) {\n\t\tcin >> n >> k;\n\n\t\tfor (int i = 0; i < n; i++) {\n\t\t\tcin >> time;\n\t\t\tif (time <= 0) total_students_arrived_before_class++;\n\t\t}\n\n\t\tif (total_students_arrived_before_class >= k) cout << \"NO\" << endl;\n\t\telse cout << \"YES\" << endl;\n\t\ttotal_students_arrived_before_class=0;\n\t}\n\n\treturn 0;\n}\n"
},
{
"path": "competitive-programming/hacker-rank/cpp/introduction/arrays_introduction.cpp",
"content": "// https://www.hackerrank.com/challenges/arrays-introduction?h_r=next-challenge&h_v=zen\n\n#include \n#include \n\nusing namespace std;\n\nint main() {\n\tvector v;\n\tint n, x;\n\tcin >> n;\n\n\twhile (n--) {\n\t\tcin >> x;\n\t\tv.push_back(x);\n\t}\n\n\tfor (int i = v.size()-1; i >= 0; i--) cout << v[i] << \" \";\n\tcout << endl;\n\n\treturn 0;\n}"
},
{
"path": "competitive-programming/hacker-rank/cpp/introduction/diagonal_difference.cpp",
"content": "#include \n#include \n\nusing namespace std;\n\nint main() {\n\n vector< vector > matrix;\n vector v;\n int n, diag1=0, diag2=0, temp;\n\n cin >> n;\n\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> temp;\n v.push_back(temp);\n }\n\n matrix.push_back(v);\n v.clear();\n }\n\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (i == j) diag1 += matrix[i][j];\n if (j == n - 1 - i) diag2 += matrix[i][j];\n }\n }\n\n int result = diag1 - diag2;\n if (result < 0) result *= -1;\n\n cout << result << endl;\n\n return 0;\n}\n"
},
{
"path": "competitive-programming/hacker-rank/cpp/introduction/input_and_output.cpp",
"content": "// https://www.hackerrank.com/challenges/cpp-input-and-output\n\n#include \n#include \n#include \n#include \n#include \nusing namespace std;\n\nint main() {\n int a, b, c;\n cin >> a >> b >> c;\n cout << a + b + c << endl;\n return 0;\n}\n"
},
{
"path": "competitive-programming/hacker-rank/cpp/introduction/library_fine.cpp",
"content": "#include \n\nusing namespace std;\n\nint main() {\n\t\n\tint day1, day2, month1, month2, year1, year2;\n\n\tcin >> day1 >> month1 >> year1;\n\tcin >> day2 >> month2 >> year2;\n\n\tif (year1 == year2) {\n\t\tif (month1 == month2) {\n\t\t\tif (day1 <= day2)\n\t\t\t\tcout << 0 << endl;\n\t\t\telse\n\t\t\t\tcout << 15 * (day1 - day2) << endl;\n\t\t} else if (month1 > month2) {\n\t\t\tcout << 500 * (month1 - month2) << endl;\n\t\t}\telse {\n\t\t\tcout << 0 << endl;\n\t\t}\n\t} else if (year1 > year2) {\n\t\tcout << 10000 * (year1 - year2) << endl;\n\t} else {\n\t\tcout << 0 << endl;\n\t}\n\n\treturn 0;\n}"
},
{
"path": "competitive-programming/hacker-rank/cpp/introduction/plus_minus.cpp",
"content": "#include \n\nusing namespace std;\n\nint main() {\n\n\tint n, temp, num, zeros=0, positives=0, negatives=0;\n\n\tcin >> n;\n\ttemp = n;\n\n\twhile (temp--) {\n\t\tcin >> num;\n\n\t\tif (num > 0) positives++;\n\t\telse if (num < 0) negatives++;\n\t\telse zeros++;\n\t}\n\n\tdouble divisor = n;\n\n\tcout << positives / divisor << endl;\n\tcout << negatives / divisor << endl;\n\tcout << zeros / divisor << endl;\n\n return 0;\n}\n"
},
{
"path": "competitive-programming/hacker-rank/cpp/introduction/staircase.cpp",
"content": "#include \n#include \n\nusing namespace std;\n\nint main() {\n\n\tint n;\n\tstring result=\"\";\n\n\tcin >> n;\n\tint total = n;\n\n\twhile (n) {\n\n\t\tfor (int i = 1; i < n; i++)\n\t\t\tresult += \" \";\n\n\t\tint num_symbol = total + 1 - n;\n\n\t\tfor (int i = 0; i < num_symbol; i++) {\n\t\t\tresult += \"#\";\n\t\t}\n\n\t\tcout << result << endl;\n\t\tresult.clear();\n\t\tn--;\n\t}\n\n\treturn 0;\n}\n"
},
{
"path": "competitive-programming/hacker-rank/cpp/introduction/time_conversion.cpp",
"content": "#include \n#include \n\nusing namespace std;\n\nint main() {\n\n\tstring time;\n\n\tcin >> time;\n\n\tchar letter = time[8];\n\n\tif (letter == 'A'){\n\t\tif (time.substr(0, 2) == \"12\") cout << \"00\" + time.substr(2, 6);\n\t\telse if (time.substr(0, 2) == \"13\") cout << \"01\" + time.substr(2, 6);\n\t\telse if (time.substr(0, 2) == \"14\") cout << \"02\" + time.substr(2, 6);\n\t\telse if (time.substr(0, 2) == \"15\") cout << \"03\" + time.substr(2, 6);\n\t\telse if (time.substr(0, 2) == \"16\") cout << \"04\" + time.substr(2, 6);\n\t\telse if (time.substr(0, 2) == \"17\") cout << \"05\" + time.substr(2, 6);\n\t\telse if (time.substr(0, 2) == \"18\") cout << \"06\" + time.substr(2, 6);\n\t\telse if (time.substr(0, 2) == \"19\") cout << \"07\" + time.substr(2, 6);\n\t\telse if (time.substr(0, 2) == \"20\") cout << \"08\" + time.substr(2, 6);\n\t\telse if (time.substr(0, 2) == \"21\") cout << \"09\" + time.substr(2, 6);\n\t\telse if (time.substr(0, 2) == \"22\") cout << \"10\" + time.substr(2, 6);\n\t\telse if (time.substr(0, 2) == \"23\") cout << \"\" + time.substr(2, 6);\n\t\telse cout << time.substr(0, 8);\n\t} else {\n\t\tif (time.substr(0, 2) == \"00\") cout << \"24\" + time.substr(2, 6);\n\t\telse if (time.substr(0, 2) == \"01\") cout << \"13\" + time.substr(2, 6);\n\t\telse if (time.substr(0, 2) == \"02\") cout << \"14\" + time.substr(2, 6);\n\t\telse if (time.substr(0, 2) == \"03\") cout << \"15\" + time.substr(2, 6);\n\t\telse if (time.substr(0, 2) == \"04\") cout << \"16\" + time.substr(2, 6);\n\t\telse if (time.substr(0, 2) == \"05\") cout << \"17\" + time.substr(2, 6);\n\t\telse if (time.substr(0, 2) == \"06\") cout << \"18\" + time.substr(2, 6);\n\t\telse if (time.substr(0, 2) == \"07\") cout << \"19\" + time.substr(2, 6);\n\t\telse if (time.substr(0, 2) == \"08\") cout << \"20\" + time.substr(2, 6);\n\t\telse if (time.substr(0, 2) == \"09\") cout << \"21\" + time.substr(2, 6);\n\t\telse if (time.substr(0, 2) == \"10\") cout << \"22\" + time.substr(2, 6);\n\t\telse if (time.substr(0, 2) == \"11\") cout << \"23\" + time.substr(2, 6);\n\t\telse cout << time.substr(0, 8);\n\t}\n\n\treturn 0;\n}"
},
{
"path": "competitive-programming/hacker-rank/cpp/introduction/vector_erase.cpp",
"content": "#include \n#include \n\nusing namespace std;\n\nint main() {\n\t\n\tint time, temp, n;\n\tvector v;\n\n\tcin >> time;\n\n\twhile (time--) {\n\t\tcin >> temp;\n\t\tv.push_back(temp);\n\t}\n\n\tint bla, begin, end;\n\tcin >> bla >> begin >> end;\t\n\n\tcout << end - begin + 1 << endl;\n\n\tv.erase(v.begin() + begin - 1, v.begin() + end);\n\n\tfor (int i = 0; i < v.size(); i++)\n\t\tcout << v[i] << \" \";\n\n\treturn 0;\n}"
},
{
"path": "competitive-programming/hacker-rank/cpp/introduction/vector_sort.cpp",
"content": "#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n\n\tvector v;\n\n\tint n, temp;\n\n\tcin >> n;\n\n\twhile (n--) {\n\t\tcin >> temp;\n\t\tv.push_back(temp);\n\t}\n\n\tsort(v.begin(), v.end());\n\n\tfor (int i = 0; i < v.size(); i++)\n\t\tcout << v[i] << \" \";\n\n return 0;\n}\n"
},
{
"path": "competitive-programming/hacker-rank/data_structures/trees/in_order_traversal.py",
"content": "def in_order(node):\n if node.left:\n in_order(node.left)\n\n print node.data,\n\n if node.right:\n in_order(node.right) \n"
},
{
"path": "competitive-programming/hacker-rank/data_structures/trees/post_order_traversal.py",
"content": "def post_order(node):\n if node.left:\n post_order(node.left)\n\n if node.right:\n post_order(node.right)\n\n print(node.data)\n"
},
{
"path": "competitive-programming/hacker-rank/data_structures/trees/pre_order_traversal.py",
"content": "def pre_order(node):\n print(node.data)\n\n if node.left:\n pre_order(node.left)\n\n if node.right:\n pre_order(node.right)\n"
},
{
"path": "competitive-programming/hacker-rank/functional-programming/array_of_n_elements/array_of_n_elements.clj",
"content": ";; https://www.hackerrank.com/challenges/fp-array-of-n-elements/problem\n\n(defn array-of-n-elements\n [n]\n (range n))\n\n(array-of-n-elements 1)\n(array-of-n-elements 3)\n(array-of-n-elements 5)\n"
},
{
"path": "competitive-programming/hacker-rank/functional-programming/array_of_n_elements/array_of_n_elements_without_range.clj",
"content": ";; https://www.hackerrank.com/challenges/fp-array-of-n-elements/problem\n\n(defn array-of-n-elements-without-range\n [n]\n (loop [n n list []]\n (if (pos? n)\n (recur (dec n) (conj list 0))\n list)))\n\n(array-of-n-elements-without-range 1)\n(array-of-n-elements-without-range 3)\n(array-of-n-elements-without-range 5)\n"
},
{
"path": "competitive-programming/hacker-rank/functional-programming/basics/hello_world.clj",
"content": ";; Problem: https://www.hackerrank.com/challenges/fp-hello-world/problem?h_r=next-challenge&h_v=zen\n\n(print \"Hello World\")\n"
},
{
"path": "competitive-programming/hacker-rank/functional-programming/basics/hello_world_n_times.clj",
"content": ";; https://www.hackerrank.com/challenges/fp-hello-world-n-times/problem\n\n(defn greater-than-zero? [n] (> n 0))\n\n(defn hello-word-n-times\n [n]\n (if (greater-than-zero? n)\n (do (println \"Hello World\")\n (hello-word-n-times (dec n)))))\n\n(hello-word-n-times 4)\n"
},
{
"path": "competitive-programming/hacker-rank/functional-programming/basics/solve_me_first.clj",
"content": ";; Problem: https://www.hackerrank.com/challenges/fp-solve-me-first/problem\n\n(defn solve-me-first\n [a b]\n (+ a b))\n\n(def a (read-line))\n(def b (read-line))\n\n(println (solve-me-first (Integer/parseInt a) (Integer/parseInt b)))\n"
},
{
"path": "competitive-programming/hacker-rank/functional-programming/eval_ex/main.clj",
"content": ";; https://www.hackerrank.com/challenges/eval-ex/problem\n\n;; Approach:\n;; Use map to transform the list of 10 elements from x to (/ (exp x n) (factorial n))\n;; And reduce suming each element\n\n;; For this approach, we can separate in 3 different functions\n;; - exp: exponantial\n;; - factorial\n;; - expansion: function composed of exp and factorial passed to map\n\n;; So we can test these 3 functions\n\n(ns eval-ex\n (:use [clojure.test]))\n\n(defn exp\n [x n]\n (reduce * (repeat n x)))\n\n(defn factorial\n [n]\n (reduce * (range 1 (inc n))))\n\n(defn expansion\n [x]\n (fn [n]\n (/ (exp x n) (factorial n))))\n\n(defn series-expansion\n [x]\n (read-string\n (format \"%.4f\"\n (reduce + (map (expansion x) (range 10))))))\n\n;; -----------------------------------------------------------\n\n;; Tests\n\n(deftest test-exp\n (testing \"Exponantial function\"\n (is (= 1 (exp 1 0)))\n (is (= 1 (exp 1 1)))\n (is (= 4 (exp 2 2)))))\n\n(deftest test-factorial\n (testing \"Factorial function\"\n (is (= 1 (factorial 0)))\n (is (= 1 (factorial 1)))\n (is (= 120 (factorial 5)))))\n\n(deftest test-expansion\n (testing \"Expansion function\"\n (is (= 1 ((expansion 10) 0)))\n (is (= 10 ((expansion 10) 1)))\n (is (= 50 ((expansion 10) 2)))))\n\n(deftest test-series-expansion\n (testing \"Sample Input - Output\"\n (is (= 2423600.1887 (series-expansion 20.0000)))\n (is (= 143.6895 (series-expansion 5.0000)))\n (is (= 1.6487 (series-expansion 0.5000)))\n (is (= 0.6065 (series-expansion -0.5000)))))\n\n(run-tests)\n"
},
{
"path": "competitive-programming/hacker-rank/functional-programming/filter_array/filter_array.clj",
"content": ";; https://www.hackerrank.com/challenges/fp-filter-array/problem\n\n(defn filter-array\n [n lst]\n (filter #(> n %) lst))\n\n(filter-array 25 [-41 46 -28 21 52 83 -29 84 27 40])\n"
},
{
"path": "competitive-programming/hacker-rank/functional-programming/filter_positions_in_a_list/filter_positions_in_a_list.clj",
"content": ";; https://www.hackerrank.com/challenges/fp-filter-positions-in-a-list/problem\n\n(defn filter-positions-in-a-list\n [lst]\n (take-nth 2 (rest lst)))\n\n(filter-positions-in-a-list [])\n(filter-positions-in-a-list [0 1 2])\n(filter-positions-in-a-list [0 1 2 3 4 5 6 7 8 9])\n(filter-positions-in-a-list [8 15 22 1 10 6 2 18 18 1])\n"
},
{
"path": "competitive-programming/hacker-rank/functional-programming/list_length/list_length.clj",
"content": ";; https://www.hackerrank.com/challenges/fp-list-length/problem?h_r=next-challenge&h_v=zen\n\n(defn list-length\n [lst]\n (loop [coll lst counter 0]\n (if (empty? coll)\n counter\n (recur (rest coll) (inc counter)))))\n\n(list-length [0 1 2 3 4 5 6 7 8 9])\n(list-length [0 1 2 -1 4 -5 6 7 -8 9])\n(list-length [])\n"
},
{
"path": "competitive-programming/hacker-rank/functional-programming/list_length/list_length_reduce.clj",
"content": ";; https://www.hackerrank.com/challenges/fp-list-length/problem?h_r=next-challenge&h_v=zen\n\n(defn list-length\n [lst]\n (reduce + (map (constantly 1) lst)))\n\n(list-length [0 1 2 3 4 5 6 7 8 9])\n(list-length [0 1 2 -1 4 -5 6 7 -8 9])\n(list-length [])\n"
},
{
"path": "competitive-programming/hacker-rank/functional-programming/list_replication/list_replication.clj",
"content": ";; Problem: https://www.hackerrank.com/challenges/fp-list-replication/problem\n\n(defn list-replication\n [n list]\n (sort\n (flatten\n (repeat n list))))\n\n(list-replication 3 [1 2 3])\n(list-replication 2 [4 5])\n(list-replication 1 [10 100])\n"
},
{
"path": "competitive-programming/hacker-rank/functional-programming/reverse_a_list/reverse_a_list.clj",
"content": ";; https://www.hackerrank.com/challenges/fp-reverse-a-list/problem\n;; last function: returns the last element of a collection\n;; count function: returns the length of a collection\n;; take function: returns the first N taken elements of a collection\n;; not-empty function: returns true if the collection is not empty. Otherwise, false\n\n(def example-list [19 22 3 28 26 17 18 4 28 0])\n\n(defn reverse-a-list\n [list]\n (loop [original-list list reversed-list []]\n (if (not-empty original-list)\n (recur (take (dec (count original-list)) original-list) (conj reversed-list (last original-list)))\n reversed-list)))\n\n(reverse-a-list example-list)\n\n;; Implementing an anonymous function\n\n(fn [lst]\n (loop [original-list lst reversed-list []]\n (if (not-empty original-list)\n (recur (take (dec (count original-list)) original-list) (conj reversed-list (last original-list)))\n reversed-list)))\n"
},
{
"path": "competitive-programming/hacker-rank/functional-programming/reverse_a_list/reverse_a_list_into.clj",
"content": ";; https://www.hackerrank.com/challenges/fp-reverse-a-list/problem\n;; basically, the into function is a reduce + conj\n\n(def example-list [19 22 3 28 26 17 18 4 28 0])\n\n(defn reverse-a-list\n [lst]\n (into '() lst))\n\n(reverse-a-list example-list)\n\n((fn [lst] (into '() lst)) example-list)\n"
},
{
"path": "competitive-programming/hacker-rank/functional-programming/reverse_a_list/reverse_a_list_reduce.clj",
"content": ";; https://www.hackerrank.com/challenges/fp-reverse-a-list/problem\n\n(def example-list [19 22 3 28 26 17 18 4 28 0])\n\n(defn reverse-a-list\n [lst]\n (reduce conj '() lst))\n\n(reverse-a-list example-list)\n\n;; Implementing an anonymous function\n\n((fn [lst] (reduce conj '() lst)) example-list)\n"
},
{
"path": "competitive-programming/hacker-rank/functional-programming/sum_of_odd_elements/sum_of_odd_elements.clj",
"content": ";; https://www.hackerrank.com/challenges/fp-sum-of-odd-elements/problem\n\n(defn sum-of-odd-elements\n [lst]\n (reduce\n +\n (filter\n (odd? n)\n lst)))\n\n(sum-of-odd-elements [3 2 4 6 5 7 8 0 1])\n"
},
{
"path": "competitive-programming/hacker-rank/functional-programming/update_list/update_list.clj",
"content": ";; https://www.hackerrank.com/challenges/fp-update-list/problem\n\n(defn to-absolute\n [n]\n (if (neg? n)\n (+ (* n -2) n)\n n))\n\n(defn add-element-from-list-to-list\n [lst1 lst2]\n (conj lst2 (to-absolute (first lst1))))\n\n(defn update-list\n [lst]\n (loop [original-list lst absolute-list []]\n (if (empty? original-list)\n absolute-list\n (recur\n (rest original-list)\n (add-element-from-list-to-list original-list absolute-list)))))\n\n(update-list [])\n(update-list [1 2 3 4 5])\n(update-list [-1 -2 -3 -4 -5])\n(update-list [1 -2 3 -4 5])\n"
},
{
"path": "competitive-programming/hacker-rank/functional-programming/update_list/update_list_anonymous.clj",
"content": ";; https://www.hackerrank.com/challenges/fp-update-list/problem\n\n(fn\n [lst]\n (loop [original-list lst absolute-list []]\n (if (empty? original-list)\n absolute-list\n (recur\n (rest original-list)\n (conj\n absolute-list\n (if (< (first original-list) 0)\n (+ (* (first original-list) -2) (first original-list))\n (first original-list)))))))\n"
},
{
"path": "competitive-programming/hacker-rank/functional-programming/update_list/update_list_map.clj",
"content": ";; https://www.hackerrank.com/challenges/fp-update-list/problem\n\n(defn to-absolute\n [n]\n (if (neg? n)\n (+ (* n -2) n)\n n))\n\n(defn update-list-map\n [lst]\n (map to-absolute lst))\n\n(update-list-map [])\n(update-list-map [1 2 3 4 5])\n(update-list-map [-1 -2 -3 -4 -5])\n(update-list-map [1 -2 3 -4 5])\n"
},
{
"path": "competitive-programming/hacker-rank/functional-programming/update_list/update_list_map_anonymous.clj",
"content": ";; https://www.hackerrank.com/challenges/fp-update-list/problem\n\n(fn\n [lst]\n (map\n (fn\n [n]\n (if (neg? n)\n (+ (* n -2) n)\n n))\n lst))\n"
},
{
"path": "competitive-programming/hacker-rank/python/basic_data_types/finding_the_percentage.py",
"content": "# https://www.hackerrank.com/challenges/finding-the-percentage/problem\n\nif __name__ == '__main__':\n n = int(raw_input())\n student_marks = {}\n\n for _ in range(n):\n line = raw_input().split()\n name, scores = line[0], line[1:]\n scores = map(float, scores)\n student_marks[name] = scores\n\n print('%.2f' %(sum(student_marks[raw_input()]) / 3))\n"
},
{
"path": "competitive-programming/hacker-rank/python/basic_data_types/lists.py",
"content": "if __name__ == '__main__':\n N = int(raw_input())\n l = []\n\n for i in range(N):\n u_input = raw_input().split(' ')\n\n if u_input[0] == 'insert':\n l.insert(int(u_input[1]), int(u_input[2]))\n elif u_input[0] == 'remove':\n l.remove(int(u_input[1]))\n elif u_input[0] == 'append':\n l.append(int(u_input[1]))\n elif u_input[0] == 'sort':\n l.sort()\n elif u_input[0] == 'pop':\n l.pop()\n elif u_input[0] == 'reverse':\n l.reverse()\n else:\n print(l)\n"
},
{
"path": "competitive-programming/hacker-rank/python/basic_data_types/nested_list.py",
"content": "# https://www.hackerrank.com/challenges/nested-list/problem\n\nmarksheet = [[raw_input(), float(raw_input())] for _ in range(int(raw_input()))]\nsecond_lowest = sorted(list(set([score for name, score in marksheet])))[1]\nnames = sorted([name for name, score in marksheet if score == second_lowest])\n\nfor name in names:\n print name\n"
},
{
"path": "competitive-programming/hacker-rank/python/basic_data_types/runner_up_score.py",
"content": "# [1,6,3,6,5,4]\n# [1,-1]\n# [6, 1]\n# [6, 3]\n# [6, 3]\n# [6, 5]\n# [6, 5]\n\nif __name__ == '__main__':\n n = int(raw_input())\n arr = map(int, raw_input().split())\n\n maximum = -999999999999999999999\n runner_up = -999999999999999999999\n\n for el in arr:\n if el > maximum:\n runner_up = maximum\n maximum = el\n elif el < maximum and el > runner_up:\n runner_up = el\n\n print(runner_up)\n"
},
{
"path": "competitive-programming/hacker-rank/python/basic_data_types/tuple.py",
"content": "# https://www.hackerrank.com/challenges/python-tuples/problem\n\nif __name__ == '__main__':\n n = int(raw_input())\n integer_list = map(int, raw_input().split())\n print(hash(tuple(integer_list)))\n"
},
{
"path": "competitive-programming/hacker-rank/python/introduction/arithmetic_operators.py",
"content": "if __name__ == '__main__':\n a = int(raw_input())\n b = int(raw_input())\n print(a + b)\n print(a - b)\n print(a * b)\n"
},
{
"path": "competitive-programming/hacker-rank/python/introduction/division.py",
"content": "from __future__ import division\n\nif __name__ == '__main__':\n a = int(raw_input())\n b = int(raw_input())\n print(a // b)\n print(a / b)\n"
},
{
"path": "competitive-programming/hacker-rank/python/introduction/if_else.py",
"content": "if __name__ == '__main__':\n n = int(raw_input())\n\n if n % 2 != 0:\n print(\"Weird\")\n else:\n if n >= 2 and n <= 5:\n print(\"Not Weird\")\n elif n >= 6 and n <= 20:\n print(\"Weird\")\n elif n > 20:\n print(\"Not Weird\")\n"
},
{
"path": "competitive-programming/hacker-rank/python/sets/intro_to_sets.py",
"content": "# https://www.hackerrank.com/challenges/py-introduction-to-sets/problem\n\ndef average(array):\n return sum(list(set(array))) / float(len(set(array)))\n"
},
{
"path": "competitive-programming/hacker-rank/python/strings/find_a_string.py",
"content": "# https://www.hackerrank.com/challenges/find-a-string/problem\n\n# ABCDCDC\n# CDC\n# 2\n\n# ABCDCDCD\n# CD\n# 3\n\n# ABCDCDC\n# AD\n# 0\n\ndef count_substring(string, sub_string):\n counter = 0\n\n for index in range(0, len(string) - len(sub_string) + 1):\n if sub_string == string[index:index + len(sub_string)]:\n counter += 1\n\n return counter\n\nprint(count_substring('ABCDCDC', 'CDC'))\nprint(count_substring('ABCDCDCD', 'CD'))\nprint(count_substring('ABCDCDC', 'AD'))\n"
},
{
"path": "competitive-programming/hacker-rank/python/strings/mutate_string.py",
"content": "# https://www.hackerrank.com/challenges/python-mutations/problem\n\n# abracadabra\n# 5 k\n# abrackdabra\n\ndef mutate_string(string, position, character):\n mutated_string = ''\n\n for i in range(len(string)):\n if i == position:\n mutated_string += character\n else:\n mutated_string += string[i]\n\n return mutated_string\n\nprint(mutate_string('abracadabra', 5, 'k'))\n"
},
{
"path": "competitive-programming/hacker-rank/python/strings/split_and_join.py",
"content": "# https://www.hackerrank.com/challenges/python-string-split-and-join/problem\n\n# this is a string => this-is-a-string\n# 123 456 789 => 123-456-789\n# ... ... ... => ...-...-...\n\ndef split_and_join(line):\n new_line = ''\n\n for c in line:\n if c == ' ':\n new_line += '-'\n else:\n new_line += c\n\n return new_line\n\nprint(split_and_join('this is a string'))\nprint(split_and_join('123 456 789'))\nprint(split_and_join('... ... ...'))\nprint(split_and_join('... ... ... '))\n"
},
{
"path": "competitive-programming/hacker-rank/python/strings/string_validators.py",
"content": "# https://www.hackerrank.com/challenges/string-validators/problem\n\nif __name__ == '__main__':\n s = raw_input()\n print(any(c.isalnum() for c in s))\n print(any(c.isalpha() for c in s))\n print(any(c.isdigit() for c in s))\n print(any(c.islower() for c in s))\n print(any(c.isupper() for c in s))\n"
},
{
"path": "competitive-programming/hacker-rank/python/strings/swap_case.py",
"content": "# https://www.hackerrank.com/challenges/swap-case/problem\n\n# A - Z (65 - 90)\n# a - z (97 - 122)\n\ndef swap_case(s):\n difference = 32\n swapped_s = ''\n\n for i in s:\n if ord(i) < 65 or (ord(i) > 90 and ord(i) < 97) or ord(i) > 122:\n swapped_s += i\n elif ord(i) <= 90:\n swapped_s += chr(ord(i) + difference)\n else:\n swapped_s += chr(ord(i) - difference)\n\n\n return swapped_s\n\nprint(swap_case('Www.HackerRank.com'))\nprint(swap_case('Pythonist 2'))\nprint(swap_case('HackerRank.com presents \"Pythonist 2\".'))\n"
},
{
"path": "competitive-programming/hacker-rank/python/strings/text_wrap.py",
"content": "# https://www.hackerrank.com/challenges/text-wrap/problem\n\nimport textwrap\n\ndef wrap(string, max_width):\n wrapped_text = ''\n\n for i in range(1, len(string) + 1):\n if i % max_width == 0:\n wrapped_text += string[i-1]\n print(wrapped_text)\n wrapped_text = ''\n else:\n wrapped_text += string[i-1]\n\n return wrapped_text\n\nprint(wrap('ABCDEFGHIJKLIMNOQRSTUVWXYZ', 4))\n"
},
{
"path": "competitive-programming/hacker-rank/python/strings/whats_your_name.py",
"content": "# https://www.hackerrank.com/challenges/whats-your-name/problem\n\n# Guido\n# Rossum\n# Hello Guido Rossum! You just delved into python.\n\ndef print_full_name(a, b):\n print \"Hello %s %s! You just delved into python.\" %(a, b)\n\nprint_full_name('Guido', 'Rossum')\n"
},
{
"path": "competitive-programming/interfatecs/1_2016/a.cpp",
"content": "#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n\n int marq, n, e;\n string s;\n\n while (cin >> marq) {\n cin >> n;\n cin.ignore();\n getline(cin, s);\n string st = s + s;\n cin >> e;\n e = e % n;\n\n while(st.size() < marq) {\n st += s;\n }\n\n if (marq > n) cout << st.substr(e, n) << endl;\n else cout << st.substr(e, marq) << endl;\n }\n\n return 0;\n}\n"
},
{
"path": "competitive-programming/interfatecs/1_2016/b.cpp",
"content": "#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n\n int n;\n\n while (cin >> n && n != -1) {\n cout << 31 % n << endl;\n }\n\n return 0;\n}\n"
},
{
"path": "competitive-programming/interfatecs/1_2016/g.cpp",
"content": "#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n\n int n;\n double bang;\n cin >> n;\n\n while (n--) {\n vector v;\n for (int i = 0; i < 12; i++) {\n cin >> bang;\n v.push_back(bang);\n }\n\n sort(v.begin(), v.end());\n\n float total = 0;\n\n for (int i = 3; i < 12; i++) {\n total += v[i];\n }\n\n float media = total / 9;\n\n if (media * 0.2 < 1.75) {\n cout << \"REPROVADO\" << endl;\n } else {\n double coisa = ((5.75 - (media * 0.2)) / 0.8) * 2;\n printf(\"%.1f\\n\", coisa);\n }\n }\n\n return 0;\n}\n"
},
{
"path": "competitive-programming/interfatecs/1_2016/i.cpp",
"content": "#include \n#include \n\nusing namespace std;\n\nint main() {\n\n double br, ext, h, gastobr, gastoext, cam;\n\n cin >> br >> ext >> h >> gastobr >> gastoext >> cam;\n double bang = (br * h * (1 - gastobr / 100) * 1.01);\n bang += (br * h * (1 - gastobr / 100) * 1.01 * 1.01 * 1.01);\n bang += (br * h * (1 - gastobr / 100)* 1.01 * 1.01);\n\n double bang2 = 0;\n bang2 += (ext * h * cam * (1 - gastoext / 100)* 1.01);\n bang2 += (ext * h * cam * (1 - gastoext / 100)* 1.01* 1.01);\n bang2 += (ext * h * cam * (1 - gastoext / 100)* 1.01* 1.01* 1.01);\n\n\n printf(\"%.2fBR %.2fES\\n\", (bang), bang2);\n\n return 0;\n}\n"
},
{
"path": "competitive-programming/interfatecs/1_2018/a.cpp",
"content": "// A\r\n\r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include