├── testing.js ├── linkedlist └── belumada.js ├── README.md ├── package.json ├── database ├── 182.sql ├── 511.sql ├── 627.sql ├── 1050.sql ├── 175.sql ├── 620.sql ├── 1393.sql ├── 1693.sql ├── 1484.sql ├── 1158.sql ├── 183.sql ├── 184.sql ├── 1965.sql ├── 1587.sql ├── contoh.py └── 1934.sql ├── test ├── palindrome.js ├── soal.js ├── bintodec.py ├── palindromeNumber.js ├── searchInsert.js ├── 5medium.js ├── lovepattern.py ├── love.js ├── hashmap.js ├── penjualan.js ├── longestcommonsubsequence.js └── maximumSumofDistinctSubarraysWithLengthK.js ├── matematika ├── perpangkatan.js ├── 9.py ├── factorial.js ├── numberisFascinating.js ├── fibbonaci.js ├── pascalTriangle.js ├── triangle.js ├── evenNumberDivisibleByThree.js └── 258.js ├── array ├── keepMultiplying.js ├── 1051.js ├── FindtheHighestAltitude.js ├── removeElement.js ├── sortArrayParity.js ├── 2006.js ├── 2535.js ├── maximumSumWithExactlyK.js ├── MedianofTwoSortedArrays.js ├── 77.js ├── moveZeroes.js ├── summaryRanges.js ├── largestOdd.js ├── 2640medium.js ├── 2079.js ├── buildArrayPermutation.js ├── twoSum.js ├── chunkArray.js ├── concatenationOfArray.js ├── applyTransformEachElement.js ├── filterElementsArray.js ├── 1343medium.js ├── numberOfSeniorCitizens.js ├── 1380.js ├── sumMultiples.js ├── 1630.js ├── largestSubstringTwoEqual.js ├── arrayReduce.js ├── 2125medium.js └── applyOperationsToArray.js ├── matriks ├── 2545medium.js ├── 867.js ├── flippingImage.js ├── 766.js ├── 2428medium.js ├── 566.js ├── richestCustomer.js ├── 2319.js ├── 2482.js ├── 2373.js ├── matrixDiagonal.js ├── circularMatrix.js ├── 2500.js ├── 36medium.js └── equalRowColumns.js ├── hashmap ├── 961.js ├── 1399.js ├── 169.js ├── 2465.js ├── 442.js ├── 2418.js ├── 791medium.js ├── 1748.js ├── 347medium.js ├── containsDouble.js ├── 448.js ├── 532.js ├── 1436.js ├── 1636.js ├── 2670.js ├── 1496.js ├── 2610medium.js ├── 2554.js ├── 383.js ├── next.js ├── validAnagram.js ├── 73medium.js ├── counterfunction.js ├── 2024medium.js ├── 2657.js ├── 451medium.js ├── 804.js ├── 2404.js ├── happyNumber.js ├── 692medium.js ├── 01.js ├── 1817medium.js ├── 1122.js ├── 1282.js ├── 1365.js ├── wordPattern.js ├── singleNumber.js ├── luckyNumber.js ├── 2284medium.js ├── 73.js ├── 532medium.js ├── 929.JS ├── url.js └── nextGreater.js ├── string ├── 1768.js ├── checkStringEquivalent.js ├── twaostring.js ├── stringconstruction.js ├── 2586.js ├── 1876.js ├── 1108.js ├── 2186medium.js ├── isomorphicString.js ├── 2243.js ├── 917.py ├── reverseWords.js ├── shuffleString.js ├── 917.js ├── 28.js └── truncateSentence.js ├── sorting └── findTargetIndices.js ├── stack ├── 1614.js ├── 739.js ├── 2390.js ├── 1598.js ├── 1047.js ├── 1209.js ├── 844.js ├── 1381.js ├── 71.js ├── 1700.js ├── 682.js ├── 345.js ├── 97.js └── 20.js ├── rekursif ├── climbingStairs.js ├── combinationSum.js ├── sumDigits.js ├── subsetSum.js └── howSum.js ├── binarySearch ├── 852.js ├── 162.js ├── binarySearch.js ├── 2300.js ├── 1351.js ├── 1870.js ├── 2389.js ├── 2070medium.js ├── 74.js └── 34medium.js ├── greedy └── 1323.js ├── simulation ├── 1773.js ├── 985medium.js └── 2391medium.js ├── prefixsum ├── 2574.js ├── 2270.js ├── 2485.js ├── 724.js ├── 2090medium.js └── 1588.js ├── design ├── 705.js ├── 1357.py ├── 1656.js ├── 303.js ├── 706.js ├── functionComposition.js ├── 1603.js ├── 307medium(TLE).js ├── counterII.js ├── 1357.js └── 1865.js └── .gitignore /testing.js: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /linkedlist/belumada.js: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # leetcode-fikrimln16 2 | Kumpulan Code Code LeetCode ! 3 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "dependencies": { 3 | "mysql": "^2.18.1" 4 | } 5 | } 6 | -------------------------------------------------------------------------------- /database/182.sql: -------------------------------------------------------------------------------- 1 | SELECT email 2 | FROM Person 3 | GROUP BY email 4 | HAVING count(email) > 1 -------------------------------------------------------------------------------- /database/511.sql: -------------------------------------------------------------------------------- 1 | SELECT player_id, MIN(event_date) as 'first_login' 2 | FROM Activity 3 | GROUP BY player_id -------------------------------------------------------------------------------- /database/627.sql: -------------------------------------------------------------------------------- 1 | UPDATE salary 2 | SET sex = CASE 3 | WHEN sex = 'm' THEN 'f' 4 | WHEN sex = 'f' THEN 'm' 5 | END -------------------------------------------------------------------------------- /database/1050.sql: -------------------------------------------------------------------------------- 1 | SELECT actor_id, director_id 2 | FROM ActorDirector 3 | GROUP BY actor_id, director_id 4 | HAVING COUNT(timestamp) >= 3 -------------------------------------------------------------------------------- /database/175.sql: -------------------------------------------------------------------------------- 1 | SELECT p.firstName, p.lastName, a.city, a.state 2 | FROM Person p 3 | LEFT JOIN Address a ON p.personId = a.personId 4 | -------------------------------------------------------------------------------- /database/620.sql: -------------------------------------------------------------------------------- 1 | SELECT id, movie, description, rating 2 | FROM Cinema 3 | WHERE id % 2 = 1 AND description != "boring" 4 | ORDER BY rating DESC 5 | -------------------------------------------------------------------------------- /database/1393.sql: -------------------------------------------------------------------------------- 1 | SELECT stock_name, SUM(CASE WHEN operation = "Buy" THEN price * -1 ELSE price END) as 'capital_gain_loss' 2 | FROM Stocks 3 | GROUP BY stock_name 4 | ORDER BY capital_gain_loss DESC -------------------------------------------------------------------------------- /database/1693.sql: -------------------------------------------------------------------------------- 1 | SELECT date_id, make_name, COUNT(DISTINCT lead_id) as 'unique_leads', 2 | COUNT(DISTINCT partner_id) as 'unique_partners' 3 | 4 | FROM DailySales 5 | GROUP BY date_id, make_name -------------------------------------------------------------------------------- /test/palindrome.js: -------------------------------------------------------------------------------- 1 | const palindrome = (input) => { 2 | const reversed = input.split("").reverse().join(""); 3 | return input === reversed; 4 | }; 5 | 6 | console.log(palindrome("katak")); 7 | -------------------------------------------------------------------------------- /matematika/perpangkatan.js: -------------------------------------------------------------------------------- 1 | const perpangkatan = (base, exponent) => { 2 | if(exponent === 0) return 1; 3 | return base * perpangkatan(base, exponent-1) 4 | } 5 | 6 | console.log(perpangkatan(2, 10)); -------------------------------------------------------------------------------- /array/keepMultiplying.js: -------------------------------------------------------------------------------- 1 | var findFinalValue = function(nums, original) { 2 | while(nums.includes(original)){ 3 | original *=2 4 | } 5 | return original 6 | }; 7 | 8 | console.log(findFinalValue([5,3,6,1,12], 3)); // 24 -------------------------------------------------------------------------------- /database/1484.sql: -------------------------------------------------------------------------------- 1 | SELECT sell_date, count(DISTINCT(product)) as num_sold, 2 | GROUP_CONCAT(DISTINCT product ORDER BY product ASC SEPARATOR ',') AS products 3 | FROM Activities 4 | GROUP BY sell_date 5 | ORDER BY sell_date ASC -------------------------------------------------------------------------------- /database/1158.sql: -------------------------------------------------------------------------------- 1 | SELECT u.user_id as buyer_id, u.join_date, COUNT(order_id) as orders_in_2019 2 | 3 | FROM Users u 4 | LEFT JOIN Orders o 5 | ON u.user_id = o.buyer_id 6 | 7 | AND YEAR(o.order_date)=2019 8 | GROUP BY u.user_id 9 | -------------------------------------------------------------------------------- /matriks/2545medium.js: -------------------------------------------------------------------------------- 1 | var sortTheStudents = function(score, k) { 2 | 3 | return score.sort((a, b) => b[k] - a[k]) 4 | }; 5 | 6 | console.log(sortTheStudents([[10,6,9,1],[7,5,11,2],[4,8,3,15]], 2)) 7 | console.log(sortTheStudents([[3,4],[5,6]], 0)) -------------------------------------------------------------------------------- /hashmap/961.js: -------------------------------------------------------------------------------- 1 | var repeatedNTimes = function(nums) { 2 | let map = new Map() 3 | for(num of nums){ 4 | map.set(num, (map.get(num) || 0) + 1) 5 | if(map.get(num) === nums.length / 2) return num 6 | } 7 | }; 8 | 9 | console.log(repeatedNTimes([1,2,3,3])); -------------------------------------------------------------------------------- /database/183.sql: -------------------------------------------------------------------------------- 1 | #CARA 1 2 | SELECT name as Customers 3 | FROM Customers c 4 | LEFT JOIN Orders o 5 | ON c.id = o.customerId 6 | WHERE o.id IS NULL 7 | 8 | #CARA 2 9 | SELECT c.Name as Customers 10 | FROM Customers c 11 | WHERE c.Id NOT IN (SELECT b.CustomerId from Orders b) -------------------------------------------------------------------------------- /test/soal.js: -------------------------------------------------------------------------------- 1 | 2 | let arr = ['p','i','k','e','r','i'] 3 | 4 | let i = 0 5 | let res = '' 6 | 7 | while(i < arr.length){ 8 | res+=arr.pop() 9 | i++ 10 | } 11 | 12 | console.log(res) 13 | 14 | // A. pik 15 | // B. pikeri 16 | // C. eri 17 | // D. ire 18 | // E. irekip -------------------------------------------------------------------------------- /database/184.sql: -------------------------------------------------------------------------------- 1 | SELECT d.name AS Department, e.name AS Employee, e.salary AS Salary 2 | FROM Employee e 3 | JOIN Department d ON e.departmentId = d.id 4 | WHERE (e.departmentId, e.salary) IN ( 5 | SELECT departmentId, MAX(salary) 6 | FROM Employee 7 | GROUP BY departmentId 8 | ) 9 | 10 | -------------------------------------------------------------------------------- /matematika/9.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def isPalindrome(self, x: int) -> bool: 3 | 4 | temp = x 5 | p = 0 6 | while temp > 0: 7 | bil_akhir = temp % 10 8 | p = p * 10 + bil_akhir 9 | temp //= 10 10 | 11 | return p == x 12 | -------------------------------------------------------------------------------- /test/bintodec.py: -------------------------------------------------------------------------------- 1 | binary = int(input()) 2 | 3 | def convertToDecimal(binary: int): 4 | temp = binary 5 | dec, i = 0, 0 6 | 7 | while temp > 0: 8 | dec += (2 ** i * temp % 10) 9 | temp //= 10 10 | i += 1 11 | 12 | return dec 13 | 14 | print(convertToDecimal(binary)) -------------------------------------------------------------------------------- /array/1051.js: -------------------------------------------------------------------------------- 1 | var heightChecker = function(heights) { 2 | let res = 0 3 | const sorted = [...heights].sort((a, b) => a - b); 4 | for (let i = 0; i < heights.length; i++) { 5 | if(heights[i] !== sorted[i]) res++ 6 | } 7 | return res 8 | }; 9 | 10 | console.log(heightChecker([5,1,2,3,4])); -------------------------------------------------------------------------------- /array/FindtheHighestAltitude.js: -------------------------------------------------------------------------------- 1 | var largestAltitude = function(gain) { 2 | let curr = 0; 3 | let max = 0; 4 | 5 | for (let i=0; i < gain.length; i++){ 6 | curr += gain[i]; 7 | max = Math.max(curr, max); 8 | } 9 | return max; 10 | }; 11 | 12 | console.log(largestAltitude([52,-91,72])); 13 | -------------------------------------------------------------------------------- /hashmap/1399.js: -------------------------------------------------------------------------------- 1 | var countLargestGroup = function(n) { 2 | 3 | let map = new Map() 4 | 5 | for (let i = 1; i <= n; i++) { 6 | let math = i%10 7 | math 8 | let temp = [math] 9 | map.set(i, temp) 10 | } 11 | 12 | map 13 | 14 | }; 15 | 16 | console.log(countLargestGroup(13)); -------------------------------------------------------------------------------- /string/1768.js: -------------------------------------------------------------------------------- 1 | var mergeAlternately = function(word1, word2) { 2 | let res = '' 3 | for (let i = 0; i < Math.max(word1.length, word2.length); i++) { 4 | if(word1[i]) res+= word1[i] 5 | if(word2[i]) res+= word2[i] 6 | } 7 | return res 8 | }; 9 | 10 | console.log(mergeAlternately("abc", "pqrasdasd")); -------------------------------------------------------------------------------- /string/checkStringEquivalent.js: -------------------------------------------------------------------------------- 1 | var arrayStringsAreEqual = function(word1, word2) { 2 | 3 | let kata1 = word1.join('') 4 | let kata2 = word2.join('') 5 | if(kata1 === kata2){ 6 | return true 7 | } 8 | 9 | return false 10 | }; 11 | 12 | console.log(arrayStringsAreEqual(["ab", "c"], ["a", "bc"])); -------------------------------------------------------------------------------- /database/1965.sql: -------------------------------------------------------------------------------- 1 | SELECT s.employee_id 2 | FROM Salaries s 3 | LEFT JOIN Employees e ON s.employee_id = e.employee_id 4 | WHERE e.employee_id IS NULL 5 | 6 | UNION ALL 7 | 8 | SELECT e.employee_id 9 | FROM Employees e 10 | LEFT JOIN Salaries s ON e.employee_id = s.employee_id 11 | WHERE s.employee_id IS NULL 12 | 13 | ORDER BY employee_id; -------------------------------------------------------------------------------- /hashmap/169.js: -------------------------------------------------------------------------------- 1 | var majorityElement = function (nums) { 2 | const n = nums.length; 3 | const map = new Map(); 4 | for (let i = 0; i < n; i++) { 5 | map.set(nums[i], (map.get(nums[i]) || 0) + 1); 6 | if (map.get(nums[i]) > n / 2) return nums[i]; 7 | } 8 | return -1; 9 | }; 10 | 11 | console.log(majorityElement([2,2,1,1,1,2,2])); //2 -------------------------------------------------------------------------------- /sorting/findTargetIndices.js: -------------------------------------------------------------------------------- 1 | var targetIndices = function(nums, target) { 2 | let sorted = nums.sort((a,b) => a-b) 3 | let indexs = [] 4 | sorted.map((element, index) => { 5 | if(element === target){ 6 | indexs.push(index) 7 | } 8 | }) 9 | 10 | return indexs 11 | }; 12 | 13 | console.log(targetIndices([1,2,5,2,3], 5)); // [4] -------------------------------------------------------------------------------- /array/removeElement.js: -------------------------------------------------------------------------------- 1 | var removeElement = function(nums, val) { 2 | 3 | let res = 0; 4 | for(let i = 0; i < nums.length; i++){ 5 | if(nums[i] != val){ 6 | nums[res++] = nums[i] 7 | } 8 | } 9 | 10 | return res 11 | }; 12 | 13 | console.log(removeElement([3,2,2,3], 3)); 14 | console.log(removeElement([0,1,2,2,3,0,4,2], 2)); -------------------------------------------------------------------------------- /hashmap/2465.js: -------------------------------------------------------------------------------- 1 | var distinctAverages = function(nums) { 2 | 3 | let sorted = nums.sort((a, b) => a-b) 4 | let set = new Set() 5 | while(sorted.length !== 0){ 6 | let avg = (sorted.shift() + sorted.pop()) / 2 7 | set.add(avg) 8 | } 9 | 10 | return set.size 11 | 12 | }; 13 | 14 | console.log(distinctAverages([1,100])); // 1 -------------------------------------------------------------------------------- /matematika/factorial.js: -------------------------------------------------------------------------------- 1 | const factorial = (n) => { 2 | // Basis: jika n adalah 0 atau 1, kembalikan 1 3 | if (n === 0 || n === 1) { 4 | return 1; 5 | } 6 | 7 | // Rekursi: hitung faktorial dari n-1 dan kalikan dengan n 8 | return n * factorial(n - 1); 9 | } 10 | 11 | // Contoh penggunaan 12 | console.log(factorial(5)); // Output: 120 13 | -------------------------------------------------------------------------------- /hashmap/442.js: -------------------------------------------------------------------------------- 1 | const findDuplicates = nums => { 2 | const map = new Map(); 3 | const res = []; 4 | 5 | nums.forEach(num => { 6 | map.set(num, (map.get(num) || 0) + 1); 7 | if (map.get(num) === 2) { 8 | res.push(num); 9 | } 10 | }); 11 | 12 | return res; 13 | }; 14 | 15 | console.log(findDuplicates([4, 3, 2, 7, 8, 2, 3, 1])); 16 | -------------------------------------------------------------------------------- /array/sortArrayParity.js: -------------------------------------------------------------------------------- 1 | var sortArrayByParity = function(nums) { 2 | let res = [] 3 | let even = [] ; let odd = [] 4 | nums.map((element) => { 5 | if(element % 2 === 0){ 6 | even.push(element) 7 | } else { 8 | odd.push(element) 9 | } 10 | }) 11 | 12 | return res.concat(even, odd) 13 | }; 14 | 15 | console.log(sortArrayByParity([3,1,2,4])); //[2,4,3,1] -------------------------------------------------------------------------------- /array/2006.js: -------------------------------------------------------------------------------- 1 | var countKDifference = function(nums, k) { 2 | 3 | let count = 0 4 | for (let i = 0; i < nums.length; i++) { 5 | const element = nums[i]; 6 | for (let j = 0; j < nums.length; j++) { 7 | const diff = nums[j]; 8 | if(diff === element + k) count++ 9 | } 10 | } 11 | return count 12 | }; 13 | 14 | console.log(countKDifference([3,1,4,1,5], 0)); -------------------------------------------------------------------------------- /array/2535.js: -------------------------------------------------------------------------------- 1 | var differenceOfSum = function(nums) { 2 | 3 | let a = 0 4 | let b = 0 5 | for (let i = 0; i < nums.length; i++) { 6 | a += nums[i] 7 | const element = String(nums[i]).split(''); 8 | for (let j = 0; j < element.length; j++) { 9 | b+=parseInt(element[j]); 10 | } 11 | } 12 | return a - b 13 | }; 14 | 15 | console.log(differenceOfSum([1,15,6,3])); -------------------------------------------------------------------------------- /database/1587.sql: -------------------------------------------------------------------------------- 1 | SELECT u.name, SUM(amount) as 'balance' 2 | FROM Transactions t 3 | JOIN Users u ON t.account = u.account 4 | GROUP BY t.account 5 | HAVING balance > 10000 6 | 7 | CREATE FUNCTION getNthHighestSalary(N INT) RETURNS INT 8 | BEGIN 9 | SET N = N - 1; 10 | RETURN ( 11 | SELECT DISTINCT(salary) 12 | FROM Employee 13 | ORDER BY salary DESC 14 | LIMIT 1 OFFSET N 15 | ); 16 | END -------------------------------------------------------------------------------- /matematika/numberisFascinating.js: -------------------------------------------------------------------------------- 1 | var isFascinating = function(n) { 2 | 3 | //gabungkan jadi satu 4 | let res = `${n}${n*2}${n*3}`.split('') 5 | 6 | if(res.includes('0')){ 7 | return false 8 | } 9 | if(res.length !== 9){ 10 | return false 11 | } 12 | if ((new Set(res)).size !== 9) { 13 | return false 14 | } 15 | 16 | return true 17 | }; 18 | 19 | console.log(isFascinating(183)); -------------------------------------------------------------------------------- /hashmap/2418.js: -------------------------------------------------------------------------------- 1 | var sortPeople = function(names, heights) { 2 | let map = new Map() 3 | for (let i = 0; i < names.length; i++) { 4 | map.set(heights[i], names[i]) 5 | } 6 | return res = Array.from(map.entries()).sort((a,b) => b[0] - a[0]).map(element => element[1]) 7 | }; 8 | 9 | console.log(sortPeople(["Mary","John","Emma"], [180,165,170])); 10 | console.log(sortPeople(["Alice","Bob","Bob"], [155,185,150])); -------------------------------------------------------------------------------- /string/twaostring.js: -------------------------------------------------------------------------------- 1 | function twoStrings(s1, s2) { 2 | // Create a Set from s2 characters 3 | const charSet = new Set(s2); 4 | 5 | // Iterate through s1 characters 6 | for (let i = 0; i < s1.length; i++) { 7 | const char = s1[i]; 8 | if (charSet.has(char)) { 9 | return "YES"; 10 | } 11 | } 12 | 13 | return "NO"; 14 | 15 | } 16 | 17 | console.log(twoStrings("zzz", "world")); -------------------------------------------------------------------------------- /hashmap/791medium.js: -------------------------------------------------------------------------------- 1 | const customSortString = (order, s) => { 2 | let orderMap = new Map(); 3 | for (let i = 0; i < order.length; i++) { 4 | orderMap.set(order[i], i); 5 | } 6 | 7 | let chars = s.split(""); 8 | 9 | chars.sort((a, b) => (orderMap.get(a) || 0) - (orderMap.get(b) || 0)); 10 | 11 | let sortedString = chars.join(""); 12 | 13 | return sortedString; 14 | }; 15 | 16 | console.log(customSortString("cbadaaa", "abcdaa")); 17 | -------------------------------------------------------------------------------- /matriks/867.js: -------------------------------------------------------------------------------- 1 | var transpose = function(matrix) { 2 | 3 | let res = [] 4 | for (let i = 0; i < matrix[0].length; i++) { 5 | let temp = [] 6 | for (let j = 0; j < matrix.length; j++) { 7 | let a = matrix[j][i] 8 | temp.push(a) 9 | } 10 | res.push(temp) 11 | } 12 | 13 | return res 14 | }; 15 | 16 | console.log(transpose([[1,2,3],[4,5,6]])); 17 | // console.log(transpose([[1,2,3],[4,5,6],[7,8,9]])); -------------------------------------------------------------------------------- /test/palindromeNumber.js: -------------------------------------------------------------------------------- 1 | function isPalindrome(num) { 2 | if (num < 0 || (num % 10 === 0 && num !== 0)) { 3 | return false; 4 | } 5 | 6 | let reversedNum = 0; 7 | let originalNum = num; 8 | while (num > 0) { 9 | num 10 | reversedNum = (reversedNum * 10) + (num % 10); 11 | reversedNum 12 | num = Math.floor(num / 10); 13 | num 14 | } 15 | return originalNum === reversedNum; 16 | } 17 | 18 | console.log(isPalindrome(123)); -------------------------------------------------------------------------------- /array/maximumSumWithExactlyK.js: -------------------------------------------------------------------------------- 1 | var maximizeSum = function(nums, k) { 2 | let end = nums.length-1 3 | let temp = [] 4 | for (let i = 0; i < k; i++) { 5 | let arr = [] 6 | const element = nums[end]; 7 | element 8 | temp 9 | arr.push(temp + nums[end]) 10 | temp.push([...arr]) 11 | nums[end] = element+1 12 | } 13 | return temp 14 | }; 15 | 16 | console.log(maximizeSum([1,2,3,4,5], 3)) 17 | // console.log(maximizeSum([5,5,5], 2)) -------------------------------------------------------------------------------- /hashmap/1748.js: -------------------------------------------------------------------------------- 1 | var sumOfUnique = function(nums) { 2 | let map = new Map() 3 | let res = 0 4 | nums.forEach((element) => { 5 | map.set(element, (map.get(element) || 0) + 1) 6 | }) 7 | map.forEach((key, value) => { 8 | if(key == 1){ 9 | res += value 10 | } 11 | }) 12 | return res 13 | }; 14 | 15 | console.log(sumOfUnique([1,2,3,2])); 16 | console.log(sumOfUnique([1,1,1,1])); 17 | console.log(sumOfUnique([1,2,3,4])); -------------------------------------------------------------------------------- /hashmap/347medium.js: -------------------------------------------------------------------------------- 1 | var topKFrequent = function (nums, k) { 2 | const map = new Map(); 3 | for (const num of nums) { 4 | map.set(num, (map.get(num) || 0) + 1); 5 | } 6 | 7 | const result = Array.from(map.entries()) 8 | .sort((a, b) => b[1] - a[1]) 9 | .slice(0, k) 10 | .map(([key]) => key); 11 | 12 | return result; 13 | }; 14 | 15 | console.log(topKFrequent([1, 1, 1, 2, 2, 3], 2)); 16 | console.log(topKFrequent([1], 1)); 17 | -------------------------------------------------------------------------------- /hashmap/containsDouble.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {boolean} 4 | */ 5 | var containsDuplicate = function (nums) { 6 | let map = new Map() 7 | 8 | nums.forEach((element) => { 9 | map.set(element, (map.get(element) || 0) + 1) 10 | }) 11 | map 12 | 13 | for(const value of map.values()){ 14 | if(value>1)return true 15 | } 16 | 17 | return false 18 | }; 19 | 20 | console.log(containsDuplicate([1, 2, 3, 4, 1])); 21 | -------------------------------------------------------------------------------- /hashmap/448.js: -------------------------------------------------------------------------------- 1 | var findDisappearedNumbers = function(nums) { 2 | let res = [] 3 | 4 | let map = new Set(nums) 5 | map // Set {4,3,2,7,8,1} 6 | 7 | //cek apakah dari range 1 - total array ada pada set atau tidak 8 | for (let i = 1; i <= nums.length; i++) { 9 | //jika tidak ada maka tambah kan index ke arr res 10 | if(!map.has(i)) res.push(i) 11 | } 12 | return res 13 | }; 14 | 15 | console.log(findDisappearedNumbers([4,3,2,7,8,2,3,1])); -------------------------------------------------------------------------------- /array/MedianofTwoSortedArrays.js: -------------------------------------------------------------------------------- 1 | var findMedianSortedArrays = function(nums1, nums2) { 2 | let merged = [...nums1, ...nums2].sort((a, b) => a - b); 3 | merged.sort((a, b) => a-b) 4 | let total = merged.length 5 | 6 | if(total % 2 === 0){ 7 | let mid = total / 2; 8 | return med = (merged[mid] + merged[mid-1]) / 2 9 | } else { 10 | return merged[Math.floor(total/2)] 11 | } 12 | }; 13 | 14 | console.log(findMedianSortedArrays([1,3], [2])); -------------------------------------------------------------------------------- /database/contoh.py: -------------------------------------------------------------------------------- 1 | import pandas as pd 2 | 3 | def department_highest_salary(employee: pd.DataFrame, department: pd.DataFrame) -> pd.DataFrame: 4 | merged = employee.merge(department, left_on='departmentId', right_on='id', how='inner') 5 | max_salaries = merged.groupby('name_y')['salary'].transform('max') 6 | result = merged[merged['salary'] == max_salaries][['name_y', 'name_x', 'salary']] 7 | result.columns = ['department', 'employee', 'salary'] 8 | return result -------------------------------------------------------------------------------- /stack/1614.js: -------------------------------------------------------------------------------- 1 | var maxDepth = function(s) { 2 | let stack = [] 3 | 4 | let max = 0 5 | let counter = 0 6 | s.split("").forEach((element) => { 7 | if(element === "("){ 8 | counter++ 9 | max = Math.max(max, counter) 10 | } else if (element === ")"){ 11 | counter-- 12 | max = Math.max(max, counter) 13 | } 14 | }) 15 | 16 | return max 17 | }; 18 | 19 | console.log(maxDepth("(1+(2*3)+((8)/4))+1+((((4)))")); -------------------------------------------------------------------------------- /hashmap/532.js: -------------------------------------------------------------------------------- 1 | var findPairs = function (nums, k) { 2 | 3 | 4 | let map = new Map() 5 | nums.forEach((element) => { 6 | map.set(element, (map.get(element) || 0) + 1) 7 | }) 8 | 9 | let count = 0 10 | map.forEach((value, key) => { 11 | if(k === 0){ 12 | if(value > 1) count++ 13 | } 14 | else{ 15 | if(map.has(key+k)) count++ 16 | } 17 | }) 18 | 19 | return count 20 | }; 21 | 22 | console.log(findPairs([3, 1, 4, 1, 5], 2)); 23 | 24 | 25 | -------------------------------------------------------------------------------- /rekursif/climbingStairs.js: -------------------------------------------------------------------------------- 1 | var climbStairs = function(n) { 2 | if(n === 0) return []; 3 | if(n < 0) return null; 4 | let pengurangan = [1,2] 5 | var total = 0; 6 | 7 | for(num of pengurangan){ 8 | const remainder = n - num; 9 | const combination = climbStairs(remainder); 10 | if (combination !== null) { 11 | total++ 12 | return [...combination, num]; 13 | } 14 | } 15 | 16 | return total 17 | }; 18 | 19 | console.log(climbStairs(10)); -------------------------------------------------------------------------------- /hashmap/1436.js: -------------------------------------------------------------------------------- 1 | var destCity = function (paths) { 2 | let set = new Set(); 3 | 4 | paths.forEach((path) => { 5 | set.add(path[1]); 6 | }); 7 | 8 | set; 9 | 10 | paths.forEach((path) => { 11 | if(set.has(path[0])) set.delete(path[0]) 12 | }) 13 | 14 | 15 | return set.values().next().value; 16 | }; 17 | 18 | console.log( 19 | destCity([ 20 | ["London", "New York"], 21 | ["New York", "Lima"], 22 | ["Lima", "Sao Paulo"], 23 | ]) 24 | ); 25 | -------------------------------------------------------------------------------- /binarySearch/852.js: -------------------------------------------------------------------------------- 1 | var peakIndexInMountainArray = function (arr) { 2 | let left = 0; 3 | let right = arr.length - 1; 4 | 5 | while (left <= right) { 6 | let mid = Math.floor((left + right) / 2); 7 | 8 | if (arr[mid] < arr[mid - 1]) { 9 | right = mid - 1; 10 | } else { 11 | left = mid + 1 12 | } 13 | } 14 | 15 | return right 16 | }; 17 | 18 | console.log( 19 | peakIndexInMountainArray([24, 69, 100, 99, 79, 78, 67, 36, 26, 19]) 20 | ); // 2 21 | -------------------------------------------------------------------------------- /string/stringconstruction.js: -------------------------------------------------------------------------------- 1 | function stringConstruction(s) { 2 | // Write your code here 3 | let map = new Map() 4 | let res = 0 5 | for (let i = 0; i < s.length; i++) { 6 | const element = s[i]; 7 | element 8 | map.set(element, (map.get(element) || 0) + 1) 9 | if(map.get(element) > 1){ 10 | res++ 11 | } 12 | } 13 | if(res){ 14 | return res 15 | } 16 | return s.length 17 | 18 | } 19 | 20 | console.log(stringConstruction("abab")); -------------------------------------------------------------------------------- /binarySearch/162.js: -------------------------------------------------------------------------------- 1 | function findPeakElement(nums) { 2 | let left = 0; 3 | let right = nums.length - 1; 4 | while (left <= right) { 5 | let mid = Math.floor(left + (right - left) / 2); 6 | 7 | if ( 8 | nums[mid] > (nums[mid - 1] || -Infinity) && 9 | nums[mid] > (nums[mid + 1] || -Infinity) 10 | ) return mid; 11 | else if (nums[mid - 1] > nums[mid + 1]) right = mid - 1; 12 | else left = mid + 1; 13 | } 14 | } 15 | console.log(findPeakElement([1, 2, 3, 1])); 16 | -------------------------------------------------------------------------------- /greedy/1323.js: -------------------------------------------------------------------------------- 1 | var maximum69Number = function (num) { 2 | let curMax = -Infinity; 3 | 4 | let length = num.toString().split("").length 5 | 6 | for (let i = 0; i < length; i++) { 7 | let temp = num.toString().split("") 8 | temp 9 | if(temp[i] === "6") { 10 | temp[i] = '9' 11 | } else { 12 | temp[i] = '6' 13 | } 14 | 15 | curMax = Math.max(curMax, temp.join("")) 16 | } 17 | 18 | return curMax 19 | }; 20 | 21 | console.log(maximum69Number(9996)); 22 | -------------------------------------------------------------------------------- /hashmap/1636.js: -------------------------------------------------------------------------------- 1 | var frequencySort = function (nums) { 2 | let map = new Map(); 3 | nums.forEach((element) => { 4 | map.set(element, (map.get(element) || 0) + 1); 5 | }); 6 | 7 | let arr = Array.from(map.entries()).sort((a, b) => { 8 | if (a[1] !== b[1]) { 9 | return a[1] - b[1]; 10 | } 11 | return b[0] - a[0]; 12 | }); 13 | 14 | return arr.flatMap(([key, value]) => Array(value).fill(key)); 15 | }; 16 | 17 | console.log(frequencySort([-1, 1, -6, 4, 5, -6, 1, 4, 1])); 18 | -------------------------------------------------------------------------------- /matriks/flippingImage.js: -------------------------------------------------------------------------------- 1 | var flipAndInvertImage = function(image) { 2 | let res = [] 3 | image.forEach(element => { 4 | let reversed = element.reverse() 5 | let temp = [] 6 | reversed.map((element) => { 7 | if(element === 0){ 8 | temp.push(1) 9 | } else { 10 | temp.push(0) 11 | } 12 | }) 13 | res.push([...temp]) 14 | }); 15 | 16 | return res 17 | }; 18 | 19 | console.log(flipAndInvertImage([[1,1,0],[1,0,1],[0,0,0]])); // [[1,0,0],[0,1,0],[1,1,1]] 20 | -------------------------------------------------------------------------------- /matriks/766.js: -------------------------------------------------------------------------------- 1 | var isToeplitzMatrix = function (matrix) { 2 | if (matrix.length === 1 || matrix[0].length === 1) return true; 3 | 4 | for (let row = 0; row < matrix.length - 1; row++) { 5 | for (let col = 0; col < matrix[0].length - 1; col++) { 6 | if (matrix[row][col] !== matrix[row + 1][col + 1]) { 7 | return false; 8 | } 9 | } 10 | } 11 | 12 | return true; 13 | }; 14 | 15 | console.log( 16 | isToeplitzMatrix([ 17 | [11, 74, 0, 93], 18 | [40, 11, 74, 7], 19 | ]) 20 | ); 21 | -------------------------------------------------------------------------------- /string/2586.js: -------------------------------------------------------------------------------- 1 | var vowelStrings = function (words, left, right) { 2 | const vocal = ["a", "i", "u", "e", "o"]; 3 | let res = 0; 4 | 5 | for (let i = left; i <= right; i++) { 6 | const element = words[i]; 7 | if (vocal.includes(element[0]) && vocal.includes(element[element.length-1])) { 8 | res++; 9 | } 10 | } 11 | 12 | return res; 13 | }; 14 | 15 | // console.log(vowelStrings(["are","amy","u"], 0, 2)); 16 | console.log(vowelStrings(["hey","aeo","mu","ooo","artro"],1, 4)); 17 | -------------------------------------------------------------------------------- /hashmap/2670.js: -------------------------------------------------------------------------------- 1 | var distinctDifferenceArray = function(nums) { 2 | let res = [] 3 | nums.forEach((element, index) => { 4 | let setPrefix = new Set() 5 | let setSuffix = new Set() 6 | 7 | for (let i = 0; i < index+1; i++) { 8 | setPrefix.add(nums[i]) 9 | } 10 | for (let i = index+1; i < nums.length; i++) { 11 | setSuffix.add(nums[i]) 12 | } 13 | res.push(setPrefix.size - setSuffix.size) 14 | }) 15 | 16 | return res 17 | }; 18 | 19 | console.log(distinctDifferenceArray([3,2,3,4,2])); -------------------------------------------------------------------------------- /matriks/2428medium.js: -------------------------------------------------------------------------------- 1 | var maxSum = function(grid) { 2 | let max = 0 3 | 4 | for (let row = 0; row < grid.length-2; row++) { 5 | for (let col = 0; col < grid[0].length-2; col++) { 6 | max = Math.max(max, 7 | grid[row][col] + grid[row][col+1] + grid[row][col+2] + 8 | grid[row+1][col+1] + 9 | grid[row+2][col] + grid[row+2][col+1] + grid[row+2][col+2] 10 | ) 11 | } 12 | } 13 | 14 | return max 15 | }; 16 | 17 | console.log(maxSum([[1,2,3],[4,5,6],[7,8,9]])); -------------------------------------------------------------------------------- /hashmap/1496.js: -------------------------------------------------------------------------------- 1 | var isPathCrossing = function(path) { 2 | let map = {}; 3 | let x = 0; 4 | let y = 0; 5 | map[`${x},${y}`] = true; 6 | 7 | for (let i = 0; i < path.length; i++) { 8 | if (path[i] === "N") y++; 9 | else if (path[i] === "E") x++; 10 | else if (path[i] === "S") y--; 11 | else if (path[i] === "W") x--; 12 | 13 | let newCoor = `${x},${y}`; 14 | 15 | if (map[newCoor]) return true; 16 | map[newCoor] = true; 17 | } 18 | 19 | return false; 20 | }; 21 | 22 | console.log(isPathCrossing("NESWW")); 23 | -------------------------------------------------------------------------------- /hashmap/2610medium.js: -------------------------------------------------------------------------------- 1 | var findMatrix = function (nums) { 2 | let map = new Map(); 3 | let answer = []; 4 | 5 | //counter 6 | for (num of nums) { 7 | map.set(num, (map.get(num) || 0) + 1); 8 | } 9 | 10 | map.forEach((value, key) => { 11 | for (let i = 0; i < value; i++) { 12 | let temp = answer[i] 13 | temp 14 | if (!temp) { 15 | answer.push([]); 16 | } 17 | answer[i].push(key); 18 | } 19 | }); 20 | return answer; 21 | }; 22 | 23 | console.log(findMatrix([1, 2, 3, 1, 2, 1])); 24 | -------------------------------------------------------------------------------- /string/1876.js: -------------------------------------------------------------------------------- 1 | var countGoodSubstrings = function (s) { 2 | let count = 0; 3 | 4 | for (let l = 0; l < s.length - 2; l++) { 5 | const window = `${s[l]}${s[l + 1]}${s[l + 2]}`; 6 | const temp = new Set(window); 7 | if (temp.size === 3) count++; 8 | } 9 | return count; 10 | }; 11 | 12 | // var countGoodSubstrings = function (s) { 13 | // return Array.from({ length: s.length - 2 }, (_, l) => new Set(`${s[l]}${s[l + 1]}${s[l + 2]}`).size === 3).filter(Boolean).length; 14 | // }; 15 | 16 | console.log(countGoodSubstrings("aababcabc")); 17 | -------------------------------------------------------------------------------- /test/searchInsert.js: -------------------------------------------------------------------------------- 1 | var searchInsert = function (nums, target) { 2 | let start = 0; 3 | let end = nums.length-1; 4 | let ans = nums.length 5 | 6 | while(start <= end) { 7 | let mid = Math.floor((start + end) / 2); 8 | if (nums[mid] === target) { 9 | return mid; 10 | } 11 | if (nums[mid] < target) { 12 | start = mid + 1 13 | } 14 | if (nums[mid] > target) { 15 | ans = mid 16 | end = mid - 1 17 | } 18 | } 19 | 20 | return ans 21 | }; 22 | 23 | console.log(searchInsert([1, 3, 5, 6], 3)); // 2 24 | -------------------------------------------------------------------------------- /string/1108.js: -------------------------------------------------------------------------------- 1 | var defangIPaddr = function (address) { 2 | 3 | let res = '' 4 | 5 | for (let i = 0; i < address.length; i++) { 6 | if(address[i] === ".") { 7 | res += "[.]" 8 | } else { 9 | res += address[i] 10 | } 11 | 12 | } 13 | 14 | return res 15 | }; 16 | 17 | var defangIPaddr = function(address) { 18 | return address.replace(/\./g, "[.]") 19 | }; 20 | 21 | var defangIPaddr = function(address) { 22 | return address.replaceAll('.','[.]') 23 | }; 24 | 25 | console.log(defangIPaddr("1.1.1.1")); 26 | -------------------------------------------------------------------------------- /hashmap/2554.js: -------------------------------------------------------------------------------- 1 | var maxCount = function (banned, n, maxSum) { 2 | let currentSum = 0, count = 0; 3 | 4 | let set = new Set(banned) 5 | for (let i = 1; i <= n; i++) { 6 | if (!set.has(i)) { 7 | //jika maxsum masih lebih besar dari currentsum 8 | if(maxSum >= currentSum+i){ 9 | //tambahkan currentsum dengan indeks 10 | currentSum += i 11 | //tambahkan count untuk result 12 | count++ 13 | } 14 | } 15 | } 16 | 17 | return count; 18 | }; 19 | 20 | //[2,3,4] 21 | 22 | console.log(maxCount([11], 7, 50)); 23 | -------------------------------------------------------------------------------- /hashmap/383.js: -------------------------------------------------------------------------------- 1 | var canConstruct = function(ransomNote, magazine) { 2 | let magazineMap = new Map() 3 | 4 | for (const element of magazine) { 5 | magazineMap.set(element, (magazineMap.get(element) || 0) + 1); 6 | } 7 | 8 | for (const element of ransomNote) { 9 | if(magazineMap.has(element) && magazineMap.get(element) > 0) { 10 | magazineMap.set(element, magazineMap.get(element) - 1); 11 | } else { 12 | return false; 13 | } 14 | } 15 | 16 | return true 17 | }; 18 | 19 | console.log(canConstruct("bde", "abbed")); -------------------------------------------------------------------------------- /hashmap/next.js: -------------------------------------------------------------------------------- 1 | var romanToInt = function (s) { 2 | var romanMap = { 3 | I: 1, 4 | V: 5, 5 | X: 10, 6 | L: 50, 7 | C: 100, 8 | D: 500, 9 | M: 1000, 10 | }; 11 | 12 | var hasil = 0; 13 | var prev = 0; 14 | 15 | for (var i = s.length - 1; i >= 0; i--) { 16 | var current = romanMap[s[i]]; 17 | 18 | if (current >= prev) { 19 | hasil += current; 20 | } else { 21 | hasil -= current; 22 | } 23 | 24 | prev = current; 25 | } 26 | 27 | return hasil; 28 | }; 29 | 30 | console.log(romanToInt("II")); 31 | -------------------------------------------------------------------------------- /matematika/fibbonaci.js: -------------------------------------------------------------------------------- 1 | const fibGenerator = (nums, memo = {}) => { 2 | if (nums in memo) { 3 | return memo[nums]; 4 | } 5 | 6 | if (nums === 1) { 7 | memo[1] = [1]; 8 | return memo[1]; 9 | } 10 | 11 | if (nums === 2) { 12 | memo[2] = [1, 1]; 13 | return memo[2]; 14 | } 15 | 16 | const fibArr = fibGenerator(nums - 1, memo); 17 | const nextNum = fibArr[fibArr.length - 1] + fibArr[fibArr.length - 2]; 18 | fibArr.push(nextNum); 19 | 20 | memo[nums] = fibArr; 21 | return fibArr; 22 | }; 23 | 24 | console.log(fibGenerator(4)); 25 | -------------------------------------------------------------------------------- /string/2186medium.js: -------------------------------------------------------------------------------- 1 | var minSteps = function (s, t) { 2 | 3 | let arrS = s.split("") 4 | let arrT = t.split("") 5 | 6 | let count = 0; 7 | for (const char of s.split("")) { 8 | char; 9 | if (!arrT.includes(char)) { 10 | count++; 11 | } 12 | } 13 | count 14 | 15 | let count2 = 0 16 | for (const char of t.split("")) { 17 | char 18 | if (!arrS.includes(char)) { 19 | count2++; 20 | } 21 | } 22 | count2 23 | 24 | return count; 25 | }; 26 | 27 | console.log(minSteps("cotxazilut", "nahrrmcchxwrieqqdwdpneitkxgnt")); 28 | -------------------------------------------------------------------------------- /binarySearch/binarySearch.js: -------------------------------------------------------------------------------- 1 | var binarySearch = function(nums, target) { 2 | let start = 0; 3 | let end = nums.length - 1 4 | let ans = nums.length 5 | while(start <= end){ 6 | let mid = Math.floor((start+end) / 2) 7 | 8 | if(nums[mid] === target){ 9 | return mid; 10 | } 11 | 12 | if ( nums[mid] < target){ 13 | start = mid + 1 14 | } 15 | 16 | if ( nums[mid] > target) { 17 | ans = mid 18 | end = mid - 1 19 | } 20 | } 21 | 22 | return -1 23 | }; 24 | 25 | console.log(binarySearch([-1,0,3,5,9,12], 2)); //1 -------------------------------------------------------------------------------- /hashmap/validAnagram.js: -------------------------------------------------------------------------------- 1 | var isAnagram = function(s, t) { 2 | if (s.length !== t.length) { 3 | return false; 4 | } 5 | 6 | const charCount = {}; 7 | 8 | for (let i = 0; i < s.length; i++) { 9 | const char = s[i]; 10 | charCount[char] = charCount[char] ? charCount[char] + 1 : 1; 11 | } 12 | 13 | for (let i = 0; i < t.length; i++) { 14 | const char = t[i]; 15 | 16 | if (!charCount[char]) { 17 | return false; 18 | } 19 | 20 | charCount[char]--; 21 | } 22 | 23 | return true; 24 | }; 25 | 26 | console.log(isAnagram("rat", "car")) -------------------------------------------------------------------------------- /matriks/566.js: -------------------------------------------------------------------------------- 1 | var matrixReshape = function(mat, r, c) { 2 | 3 | let lokal = [] 4 | for (let row = 0; row < r; row++) { 5 | let temp = [] 6 | for (let col = 0; col < c; col++) { 7 | temp.push(0) 8 | } 9 | lokal.push(temp) 10 | } 11 | 12 | lokal 13 | 14 | for (let row = 0; row < mat.length; row++) { 15 | for (let col = 0; col < mat[0].length; col++) { 16 | lokal[row] = mat[row][col] 17 | } 18 | 19 | } 20 | 21 | lokal 22 | }; 23 | 24 | console.log(matrixReshape([[1,2],[3,4]], 2, 4)); -------------------------------------------------------------------------------- /simulation/1773.js: -------------------------------------------------------------------------------- 1 | var countMatches = function (items, ruleKey, ruleValue) { 2 | let find = 0; 3 | if (ruleKey === "type") find = 0; 4 | if (ruleKey === "color") find = 1; 5 | if (ruleKey === "name") find = 2; 6 | 7 | let arr = items.map((element) => { 8 | return element[find] 9 | }).filter((elemen) => elemen === ruleValue); 10 | 11 | return arr.length; 12 | }; 13 | 14 | console.log( 15 | countMatches( 16 | [["phone","blue","pixel"],["computer","silver","lenovo"],["phone","gold","iphone"]], 17 | "color", 18 | "silver" 19 | ) 20 | ); // 1 21 | -------------------------------------------------------------------------------- /hashmap/73medium.js: -------------------------------------------------------------------------------- 1 | var setZeroes = function(matrix) { 2 | 3 | let map = new Map() 4 | 5 | for (let row = 0; row < matrix.length; row++) { 6 | const element = matrix[row]; 7 | for (let col = 0; col < element.length; col++) { 8 | const element = matrix[row][col]; 9 | element 10 | if(element === 0){ 11 | matrix[row][col] = 0 12 | } 13 | matrix[row][col] = 0 14 | } 15 | 16 | } 17 | map 18 | 19 | 20 | return matrix 21 | }; 22 | 23 | console.log(setZeroes([[0,1,2,0],[3,4,5,2],[1,3,1,5]])); -------------------------------------------------------------------------------- /string/isomorphicString.js: -------------------------------------------------------------------------------- 1 | var isIsomorphic = function (s, t) { 2 | //jika jumlah tidak sama maka false 3 | if (s.length != t.length) return false; 4 | 5 | let temp_1 = []; 6 | let temp_2 = []; 7 | 8 | for (let i = 0; i < s.length; i++) { 9 | temp_1.push(s.indexOf(s[i])); 10 | temp_2.push(t.indexOf(t[i])); 11 | 12 | //ketika tidak sama, berarti terdapat item yang sama, karena akan mengeluarkan index yang sudah ada 13 | if (temp_1[i] != temp_2[i]) return false; 14 | } 15 | return true; 16 | }; 17 | 18 | console.log(isIsomorphic("badc", "ttde")); //false 19 | -------------------------------------------------------------------------------- /matematika/pascalTriangle.js: -------------------------------------------------------------------------------- 1 | var generate = function (numRows) { 2 | let res = []; 3 | if (numRows === 0){ 4 | return res; 5 | } 6 | 7 | res.push([1]); 8 | 9 | for (let i = 1; i < numRows; i++) { 10 | let list = []; 11 | list.push(1); 12 | 13 | for (let j = 1; j < res[i-1].length; j++) { 14 | let prev = res[i-1][j-1] 15 | let next = res[i-1][j] 16 | let sum = prev + next; 17 | list.push(sum); 18 | } 19 | 20 | list.push(1); 21 | 22 | res.push([...list]); 23 | } 24 | 25 | return res; 26 | }; 27 | 28 | console.log(generate(3)); 29 | -------------------------------------------------------------------------------- /matematika/triangle.js: -------------------------------------------------------------------------------- 1 | var minimumTotal = function(triangle) { 2 | let n = triangle.length; 3 | let dp = Array(n).fill(Number.MAX_VALUE).map(()=> Array(n).fill(Number.MAX_VALUE)); 4 | //let min = Number.MAX_VALUE; 5 | function f(i, j){ 6 | if(i == n-1){return triangle[i][j];} 7 | if(dp[i][j] != Number.MAX_VALUE) return dp[i][j]; 8 | let down = triangle[i][j] + f(i+1, j); 9 | let diag = triangle[i][j] + f(i+1, j+1); 10 | return dp[i][j] = Math.min(down, diag); 11 | } 12 | return f(0, 0); 13 | }; 14 | 15 | console.log(minimumTotal([[2],[3,4]])) -------------------------------------------------------------------------------- /hashmap/counterfunction.js: -------------------------------------------------------------------------------- 1 | function counter(iterable) { 2 | const countMap = new Map(); 3 | for (const element of iterable) { 4 | countMap.set(element, (countMap.get(element) || 0) + 1); 5 | } 6 | let set = new Set([1,2,3,4,4,4]) 7 | console.log(set) 8 | return countMap; 9 | 10 | } 11 | 12 | console.log(counter([1, 2, 3, 2, 3])); 13 | 14 | const counts = counter([1, 2, 3, 2, 3, 4]); 15 | console.log(counts.get(1)); // Output: 1 16 | console.log(counts.get(2)); // Output: 2 17 | console.log(counts.get(3)); // Output: 2 18 | console.log(counts.get(4)); // Output: 1 19 | console.log(counts.get(5)); // Output: undefined -------------------------------------------------------------------------------- /matematika/evenNumberDivisibleByThree.js: -------------------------------------------------------------------------------- 1 | var averageValue = (nums) => { 2 | let total = 0; 3 | let even = Math.floor(nums.filter((element) => { 4 | if (element % 3 === 0 && element % 2 === 0) { 5 | total++; 6 | return element % 3 === 0 && element % 2 === 0; 7 | } 8 | }).reduce((cur, number) => { 9 | return cur + number 10 | }, 0) / total); 11 | 12 | 13 | if (total === 0) { 14 | return 0; 15 | } else { 16 | return even; 17 | } 18 | }; 19 | 20 | console.log( 21 | averageValue([43,9,75,76,25,96,46,85,19,29,88,2,5,24,60,26,76,24,96,82,97,97,72,35,21,77,82,30,94,55,76,94,51]) 22 | ); 23 | -------------------------------------------------------------------------------- /rekursif/combinationSum.js: -------------------------------------------------------------------------------- 1 | const combinationSum = (targetSum, numbers) => { 2 | if (targetSum === 0) return [[]]; 3 | if (targetSum < 0) return null; 4 | 5 | let results = []; 6 | 7 | for (let num of numbers) { 8 | const remainder = targetSum - num; 9 | const combinations = combinationSum(remainder, numbers); 10 | 11 | if (combinations !== null) { 12 | for (let combination of combinations) { 13 | const chance = [num, ...combination]; 14 | results.push(chance); 15 | } 16 | } 17 | } 18 | 19 | return results; 20 | } 21 | 22 | console.log(combinationSum(7, [2, 3, 6, 7])); 23 | -------------------------------------------------------------------------------- /matriks/richestCustomer.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | Input: accounts = [[1,2,3],[3,2,1]] 4 | Output: 6 5 | Explanation: 6 | 1st customer has wealth = 1 + 2 + 3 = 6 7 | 2nd customer has wealth = 3 + 2 + 1 = 6 8 | Both customers are considered the richest with a wealth of 6 each, so return 6. 9 | 10 | */ 11 | 12 | var maximumWealth = function(accounts) { 13 | 14 | let highest = 0; 15 | 16 | accounts.forEach((account) => { 17 | let sum = account.reduce((x,y) => { 18 | return x + y 19 | }, 0); 20 | if ( highest < sum ) highest = sum; 21 | }) 22 | 23 | return highest; 24 | 25 | }; 26 | 27 | console.log(maximumWealth([[5,2,3], [1,2,4], [1,2,5]])) 28 | -------------------------------------------------------------------------------- /array/77.js: -------------------------------------------------------------------------------- 1 | function findSubarrays(arr) { 2 | const subarrays = []; 3 | 4 | for (let i = 0; i < arr.length; i++) { 5 | for (let j = i; j < arr.length; j++) { 6 | const subarray = arr.slice(i, j + 1); 7 | subarrays.push(subarray); 8 | } 9 | } 10 | 11 | return subarrays; 12 | } 13 | 14 | var combine = function (n, k) { 15 | let arr = []; 16 | 17 | for (let i = 0; i < n; i++) { 18 | arr.push(i + 1); 19 | } 20 | 21 | let res = findSubarrays(arr) 22 | 23 | let filter = res.filter((element) => { 24 | return element.length == k 25 | }) 26 | 27 | filter 28 | 29 | return 30 | 31 | }; 32 | 33 | console.log(combine(4, 2)); 34 | -------------------------------------------------------------------------------- /hashmap/2024medium.js: -------------------------------------------------------------------------------- 1 | var maxConsecutiveAnswers = function (answerKey, k) { 2 | let m = new Map(); 3 | let out = 0; 4 | let l = 0; 5 | 6 | for (let r = 0; r < answerKey.length; r++) { 7 | let b = answerKey[r]; 8 | m.set(b, (m.get(b) || 0) + 1); 9 | m 10 | 11 | 12 | while ((m.get("T") || 0) > k && (m.get("F") || 0) > k) { 13 | let temp = answerKey[l] 14 | temp 15 | m 16 | m.set(temp, (m.get(temp) || 0) - 1); 17 | m 18 | l += 1; 19 | } 20 | m 21 | r 22 | l 23 | out = Math.max(out, r - l + 1); 24 | } 25 | 26 | return out; 27 | }; 28 | 29 | console.log(maxConsecutiveAnswers("FFFTTTF", 2)); 30 | -------------------------------------------------------------------------------- /hashmap/2657.js: -------------------------------------------------------------------------------- 1 | var findThePrefixCommonArray = function(A, B) { 2 | let res = [] 3 | 4 | for (let i = 1; i <= A.length; i++) { 5 | let a = A.slice(0, i) 6 | let b = B.slice(0, i) 7 | let arr = a.concat(b) 8 | let map = new Map() 9 | 10 | let temp = 0 11 | arr.forEach((element) => { 12 | map.set(element, (map.get(element) || 0) + 1) 13 | if (map.get(element) > 1) { 14 | temp++ 15 | } 16 | }) 17 | res.push(temp) 18 | } 19 | 20 | return res 21 | }; 22 | 23 | // console.log(findThePrefixCommonArray([1,3,2,4], [3,1,2,4])); 24 | console.log(findThePrefixCommonArray([2,3,1], [3,1,2])); -------------------------------------------------------------------------------- /prefixsum/2574.js: -------------------------------------------------------------------------------- 1 | var leftRightDifference = function(nums) { 2 | 3 | let leftPrefixSum = [] 4 | leftPrefixSum[0] = 0 5 | for (let i = 1; i < nums.length; i++) { 6 | leftPrefixSum[i] = leftPrefixSum[i-1] + nums[i-1] 7 | } 8 | 9 | let rightPrefixSum = [] 10 | rightPrefixSum[nums.length - 1] = 0 11 | for (let i = nums.length - 1; i > 0; i--) { 12 | rightPrefixSum[i-1] = nums[i] + rightPrefixSum[i] 13 | } 14 | 15 | let res = [] 16 | for (let i = 0; i < nums.length; i++) { 17 | res.push(Math.abs(leftPrefixSum[i] - rightPrefixSum[i])) 18 | 19 | } 20 | 21 | return res 22 | }; 23 | 24 | console.log(leftRightDifference([1])); -------------------------------------------------------------------------------- /hashmap/451medium.js: -------------------------------------------------------------------------------- 1 | var frequencySort = function(s) { 2 | let map = new Map() 3 | let res = [] 4 | for (let i = 0; i < s.length; i++) { 5 | const element = s[i]; 6 | map.set(element, (map.get(element) || 0) + 1) 7 | } 8 | 9 | //sorting map berdasarkan value 10 | const result = Array.from(map.entries()).sort((a, b) => b[1] - a[1]); 11 | 12 | for (let i = 0; i < result.length; i++) { 13 | const element = result[i]; 14 | let temp = element[1] 15 | temp 16 | for (let j = 0; j < temp; j++) { 17 | res.push(element[0]) 18 | } 19 | } 20 | 21 | return res.join("") 22 | }; 23 | 24 | console.log(frequencySort("tree")); -------------------------------------------------------------------------------- /array/moveZeroes.js: -------------------------------------------------------------------------------- 1 | var moveZeroes = function (nums) { 2 | let i = 1; 3 | // for (let index = 0; index < nums.length; index++) { 4 | // if(nums[index] !== 0){ 5 | // nums[index] = nums[index] 6 | // } else { 7 | // i++ 8 | // } 9 | // } 10 | 11 | let arr = [] 12 | nums.forEach((element, index) => { 13 | if (nums[index] === 0) { 14 | i++; 15 | } 16 | if(nums[index] !== 0) { 17 | arr[index] = element; 18 | } 19 | }); 20 | 21 | arr 22 | 23 | 24 | 25 | 26 | nums 27 | i 28 | while(i < nums.length){ 29 | nums[i] = 0; 30 | i++; 31 | } 32 | 33 | return nums; 34 | }; 35 | 36 | console.log(moveZeroes([0, 1, 0, 3, 12])); 37 | -------------------------------------------------------------------------------- /hashmap/804.js: -------------------------------------------------------------------------------- 1 | const alphabet = { 2 | a: '.-', b: '-...', c: '-.-.', d: '-..', e: '.', f: '..-.', g: '--.', h: '....', i: '..', j: '.---', k: '-.-', l: '.-..', m: '--', 3 | n: '-.', o: '---', p: '.--.', q: '--.-', r: '.-.', s: '...', t: '-', u: '..-', v: '...-', w: '.--', x: '-..-', y: '-.--', z: '--..' 4 | } 5 | 6 | var uniqueMorseRepresentations = function(words) { 7 | let morses = words.map((word) => { 8 | let chars = [...word]; 9 | let morse = chars.map((char) => alphabet[char]).join(""); 10 | return morse; 11 | }); 12 | 13 | let uniqueSet = new Set(morses); 14 | return uniqueSet.size; 15 | }; 16 | 17 | console.log(uniqueMorseRepresentations(["gin","zen","gig","msg"])); //2 -------------------------------------------------------------------------------- /prefixsum/2270.js: -------------------------------------------------------------------------------- 1 | var waysToSplitArray = function(nums) { 2 | 3 | let prefixSum = [] 4 | prefixSum[0] = nums[0] 5 | for (let i = 1; i < nums.length; i++) { 6 | prefixSum[i] = prefixSum[i-1] + nums[i] 7 | } 8 | 9 | 10 | console.log(prefixSum) // [ 2, 5, 6, 6 ] 11 | 12 | let count = 0 13 | for (let i = 0; i < nums.length - 1; i++) { 14 | const left = prefixSum[i]; 15 | console.log(left) // 2 , 5 , 6 16 | 17 | const right = prefixSum[nums.length - 1] - prefixSum[i+1-1] 18 | console.log(right) // 4 , 1 , 0 19 | 20 | if(left>=right) count++ 21 | } 22 | 23 | return count 24 | 25 | }; 26 | 27 | console.log(waysToSplitArray([2,3,1,0])); // 2 -------------------------------------------------------------------------------- /binarySearch/2300.js: -------------------------------------------------------------------------------- 1 | var successfulPairs = function (spells, potions, success) { 2 | let res = []; 3 | 4 | potions.sort((a, b) => a - b); 5 | 6 | for (let i = 0; i < spells.length; i++) { 7 | let left = 0; 8 | let right = potions.length - 1; 9 | 10 | while (left <= right) { 11 | let mid = Math.floor((left + right) / 2); 12 | 13 | if (spells[i] * potions[mid] >= success) { 14 | right = mid - 1; 15 | } else { 16 | left = mid + 1; 17 | } 18 | } 19 | res.push(potions.length - 1 - right); 20 | } 21 | 22 | return res; 23 | }; 24 | 25 | // console.log(successfulPairs([5,1,3], [1,2,3,4,5], 7)); 26 | console.log(successfulPairs([3, 1, 2], [8, 5, 8], 16)); 27 | -------------------------------------------------------------------------------- /hashmap/2404.js: -------------------------------------------------------------------------------- 1 | var mostFrequentEven = function (nums) { 2 | let map = new Map(); 3 | 4 | //mencari nilai genap, dan sorting hasilnya secara ascending 5 | const even = nums.filter(num => num % 2 === 0).sort((a,b) => a-b); 6 | if(even.length === 0) return -1 7 | 8 | //menghitung / counter untuk mendapatkan jumlah angka genapnya 9 | even.forEach((element) => {map.set(element, (map.get(element) || 0) + 1);}); 10 | //sorting map berdasarkan value dari yang terkecil 11 | const result = Array.from(map.entries()).sort((a, b) => b[1] - a[1]).slice(0, 1).map(([key]) => key); 12 | 13 | return result; 14 | }; 15 | 16 | console.log(mostFrequentEven([8154,9139,8194,3346,5450,9190,133,8239,4606,8671,8412,6290])); 17 | -------------------------------------------------------------------------------- /binarySearch/1351.js: -------------------------------------------------------------------------------- 1 | function binarySearch(arr) { 2 | let left = 0; 3 | let right = arr.length - 1; 4 | 5 | while (left <= right) { 6 | let mid = Math.floor((left + right) / 2); 7 | 8 | if (arr[mid] < 0) { 9 | right = mid - 1; 10 | } else { 11 | left = mid + 1; 12 | } 13 | } 14 | 15 | return left; 16 | } 17 | 18 | var countNegatives = function (grid) { 19 | let res = 0; 20 | for (let i = 0; i < grid.length; i++) { 21 | let index = binarySearch(grid[i]); 22 | index 23 | let total = grid[i].length 24 | total; 25 | res += total - index 26 | } 27 | 28 | return res; 29 | }; 30 | 31 | console.log( 32 | countNegatives([[4,3,2,-1],[3,2,1,-1],[1,1,-1,-2],[-1,-1,-2,-3]]) 33 | ); 34 | -------------------------------------------------------------------------------- /hashmap/happyNumber.js: -------------------------------------------------------------------------------- 1 | /* 2 | Input: n = 19 3 | Output: true 4 | Explanation: 5 | 12 + 92 = 82 6 | 82 + 22 = 68 7 | 62 + 82 = 100 8 | 12 + 02 + 02 = 1 9 | */ 10 | 11 | /* 12 | Input: n = 2 13 | Output: false 14 | */ 15 | 16 | /** 17 | * @param {number} n 18 | * @return {boolean} 19 | */ 20 | function isHappy(n) { 21 | 22 | function getNext(n) { 23 | let totalSum = 0; 24 | while (n > 0) { 25 | let d = n % 10; 26 | n = Math.floor(n / 10); 27 | totalSum += d * d; 28 | } 29 | return totalSum; 30 | } 31 | 32 | let seen = new Set(); 33 | while (n !== 1 && !seen.has(n)) { 34 | seen.add(n); 35 | n = getNext(n); 36 | } 37 | return n === 1; 38 | }; 39 | 40 | console.log(isHappy(2)); //false 41 | -------------------------------------------------------------------------------- /array/summaryRanges.js: -------------------------------------------------------------------------------- 1 | var summaryRanges = function (nums) { 2 | const res = []; 3 | 4 | let i = 0; 5 | while (i < nums.length) { 6 | let start, last; 7 | start = nums[i]; 8 | 9 | //melakukan perulangan dari index awal, jika index selanjutnya lebih dari i+1, maka berhenti 10 | while (i + 1 < nums.length && nums[i + 1] == nums[i] + 1) { 11 | i++; 12 | } 13 | 14 | last = nums[i]; 15 | //jika awal dan akhirnya sama, berarti hanya satu index 16 | if (start == last) { 17 | res.push(start + ""); 18 | } else { 19 | res.push(start + "->" + last); 20 | } 21 | 22 | i++; 23 | } 24 | 25 | return res; 26 | }; 27 | 28 | console.log(summaryRanges([0, 1, 2, 4, 5, 7])); //['0->2', '4->5', '7'] 29 | -------------------------------------------------------------------------------- /design/705.js: -------------------------------------------------------------------------------- 1 | var MyHashSet = function () { 2 | this.set = new Set() 3 | }; 4 | 5 | /** 6 | * @param {number} key 7 | * @return {void} 8 | */ 9 | MyHashSet.prototype.add = function (key) { 10 | this.set.add(key) 11 | }; 12 | 13 | /** 14 | * @param {number} key 15 | * @return {void} 16 | */ 17 | MyHashSet.prototype.remove = function (key) { 18 | this.set.delete(key) 19 | }; 20 | 21 | /** 22 | * @param {number} key 23 | * @return {boolean} 24 | */ 25 | MyHashSet.prototype.contains = function (key) { 26 | return this.set.has(key) 27 | }; 28 | 29 | /** 30 | * Your MyHashSet object will be instantiated and called as such: 31 | * var obj = new MyHashSet() 32 | * obj.add(key) 33 | * obj.remove(key) 34 | * var param_3 = obj.contains(key) 35 | */ 36 | -------------------------------------------------------------------------------- /string/2243.js: -------------------------------------------------------------------------------- 1 | var digitSum = function(s, k) { 2 | while (s.length > k) { 3 | let current = ''; 4 | for (let i = 0; i < s.length; i += k) { 5 | let chunk = s.slice(i, i + k); 6 | let sum = chunk.split('').reduce((a, b) => parseInt(a) + parseInt(b)); 7 | current += sum; 8 | } 9 | s = current; 10 | } 11 | return s; 12 | }; 13 | 14 | 15 | // var digitSum = function(s, k) { 16 | // while (s.length > k) { 17 | // let current = ''; 18 | // for (let i = 0; i < s.length; i += k) { 19 | // current += s.slice(i, i + k).split('').reduce((a, b) => +a + +b); 20 | // } 21 | 22 | // s = current; 23 | // } 24 | // return s; 25 | // }; 26 | 27 | console.log(digitSum("11111222223", 3)); 28 | -------------------------------------------------------------------------------- /test/5medium.js: -------------------------------------------------------------------------------- 1 | const longestPalindrome = function (s) { 2 | let maxLength = 0; 3 | let start = 0; 4 | 5 | const expandAroundCenter = (left, right) => { 6 | while (left >= 0 && right < s.length && s[left] === s[right]) { 7 | const currentLength = right - left + 1; 8 | if (currentLength > maxLength) { 9 | maxLength = currentLength; 10 | start = left; 11 | } 12 | left--; 13 | right++; 14 | } 15 | }; 16 | 17 | for (let i = 0; i < s.length; i++) { 18 | expandAroundCenter(i, i); // Untuk panjang palindrome ganjil 19 | expandAroundCenter(i, i + 1); // Untuk panjang palindrome genap 20 | } 21 | 22 | return s.slice(start, start + maxLength); 23 | }; 24 | 25 | console.log(longestPalindrome("adada")); 26 | -------------------------------------------------------------------------------- /design/1357.py: -------------------------------------------------------------------------------- 1 | class Cashier: 2 | def __init__(self, n, discount, products, prices): 3 | self.mapping = {} 4 | for i in range(len(products)): 5 | self.mapping[products[i]] = prices[i] 6 | 7 | self.n = n 8 | self.discount = discount 9 | self.count = 0 10 | 11 | def get_bill(self, product, amount): 12 | total = 0 13 | barang = 0 14 | for i in range(len(product)): 15 | jumlah_barang = amount[i] 16 | barang += 1 17 | total += self.mapping[product[i]] * jumlah_barang 18 | 19 | self.count += 1 20 | if self.count == self.n: 21 | self.count = 0 22 | return total * (100 - self.discount) / 100 23 | 24 | return total 25 | -------------------------------------------------------------------------------- /hashmap/692medium.js: -------------------------------------------------------------------------------- 1 | var topKFrequent = function (words, k) { 2 | let map = new Map(); 3 | words.forEach((element) => map.set(element, (map.get(element) || 0) + 1)); 4 | 5 | return Array.from(map.entries()).sort((a, b) => { 6 | let countCompare = b[1] - a[1]; 7 | //bandingkan sesuai leksikografis jika value nya sama 8 | if (countCompare === 0) { 9 | return a[0].localeCompare(b[0]); 10 | } else { 11 | return countCompare; 12 | } 13 | }).slice(0, k).map((entry) => entry[0]) 14 | }; 15 | 16 | // console.log(topKFrequent(["i","love","leetcode","i","love","coding"], 2)); 17 | // console.log(topKFrequent(["the","day","is","sunny","the","the","the","sunny","is","is"], 4)); 18 | console.log(topKFrequent(["i", "love", "leetcode", "i", "love", "coding"], 3)); 19 | -------------------------------------------------------------------------------- /rekursif/sumDigits.js: -------------------------------------------------------------------------------- 1 | // const sumDigits = (numbers) => { 2 | // const splitNum = numbers.toString().split(""); 3 | // splitNum 4 | 5 | // let results = 0; 6 | // for ( num of splitNum){ 7 | // results = results + parseInt(num); 8 | // } 9 | 10 | // return results 11 | // } 12 | 13 | const sumDigits = (number) => { 14 | if (number === 0) { 15 | return 0; // Basis: Jika angka sudah 0, kembalikan 0 16 | } 17 | 18 | const lastDigit = number % 10; // Dapatkan digit terakhir 19 | lastDigit 20 | const remainingDigits = Math.floor(number / 10); // Dapatkan sisa digit 21 | remainingDigits 22 | 23 | return lastDigit + sumDigits(remainingDigits); // Rekursi: Jumlahkan digit terakhir dengan jumlah digit pada sisa angka 24 | } 25 | 26 | console.log(sumDigits(12345)); // Output: 15 -------------------------------------------------------------------------------- /rekursif/subsetSum.js: -------------------------------------------------------------------------------- 1 | const bestSum = (targetSum, numbers) => { 2 | 3 | if (targetSum === 0) return []; 4 | if (targetSum < 0) return null; 5 | 6 | let shortestCombination = null; 7 | 8 | for ( let num of numbers){ 9 | targetSum 10 | num 11 | const remainder = targetSum - num; 12 | remainder 13 | const remainderCombination = bestSum(remainder, numbers); 14 | remainderCombination 15 | if ( remainderCombination !== null){ 16 | const combination = [...remainderCombination, num]; 17 | combination 18 | if (shortestCombination === null || combination.length < shortestCombination.length){ 19 | shortestCombination = combination; 20 | } 21 | } 22 | } 23 | 24 | return shortestCombination; 25 | } 26 | 27 | console.log(bestSum(3, [1,2])) 28 | -------------------------------------------------------------------------------- /string/917.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def reverseOnlyLetters(self, s: str) -> str: 3 | 4 | #ubah string menjadi list 5 | s = list(s) 6 | 7 | # "abc" 8 | # ["a", "b", "c"] 9 | 10 | #pointer kiri dan kanan 11 | left, right = 0, len(s) - 1 12 | 13 | #perulangan tp 14 | while left < right: 15 | #jika ptr kiri bukan huruf 16 | if not s[left].isalpha(): 17 | left += 1 18 | #jika ptr kanan bukan huruf 19 | elif not s[right].isalpha(): 20 | right -= 1 21 | #jika keduanya adalah huruf 22 | else: 23 | s[left], s[right] = s[right], s[left] 24 | left += 1 25 | right -= 1 26 | 27 | #gabungkan kembali agar menjadi string 28 | return "".join(s) -------------------------------------------------------------------------------- /matematika/258.js: -------------------------------------------------------------------------------- 1 | const addDigits = (num) => { 2 | let result = Infinity; 3 | 4 | if (num === 0) return 0; 5 | 6 | while (true) { 7 | if (result < 10) return result; 8 | digVal = (num % 10) + Math.floor(num / 10); 9 | result = digVal; 10 | result 11 | num = digVal; 12 | } 13 | }; 14 | 15 | // const addDigits = (num) => { 16 | // if (num === 0) { 17 | // return 0; 18 | // } 19 | 20 | // while (num >= 10) { 21 | // let digitSum = 0; 22 | 23 | // while (num > 0) { 24 | // let temp = num % 10 25 | // temp 26 | // digitSum += temp; 27 | // digitSum 28 | // num = Math.floor(num / 10); 29 | // } 30 | 31 | // num = digitSum; 32 | // } 33 | 34 | // return num; 35 | // }; 36 | 37 | 38 | console.log(addDigits(3823)); -------------------------------------------------------------------------------- /design/1656.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | */ 4 | var OrderedStream = function(n) { 5 | pointer = 0; 6 | stream = new Array(n); 7 | }; 8 | 9 | /** 10 | * @param {number} idKey 11 | * @param {string} value 12 | * @return {string[]} 13 | */ 14 | OrderedStream.prototype.insert = function(idKey, value) { 15 | stream[idKey - 1] = value; 16 | const result = []; 17 | if(!stream[pointer]) { 18 | return []; 19 | } else { 20 | while(stream[pointer]){ 21 | result.push(stream[pointer]); 22 | pointer ++;} 23 | } 24 | return result; 25 | }; 26 | 27 | var obj = new OrderedStream(5); 28 | var param_1 = obj.insert(3, "ccccc"); 29 | var param_2 = obj.insert(1, "aaaaa"); 30 | var param_3 = obj.insert(2, "bbbbb"); 31 | var param_4 = obj.insert(5, "eeeee"); 32 | var param_5 = obj.insert(4, "ddddd"); 33 | -------------------------------------------------------------------------------- /prefixsum/2485.js: -------------------------------------------------------------------------------- 1 | var pivotInteger = function(n) { 2 | if(n == 1) return 1 3 | let arr = [] 4 | 5 | //melalukan rumus prefix sum 6 | let prefixSum = [] 7 | let temp = 0 8 | for (let i = 0; i < n; i++) { 9 | prefixSum[i] = temp + i+1 10 | temp = prefixSum[i] 11 | arr[i] = i+1 12 | } 13 | 14 | console.log(arr) // [ 1, 2, 3, 4, 5, 6, 7, 8 ] 15 | console.log(prefixSum) // [ 1, 3, 6, 10, 15, 21, 28, 36 ] 16 | 17 | //melakukan perulangan sampai mendapatkan value yang sama 18 | for (let i = 0; i < n; i++) { 19 | const a = prefixSum[i]; 20 | let b = prefixSum[n-1] - prefixSum[i-1] 21 | if(a==b) return i+1 22 | } 23 | 24 | //kembalikan -1 jika tidak ada yang sama di perulangan sblmnya 25 | return -1 26 | }; 27 | 28 | console.log(pivotInteger(8)); // 6 29 | 30 | -------------------------------------------------------------------------------- /prefixsum/724.js: -------------------------------------------------------------------------------- 1 | var pivotIndex = function (nums) { 2 | 3 | //melalukan rumus prefix sum 4 | let prefixSum = []; 5 | prefixSum[0] = nums[0] 6 | for (let i = 1; i < nums.length; i++) { 7 | prefixSum[i] = prefixSum[i-1] + nums[i] 8 | } 9 | 10 | console.log(nums) // [ 1, 7, 3, 6, 5, 6 ] 11 | console.log(prefixSum) // [ 1, 8, 11, 17, 22, 28 ] 12 | 13 | //melakukan perulangan sampai mendapatkan value yang sama 14 | for (let i = 0; i < nums.length; i++) { 15 | let a = prefixSum[i-1]; 16 | if(!a) a=0 17 | let b = prefixSum[nums.length - 1] - prefixSum[i] 18 | 19 | //jika a dan b sama, maka return index nya 20 | if(a==b) return i 21 | } 22 | 23 | //kembalikan -1 jika tidak ada yang sama di perulangan sblmnya 24 | return -1; 25 | }; 26 | 27 | console.log(pivotIndex([1,7,3,6,5,6])); // 3 28 | -------------------------------------------------------------------------------- /hashmap/01.js: -------------------------------------------------------------------------------- 1 | // var twoSum = function(nums, target) { 2 | // let map = new Map() 3 | 4 | // for (let i = 0; i < nums.length; i++) { 5 | // let cur = target-nums[i] 6 | // if(map.has(cur)){ 7 | // return [map.get(cur), i] 8 | // } 9 | 10 | // map.set(nums[i], i) 11 | // } 12 | 13 | // }; 14 | 15 | var twoSum = function(nums, target) { 16 | let map = new Map() 17 | 18 | for (let i = 0; i < nums.length; i++) { 19 | let cur = target-nums[i] 20 | if(map.has(cur)){ 21 | return [map.get(cur), i] 22 | } 23 | 24 | map.set(nums[i], i) 25 | 26 | } 27 | }; 28 | 29 | var kondisi1 = function(pilihan){ 30 | if(pilihan === "a") return "A" 31 | 32 | return "Lainnya" 33 | } 34 | 35 | console.log(kondisi1("a")) // A 36 | 37 | 38 | 39 | -------------------------------------------------------------------------------- /hashmap/1817medium.js: -------------------------------------------------------------------------------- 1 | var findingUsersActiveMinutes = function (logs, k) { 2 | let map = new Map(); 3 | 4 | for (const [user, time] of logs) { 5 | //jika tidak ada user maka buat key baru dan value berupa set 6 | if (map.has(user) === false) { 7 | map.set(user, new Set()); 8 | } 9 | //tambahkan value berupa set yang berisi time 10 | let set = map.get(user) 11 | set.add(time); 12 | } 13 | 14 | 15 | //tambah 0 ke array sesuai k 16 | let arr = new Array(k).fill(0); 17 | 18 | map.forEach((elemen) => { 19 | arr[elemen.size - 1] = arr[elemen.size - 1]+1; 20 | }) 21 | 22 | return arr; 23 | }; 24 | 25 | console.log( 26 | findingUsersActiveMinutes( 27 | [ 28 | [1, 5], 29 | [1, 2], 30 | [0, 2], 31 | [1, 5], 32 | [1, 3], 33 | ], 34 | 5 35 | ) 36 | ); 37 | -------------------------------------------------------------------------------- /matriks/2319.js: -------------------------------------------------------------------------------- 1 | var largestLocal = function(grid) { 2 | 3 | let lokal = [] 4 | for (let row = 0; row < grid.length - 2; row++) { 5 | let temp = [] 6 | for (let col = 0; col < grid.length - 2; col++) { 7 | temp.push(0) 8 | } 9 | lokal.push([...temp]) 10 | } 11 | 12 | for (let row = 0; row < grid.length - 2; row++) { 13 | for (let col = 0; col < grid.length - 2; col++) { 14 | lokal[row][col] = Math.max( 15 | grid[row][col], grid[row][col+1], grid[row][col+2], 16 | grid[row+1][col], grid[row+1][col+1], grid[row+1][col+2], 17 | grid[row+2][col], grid[row+2][col+1], grid[row+2][col+2] 18 | ) 19 | } 20 | } 21 | 22 | return lokal 23 | 24 | }; 25 | console.log(largestLocal([[1,1,1,1,1],[1,1,1,1,1],[1,1,2,1,1],[1,1,1,1,1],[1,1,1,1,1]])); -------------------------------------------------------------------------------- /design/303.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | */ 4 | var NumArray = function(nums) { 5 | this.prefixSum = nums.slice(); 6 | //rumus prefixSum 7 | for (let i = 1; i < this.prefixSum.length; i++) { 8 | this.prefixSum[i] = this.prefixSum[i - 1] + nums[i]; 9 | } 10 | }; 11 | 12 | /** 13 | * @param {number} left 14 | * @param {number} right 15 | * @return {number} 16 | */ 17 | NumArray.prototype.sumRange = function(left, right) { 18 | if (left === 0) { 19 | return this.prefixSum[right]; 20 | } 21 | return this.prefixSum[right] - this.prefixSum[left - 1]; 22 | }; 23 | 24 | var numArray = new NumArray([-2, 0, 3, -5, 2, -1]); 25 | numArray.sumRange(0, 2); // return (-2) + 0 + 3 = 1 26 | numArray.sumRange(2, 5); // return 3 + (-5) + 2 + (-1) = -1 27 | numArray.sumRange(0, 5); // return (-2) + 0 + 3 + (-5) + 2 + (-1) = -3 28 | -------------------------------------------------------------------------------- /hashmap/1122.js: -------------------------------------------------------------------------------- 1 | var relativeSortArray = function (arr1, arr2) { 2 | let res = []; 3 | let sisa = []; 4 | 5 | let map = new Map(); 6 | arr2.forEach((element) => { 7 | if (!map.has(element)) { 8 | map.set(element, 0); 9 | } 10 | }); 11 | 12 | arr1.forEach((element) => { 13 | if (!map.has(element)) { 14 | sisa.push(element); 15 | } else { 16 | map.set(element, map.get(element) + 1); 17 | } 18 | }); 19 | 20 | map.forEach((element, index) => { 21 | for (let i = 0; i < element; i++) { 22 | res.push(index); 23 | } 24 | }); 25 | 26 | return res.concat(sisa.sort((a, b) => a - b)); 27 | }; 28 | 29 | // console.log( 30 | // relativeSortArray([2, 3, 1, 3, 2, 4, 6, 7, 9, 2, 19], [2, 1, 4, 3, 9, 6]) 31 | // ); 32 | console.log(relativeSortArray([28, 6, 22, 8, 44, 17], [22, 28, 8, 6])); 33 | -------------------------------------------------------------------------------- /binarySearch/1870.js: -------------------------------------------------------------------------------- 1 | var minSpeedOnTime = function(dist, hour) { 2 | let left=1,right=10000000,speed,sum,ans=-1; 3 | 4 | while(left<=right){ 5 | speed = left + Math.floor((right-left)/2); 6 | 7 | sum=0; 8 | for(let i=0;i= 0; i--){ 22 | if(num[i] % 2 == 0){ 23 | num.pop(); 24 | } else { 25 | break; 26 | } 27 | } 28 | return num.join(""); 29 | }; 30 | 31 | console.log(largestOddNumber("52")) // 5 32 | console.log(largestOddNumber("4206")) // '' 33 | console.log(largestOddNumber("35427")) // 35427 34 | console.log(largestOddNumber("10133890")) //1013389 -------------------------------------------------------------------------------- /array/2640medium.js: -------------------------------------------------------------------------------- 1 | var findPrefixScore = function (nums) { 2 | // let temp = []; 3 | // for (let i = 0; i < nums.length; i++) { 4 | // let max = nums[i]; 5 | // for (let j = 0; j < i; j++) { 6 | // if (nums[j] > max) { 7 | // max = nums[j]; 8 | // } 9 | // } 10 | // temp.push(nums[i] + max); 11 | // } 12 | // let res = []; 13 | 14 | // for (let i = 1; i <= temp.length; i++) { 15 | // const element = temp.slice(0, i) 16 | // res.push(element.reduce((a,b) => a + b)) 17 | // } 18 | 19 | // return res; 20 | let res = []; 21 | let max = Number.NEGATIVE_INFINITY; 22 | let sum = 0; 23 | 24 | for (let i = 0; i < nums.length; i++) { 25 | max = Math.max(nums[i], max); 26 | sum += nums[i] + max; 27 | res.push(sum); 28 | } 29 | 30 | return res; 31 | 32 | }; 33 | 34 | console.log(findPrefixScore([2,3,7,5,10])); 35 | -------------------------------------------------------------------------------- /array/2079.js: -------------------------------------------------------------------------------- 1 | var wateringPlants = function(plants, capacity) { 2 | 3 | let steps = 0 4 | let water = capacity 5 | for (let index = 0; index < plants.length; index++) { 6 | let plant = plants[index]; 7 | 8 | if (plant <= water) { 9 | //tambahkan steps 10 | steps++; 11 | //kurangi water sesuai kebutuhan tanaman 12 | water = water - plant; 13 | } else { 14 | //reset water menjadi full lagi 15 | water = capacity; 16 | 17 | //rumus jika kembali dan datang lagi 18 | let additionalSteps = index * 2 + 1; 19 | 20 | //tambahkan ke steps 21 | steps += additionalSteps; 22 | 23 | //kurangi water sesuai kebutuhan tanaman 24 | water = water - plant; 25 | } 26 | } 27 | 28 | return steps 29 | 30 | }; 31 | 32 | console.log(wateringPlants([7,7,7,7,7,7,7], 8)); -------------------------------------------------------------------------------- /array/buildArrayPermutation.js: -------------------------------------------------------------------------------- 1 | /* 2 | Input: nums = [0,2,1,5,3,4] 3 | Output: [0,1,2,4,5,3] 4 | Explanation: The array ans is built as follows: 5 | ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]] 6 | = [nums[0], nums[2], nums[1], nums[5], nums[3], nums[4]] 7 | = [0,1,2,4,5,3] 8 | */ 9 | 10 | /* 11 | Input: nums = [5,0,1,2,3,4] 12 | Output: [4,5,0,1,2,3] 13 | Explanation: The array ans is built as follows: 14 | ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]] 15 | = [nums[5], nums[0], nums[1], nums[2], nums[3], nums[4]] 16 | = [4,5,0,1,2,3] 17 | */ 18 | 19 | const buildArray = (number) => { 20 | let array = []; 21 | number.forEach(element => { 22 | array.push(number[element]) 23 | }); 24 | 25 | return array; 26 | } 27 | 28 | console.log(buildArray([0,2,1,5,3,4])); 29 | -------------------------------------------------------------------------------- /string/reverseWords.js: -------------------------------------------------------------------------------- 1 | /* 2 | Given a string s, reverse the order of characters in each word within a sentence while still preserving whitespace and initial word order. 3 | */ 4 | 5 | /* 6 | Input: s = "Let's take LeetCode contest" 7 | Output: "s'teL ekat edoCteeL tsetnoc" 8 | */ 9 | 10 | /* 11 | Input: s = "God Ding" 12 | Output: "doG gniD" 13 | */ 14 | 15 | var reverseWords = function(s) { 16 | let split = s.split(' ') 17 | let res = [] 18 | 19 | split.forEach((element, index) => { 20 | let reverseKata = element.split('') 21 | for (let i = reverseKata.length-1; i >= 0; i--) { 22 | res.push(reverseKata[i]); 23 | } 24 | index === split.length - 1 ? res.push() : res.push(' '); 25 | }) 26 | return res.join('') 27 | }; 28 | 29 | console.log(reverseWords("God Ding")); //doG gniD 30 | console.log(reverseWords("Let's take LeetCode contest")); //s'teL ekat edoCteeL tsetnoc -------------------------------------------------------------------------------- /hashmap/1282.js: -------------------------------------------------------------------------------- 1 | var groupThePeople = function(groupSizes) { 2 | const result = []; 3 | const map = new Map(); 4 | 5 | for (let index = 0; index < groupSizes.length; index++) { 6 | const value = groupSizes[index]; 7 | //periksa apakah sudah ada key nya atau belum, 8 | //jika tidak buat key dengan value array value 9 | if (map.has(value) === false) { 10 | map.set(value, []); 11 | } 12 | 13 | //masukan index(index) ke array value tadi 14 | map.get(value).push(index); 15 | 16 | //cek terlebih dahulu jika size array sama dengan value value 17 | if (map.get(value).length === value) { 18 | //masukan value array tadi ke result 19 | let arr = map.get(value) 20 | result.push(arr); 21 | //hapus key sebelumnya 22 | map.delete(value); 23 | } 24 | } 25 | 26 | return result; 27 | }; 28 | 29 | console.log(groupThePeople([1,2,1,3,3,3,2,1,1])); 30 | -------------------------------------------------------------------------------- /hashmap/1365.js: -------------------------------------------------------------------------------- 1 | // var smallerNumbersThanCurrent = function(nums) { 2 | // let res = [] 3 | 4 | // for (let i = 0; i < nums.length; i++) { 5 | // let count = 0 6 | // for (let j = 0; j < nums.length; j++) { 7 | // if(nums[j] < nums[i]) count++ 8 | // } 9 | // res.push(count) 10 | 11 | // } 12 | 13 | // return res 14 | // }; 15 | 16 | var smallerNumbersThanCurrent = function(nums) { 17 | const sortedNums = [...nums].sort((a, b) => a - b); 18 | const countMap = new Map(); 19 | const result = []; 20 | 21 | for (let i = 0; i < sortedNums.length; i++) { 22 | if (!countMap.has(sortedNums[i])) { 23 | countMap.set(sortedNums[i], i); 24 | } 25 | } 26 | 27 | for (let num of nums) { 28 | result.push(countMap.get(num)); 29 | } 30 | 31 | return result; 32 | }; 33 | 34 | 35 | console.log(smallerNumbersThanCurrent([6,5,4,8])); -------------------------------------------------------------------------------- /design/functionComposition.js: -------------------------------------------------------------------------------- 1 | /* 2 | Input: functions = [x => x + 1, x => x * x, x => 2 * x], x = 4 3 | Output: 65 4 | Explanation: 5 | Evaluating from right to left ... 6 | Starting with x = 4. 7 | 2 * (4) = 8 8 | (8) * (8) = 64 9 | (64) + 1 = 65 10 | */ 11 | 12 | /* 13 | Input: functions = [x => 10 * x, x => 10 * x, x => 10 * x], x = 1 14 | Output: 1000 15 | Explanation: 16 | Evaluating from right to left ... 17 | 10 * (1) = 10 18 | 10 * (10) = 100 19 | 10 * (100) = 1000 20 | */ 21 | 22 | /* 23 | Input: functions = [], x = 42 24 | Output: 42 25 | Explanation: 26 | The composition of zero functions is the identity function 27 | */ 28 | 29 | const compose = (functions) => { 30 | return (value) => { 31 | return functions.reduceRight((result, fn) => { 32 | return fn(result); 33 | }, value); 34 | }; 35 | }; 36 | 37 | const fn = compose([(x)=>10*x, (x)=>10*x, (x)=>10*x]); 38 | console.log(fn(1)); // Output: 9 39 | -------------------------------------------------------------------------------- /string/shuffleString.js: -------------------------------------------------------------------------------- 1 | /* 2 | You are given a string s and an integer array indices of the same length. The string s will be shuffled such that the character at the ith position moves to indices[i] in the shuffled string. 3 | 4 | Return the shuffled string. 5 | */ 6 | 7 | /* 8 | Input: s = "codeleet", indices = [4,5,6,7,0,2,1,3] 9 | Output: "leetcode" 10 | Explanation: As shown, "codeleet" becomes "leetcode" after shuffling. 11 | */ 12 | 13 | /* 14 | Input: s = "abc", indices = [0,1,2] 15 | Output: "abc" 16 | Explanation: After shuffling, each character remains in its position. 17 | */ 18 | 19 | var restoreString = function (s, indices) { 20 | var str = new Array(indices.length); 21 | 22 | for (let index = 0; index < indices.length; index++) { 23 | str[indices[index]] = s[index]; 24 | } 25 | 26 | return str.join('') 27 | }; 28 | 29 | console.log(restoreString("codeleet", [4, 5, 6, 7, 0, 2, 1, 3])); //leetcode 30 | 31 | -------------------------------------------------------------------------------- /stack/739.js: -------------------------------------------------------------------------------- 1 | class Stack { 2 | constructor() { 3 | this.stack = []; 4 | } 5 | 6 | push(element) { 7 | this.stack.push(element); 8 | } 9 | 10 | pop() { 11 | if (this.isEmpty()) return "stack kosong"; 12 | return this.stack.pop(); 13 | } 14 | 15 | isEmpty() { 16 | return this.stack.length === 0; 17 | } 18 | 19 | peek() { 20 | return this.stack[this.stack.length - 1]; 21 | } 22 | } 23 | 24 | var dailyTemperatures = function (temperatures) { 25 | let res = new Array(temperatures.length).fill(0); 26 | 27 | let stack = new Stack(); 28 | for (let i = 0; i < temperatures.length; i++) { 29 | while (!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]) { 30 | let idx = stack.pop(); 31 | idx 32 | res[idx] = i - idx; 33 | } 34 | stack.push(i); 35 | } 36 | 37 | return res; 38 | }; 39 | 40 | console.log(dailyTemperatures([30,60,90,30,60,90,30,60,90,100])); 41 | -------------------------------------------------------------------------------- /stack/2390.js: -------------------------------------------------------------------------------- 1 | class Stack{ 2 | constructor(){ 3 | this.stack = [] 4 | } 5 | 6 | push(element){ 7 | this.stack.push(element) 8 | } 9 | 10 | pop(){ 11 | if(this.isEmpty()) return "Stack Kosong" 12 | return this.stack.pop() 13 | } 14 | 15 | isEmpty(){ 16 | return this.stack.length === 0 17 | } 18 | 19 | peek(){ 20 | return this.stack[this.stack.length - 1] 21 | } 22 | 23 | print(){ 24 | let string = "" 25 | for(let i = 0; i= 0; 20 | case 2: 21 | return --this.medium >= 0; 22 | case 3: 23 | return --this.small >= 0; 24 | default: 25 | break; 26 | } 27 | }; 28 | 29 | /** 30 | * Your ParkingSystem object will be instantiated and called as such: 31 | * var obj = new ParkingSystem(big, medium, small) 32 | * var param_1 = obj.addCar(carType) 33 | */ 34 | 35 | var obj = new ParkingSystem(1,1,0) 36 | var car1 = obj.addCar(1) 37 | var car2 = obj.addCar(2) 38 | var car3 = obj.addCar(3) 39 | var car4 = obj.addCar(1) -------------------------------------------------------------------------------- /hashmap/wordPattern.js: -------------------------------------------------------------------------------- 1 | var wordPattern = function(pattern, s) { 2 | let map1 = new Map(); 3 | let map2 = new Map(); 4 | 5 | let split_pattern = pattern.split(""); 6 | let split_s = s.split(" "); 7 | 8 | if (split_pattern.length !== split_s.length) { 9 | return false; 10 | } 11 | 12 | 13 | for (let i = 0; i < split_pattern.length; i++) { 14 | const char = split_pattern[i]; 15 | const word = split_s[i]; 16 | 17 | if (map1.has(char)) { 18 | if (map1.get(char) !== word) { 19 | return false; 20 | } 21 | } else { 22 | map1.set(char, word); 23 | } 24 | 25 | if (map2.has(word)) { 26 | if (map2.get(word) !== char) { 27 | return false; 28 | } 29 | } else { 30 | map2.set(word, char); 31 | } 32 | } 33 | 34 | map1 35 | map2 36 | 37 | return true; 38 | }; 39 | 40 | console.log(wordPattern("abbba", "dog cat cat dog cat")); // Output: false 41 | -------------------------------------------------------------------------------- /stack/1598.js: -------------------------------------------------------------------------------- 1 | class Stack { 2 | constructor() { 3 | this.stack = []; 4 | } 5 | 6 | push(item) { 7 | this.stack.push(item); 8 | } 9 | 10 | pop() { 11 | if (this.isEmpty()) return "Stack Kosong"; 12 | return this.stack.pop(); 13 | } 14 | 15 | isEmpty() { 16 | return this.stack.length === 0; 17 | } 18 | 19 | peek() { 20 | return this.stack[this.stack.length - 1]; 21 | } 22 | 23 | size(){ 24 | return this.stack.length 25 | } 26 | } 27 | 28 | var minOperations = function (logs) { 29 | let stack = new Stack(); 30 | 31 | const operations = { 32 | "../": () => { 33 | stack.pop(); 34 | }, 35 | "./": () => { 36 | stack.peek(); 37 | }, 38 | default: (element) => stack.push(element), 39 | }; 40 | 41 | logs.forEach((element) => { 42 | const action = operations[element] || operations.default; 43 | action(element); 44 | }); 45 | 46 | return stack.size() 47 | }; 48 | 49 | 50 | console.log(minOperations(["d1/","d2/","../","d21/","./"])) // 2 -------------------------------------------------------------------------------- /hashmap/singleNumber.js: -------------------------------------------------------------------------------- 1 | /* 2 | Given a non-empty array of integers nums, every element appears twice except for one. Find that single one. 3 | 4 | You must implement a solution with a linear runtime complexity and use only constant extra space. 5 | */ 6 | 7 | /* 8 | Input: nums = [2,2,1] 9 | Output: 1 10 | */ 11 | 12 | /* 13 | Input: nums = [4,1,2,1,2] 14 | Output: 4 15 | */ 16 | 17 | /* 18 | Input: nums = [1] 19 | Output: 1 20 | */ 21 | 22 | var singleNumber = function (nums) { 23 | let map = new Map(); 24 | 25 | nums.forEach((element, index) => { 26 | if (map.has(element) === false) { 27 | let temp = 0; 28 | map.set(element, temp + 1); 29 | } else { 30 | let temp = map.get(element); 31 | map.set(element, temp + 1); 32 | } 33 | }); 34 | 35 | map // { 4 => 1, 1 => 2, 2 => 2} 36 | let res = 0; 37 | map.forEach((kunci, nilai) => { 38 | if (kunci === 1) { 39 | res = nilai; 40 | } 41 | }); 42 | 43 | return res; 44 | }; 45 | 46 | console.log(singleNumber([4, 1, 2, 1, 2])); 47 | -------------------------------------------------------------------------------- /array/twoSum.js: -------------------------------------------------------------------------------- 1 | /* 2 | Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target. 3 | 4 | You may assume that each input would have exactly one solution, and you may not use the same element twice. 5 | 6 | You can return the answer in any order. 7 | */ 8 | 9 | /* 10 | Input: nums = [2,7,11,15], target = 9 11 | Output: [0,1] 12 | Explanation: Because nums[0] + nums[1] == 9, we return [0, 1]. 13 | */ 14 | 15 | /* 16 | Input: nums = [3,2,4], target = 6 17 | Output: [1,2] 18 | */ 19 | 20 | /* 21 | Input: nums = [3,3], target = 6 22 | Output: [0,1] 23 | */ 24 | 25 | var twoSum = function(nums, target) { 26 | let res = [] 27 | for (let i = 0; i < nums.length; i++) { 28 | for (let j = i+1; j < nums.length; j++) { 29 | let sum = nums[i] + nums[j] 30 | if(sum === target){ 31 | res.push(i, j) 32 | } 33 | } 34 | 35 | } 36 | 37 | return res 38 | }; 39 | 40 | console.log(twoSum([2,7,11,15], 9)) // [0, 1] 41 | console.log(twoSum([3,2,4], 6)) // [1, 2] -------------------------------------------------------------------------------- /matriks/2482.js: -------------------------------------------------------------------------------- 1 | var diff = (row, col, grid) => { 2 | let zeroRow = 0; 3 | let onesRow = 0; 4 | for (let i = 0; i < grid[row].length; i++) { 5 | const element = grid[row][i]; 6 | if (element === 0) { 7 | zeroRow++; 8 | } else { 9 | onesRow++; 10 | } 11 | } 12 | 13 | let zeroCol = 0; 14 | let onesCol = 0; 15 | for (let i = 0; i < grid.length; i++) { 16 | const element = grid[i][col]; 17 | if (element === 0) { 18 | zeroCol++; 19 | } else { 20 | onesCol++; 21 | } 22 | } 23 | 24 | return onesRow + onesCol - zeroRow - zeroCol; 25 | }; 26 | 27 | var onesMinusZeros = function (grid) { 28 | let result = []; 29 | 30 | for (let row = 0; row < grid.length; row++) { 31 | let temp = []; 32 | for (let col = 0; col < grid[row].length; col++) { 33 | temp.push(diff(row, col, grid)); 34 | } 35 | result.push([...temp]); 36 | } 37 | 38 | return result; 39 | }; 40 | 41 | console.log( 42 | onesMinusZeros([ 43 | [1, 1, 1], 44 | [1, 1, 1], 45 | ]) 46 | ); 47 | -------------------------------------------------------------------------------- /matriks/2373.js: -------------------------------------------------------------------------------- 1 | var largestLocal = function(grid) { 2 | 3 | //buat array lokal untuk menampung jawaban 4 | let lokal = [] 5 | for (let row = 0; row < grid.length - 2; row++) { 6 | let temp = [] 7 | for (let col = 0; col < grid.length - 2; col++) { 8 | temp.push(0) 9 | } 10 | lokal.push([...temp]) 11 | } 12 | 13 | console.log(lokal) // [[0,0],[0,0]] 14 | 15 | //mencari nilai maksimal dari array 3x3 nya 16 | for (let row = 0; row < grid.length - 2; row++) { 17 | for (let col = 0; col < grid.length - 2; col++) { 18 | //lalu timpa pada array lokal tadi 19 | lokal[row][col] = Math.max( 20 | grid[row][col], grid[row][col+1], grid[row][col+2], 21 | grid[row+1][col], grid[row+1][col+1], grid[row+1][col+2], 22 | grid[row+2][col], grid[row+2][col+1], grid[row+2][col+2] 23 | ) // 9, 9, 8, 6 24 | } 25 | } 26 | 27 | return lokal // [ [ 9, 9 ], [ 8, 6 ] ] 28 | 29 | }; 30 | 31 | console.log(largestLocal([[9,9,8,1],[5,6,2,6],[8,2,6,4],[6,2,2,2]])) -------------------------------------------------------------------------------- /array/chunkArray.js: -------------------------------------------------------------------------------- 1 | /* 2 | Input: arr = [1,2,3,4,5], size = 1 3 | Output: [[1],[2],[3],[4],[5]] 4 | Explanation: The arr has been split into subarrays each with 1 element. 5 | */ 6 | 7 | /* 8 | Input: arr = [1,9,6,3,2], size = 3 9 | Output: [[1,9,6],[3,2]] 10 | Explanation: The arr has been split into subarrays with 3 elements. However, only two elements are left for the 2nd subarray. 11 | */ 12 | 13 | /* 14 | Input: arr = [8,5,3,2,6], size = 6 15 | Output: [[8,5,3,2,6]] 16 | Explanation: Size is greater than arr.length thus all elements are in the first subarray. 17 | */ 18 | 19 | /* 20 | Input: arr = [], size = 1 21 | Output: [] 22 | Explanation: There are no elements to be chunked so an empty array is returned. 23 | */ 24 | 25 | const chunk = (arr, size) => { 26 | 27 | var chunkedArray = []; 28 | var index = 0; 29 | 30 | while (index < arr.length) { 31 | const chunk = arr.slice(index, index + size) 32 | chunkedArray.push(chunk); 33 | index += size; 34 | } 35 | 36 | return chunkedArray; 37 | }; 38 | 39 | console.log(chunk([1, 2, 3, 4, 5], 3)); 40 | -------------------------------------------------------------------------------- /test/love.js: -------------------------------------------------------------------------------- 1 | function printlove(n) { 2 | for (let i = n / 2; i < n; i += 2) { 3 | let line = ""; 4 | 5 | // Tampilkan spasi pertama 6 | for (let j = 1; j < n - i; j += 2) { 7 | line += " "; 8 | } 9 | 10 | // Tampilkan bintang pertama 11 | for (let j = 1; j < i + 1; j++) { 12 | line += "*"; 13 | } 14 | 15 | // Tampilkan spasi kedua 16 | for (let j = 1; j < n - i + 1; j++) { 17 | line += " "; 18 | } 19 | 20 | // Tampilkan bintang kedua 21 | for (let j = 1; j < i + 1; j++) { 22 | line += "*"; 23 | } 24 | 25 | console.log(line); 26 | } 27 | 28 | // Bagian bawah love 29 | for (let i = n; i > 0; i--) { 30 | let line = ""; 31 | 32 | // Tampilkan spasi 33 | for (let j = 0; j < n - i; j++) { 34 | line += " "; 35 | } 36 | 37 | // Tampilkan bintang 38 | for (let j = 1; j < i * 2; j++) { 39 | line += "*"; 40 | } 41 | 42 | console.log(line); 43 | } 44 | } 45 | 46 | // Contoh pemanggilan fungsi printlove dengan n = 6 47 | printlove(10); 48 | 49 | 50 | -------------------------------------------------------------------------------- /array/concatenationOfArray.js: -------------------------------------------------------------------------------- 1 | /* 2 | Given an integer array nums of length n, you want to create an array ans of length 2n where ans[i] == nums[i] and ans[i + n] == nums[i] for 0 <= i < n (0-indexed). 3 | 4 | Specifically, ans is the concatenation of two nums arrays. 5 | 6 | Return the array ans. 7 | */ 8 | 9 | /* 10 | Input: nums = [1,3,2,1] 11 | Output: [1,3,2,1,1,3,2,1] 12 | Explanation: The array ans is formed as follows: 13 | - ans = [nums[0],nums[1],nums[2],nums[3],nums[0],nums[1],nums[2],nums[3]] 14 | - ans = [1,3,2,1,1,3,2,1] 15 | */ 16 | 17 | /* 18 | Input: nums = [1,2,1] 19 | Output: [1,2,1,1,2,1] 20 | Explanation: The array ans is formed as follows: 21 | - ans = [nums[0],nums[1],nums[2],nums[0],nums[1],nums[2]] 22 | - ans = [1,2,1,1,2,1] 23 | */ 24 | 25 | var getConcatenation = (numRows) => { 26 | 27 | let array2 = [] 28 | numRows.forEach(element => { 29 | array2.push(element) 30 | }); 31 | 32 | let result = numRows.concat(array2) 33 | return result 34 | }; 35 | 36 | console.log(getConcatenation([1,2,1])); 37 | console.log(getConcatenation([1,3,2,1])); -------------------------------------------------------------------------------- /array/applyTransformEachElement.js: -------------------------------------------------------------------------------- 1 | /* 2 | Input: arr = [1,2,3], fn = function plusone(n) { return n + 1; } 3 | Output: [2,3,4] 4 | Explanation: 5 | const newArray = map(arr, plusone); // [2,3,4] 6 | The function increases each value in the array by one. 7 | */ 8 | 9 | /* 10 | Input: arr = [1,2,3], fn = function plusI(n, i) { return n + i; } 11 | Output: [1,3,5] 12 | Explanation: The function increases each value by the index it resides in. 13 | */ 14 | 15 | /* 16 | Input: arr = [10,20,30], fn = function constant() { return 42; } 17 | Output: [42,42,42] 18 | Explanation: The function always returns 42. 19 | */ 20 | 21 | /** 22 | * @param {number[]} arr 23 | * @param {Function} fn 24 | * @return {number[]} 25 | */ 26 | var map = function (arr, fn) { 27 | let results = []; 28 | let i = 0; 29 | arr.forEach((element) => { 30 | let result = fn(element, i); 31 | results.push(result); 32 | i++; 33 | }); 34 | return results; 35 | }; 36 | 37 | const arr = [1, 2, 3]; 38 | const fn = function plusone(n) { 39 | return n + 1; 40 | }; 41 | console.log(map(arr, fn)); 42 | -------------------------------------------------------------------------------- /array/filterElementsArray.js: -------------------------------------------------------------------------------- 1 | /* 2 | Input: arr = [0,10,20,30], fn = function greaterThan10(n) { return n > 10; } 3 | Output: [20,30] 4 | Explanation: 5 | const newArray = filter(arr, fn); // [20, 30] 6 | The function filters out values that are not greater than 10 7 | */ 8 | 9 | /* 10 | Input: arr = [1,2,3], fn = function firstIndex(n, i) { return i === 0; } 11 | Output: [1] 12 | Explanation: 13 | fn can also accept the index of each element 14 | In this case, the function removes elements not at index 0 15 | */ 16 | 17 | /* 18 | Input: arr = [-2,-1,0,1,2], fn = function plusOne(n) { return n + 1 } 19 | Output: [-2,0,1,2] 20 | Explanation: 21 | Falsey values such as 0 should be filtered out 22 | */ 23 | 24 | 25 | const filter = (arr, fn) => { 26 | const result = []; 27 | 28 | for (let index = 0; index < arr.length; index++) { 29 | if(fn(arr[index], index)){ 30 | result.push(arr[index]) 31 | }; 32 | } 33 | 34 | return result; 35 | }; 36 | 37 | const arr = [1,2,3]; 38 | const fn = function firstIndex(n, i) { return i === 0; } 39 | console.log(filter(arr, fn)); 40 | 41 | -------------------------------------------------------------------------------- /matriks/matrixDiagonal.js: -------------------------------------------------------------------------------- 1 | var diagonalSum = function(mat) { 2 | let total = mat.length 3 | 4 | let primaryDiagonal = 0 5 | let secondaryDiagonal = 0 6 | for (let i = 0; i < total; i++) { 7 | const element = mat[i][i]; 8 | primaryDiagonal = primaryDiagonal + element 9 | } 10 | 11 | if(total % 2 === 1){ 12 | let temp = total 13 | for (let j = 0; j < total; j++) { 14 | const element = mat[j][temp-1]; 15 | element 16 | if(j !== temp-1){ 17 | secondaryDiagonal = secondaryDiagonal + element 18 | } 19 | temp-- 20 | } 21 | } else { 22 | let temp = total 23 | for (let j = 0; j < total; j++) { 24 | const element = mat[j][temp-1]; 25 | temp-- 26 | secondaryDiagonal = secondaryDiagonal + element 27 | } 28 | } 29 | 30 | return primaryDiagonal + secondaryDiagonal 31 | }; 32 | 33 | console.log(diagonalSum([[1,2,3], 34 | [4,5,6], 35 | [7,8,9]])); //25 36 | 37 | console.log(diagonalSum([[1,1,1,1], 38 | [1,1,1,1], 39 | [1,1,1,1], 40 | [1,1,1,1]])); //8 41 | 42 | console.log([[5]]); //[[5]] -------------------------------------------------------------------------------- /stack/1047.js: -------------------------------------------------------------------------------- 1 | class Stack { 2 | constructor() { 3 | this.stack = []; 4 | } 5 | 6 | push(element) { 7 | this.stack.push(element); 8 | } 9 | 10 | pop() { 11 | if (this.isEmpty()) return "Stack Kosong"; 12 | return this.stack.pop(); 13 | } 14 | 15 | isEmpty() { 16 | return this.stack.length === 0; 17 | } 18 | 19 | peek() { 20 | return this.stack[this.stack.length - 1]; 21 | } 22 | 23 | size() { 24 | return this.stack.length; 25 | } 26 | 27 | print() { 28 | let string = ""; 29 | for (let i = 0; i < this.stack.length; i++) { 30 | string += this.stack[i]; 31 | } 32 | return string; 33 | } 34 | } 35 | 36 | var removeDuplicates = function (s) { 37 | let stack = new Stack(); 38 | 39 | for (let i = 0; i < s.length; i++) { 40 | const element = s[i]; 41 | element 42 | if(stack.isEmpty() || stack.peek() !== element) { 43 | stack.push(element) 44 | } else { 45 | stack.pop() 46 | } 47 | } 48 | 49 | return stack.print(); 50 | }; 51 | 52 | console.log(removeDuplicates("azxxzy")); 53 | -------------------------------------------------------------------------------- /hashmap/luckyNumber.js: -------------------------------------------------------------------------------- 1 | /* 2 | Input: arr = [2,2,3,4] 3 | Output: 2 4 | Explanation: The only lucky number in the array is 2 because frequency[2] == 2. 5 | */ 6 | 7 | /* 8 | Input: arr = [1,2,2,3,3,3] 9 | Output: 3 10 | Explanation: 1, 2 and 3 are all lucky numbers, return the largest of them. 11 | */ 12 | 13 | /* 14 | Input: arr = [2,2,2,3,3] 15 | Output: -1 16 | Explanation: There are no lucky numbers in the array. 17 | */ 18 | 19 | var findLucky = (arr) => { 20 | const frequency = {}; 21 | 22 | // Menghitung frekuensi setiap elemen dalam array 23 | for (let i = 0; i < arr.length; i++) { 24 | const num = arr[i]; 25 | if (frequency[num]) { 26 | frequency[num]++; 27 | } else { 28 | frequency[num] = 1; 29 | } 30 | } 31 | 32 | frequency; 33 | 34 | // Mencari angka beruntung (lucky number) 35 | let luckyNumber = -1; 36 | for (const key in frequency) { 37 | if (key == frequency[key]) { 38 | luckyNumber = Math.max(luckyNumber, key); 39 | } 40 | } 41 | 42 | return luckyNumber; 43 | }; 44 | 45 | console.log(findLucky([2, 2, 3, 3])); 46 | -------------------------------------------------------------------------------- /stack/1209.js: -------------------------------------------------------------------------------- 1 | class Stack { 2 | constructor() { 3 | this.stack = []; 4 | } 5 | 6 | push(element) { 7 | this.stack.push(element); 8 | } 9 | 10 | pop() { 11 | if (this.isEmpty()) return "Stack Kosong"; 12 | return this.stack.pop(); 13 | } 14 | 15 | isEmpty() { 16 | return this.stack.length === 0; 17 | } 18 | 19 | peek() { 20 | return this.stack[this.stack.length - 1]; 21 | } 22 | 23 | size() { 24 | return this.stack.length; 25 | } 26 | 27 | print() { 28 | let string = ""; 29 | for (let i = 0; i < this.stack.length; i++) { 30 | string += this.stack[i]; 31 | } 32 | return string; 33 | } 34 | 35 | remove(k){ 36 | for (let i = 0; i < k; i++) { 37 | this.stack.pop() 38 | } 39 | } 40 | } 41 | 42 | var removeDuplicates = function (s, k) { 43 | let stack = new Stack(); 44 | 45 | let count = 1 46 | for (let i = 0; i < s.length; i++) { 47 | 48 | const element = s[i]; 49 | stack.push(element) 50 | 51 | } 52 | 53 | stack 54 | }; 55 | 56 | console.log(removeDuplicates("deeedbbccbdaaeee", 3)); 57 | -------------------------------------------------------------------------------- /array/1343medium.js: -------------------------------------------------------------------------------- 1 | // var numOfSubarrays = function(arr, k, threshold) { 2 | // let res = 0 3 | // let totalmove = arr.length - k 4 | // for (let i = 0; i < totalmove+1; i++) { 5 | // let tempArr = 0 6 | // for (let j = i; j < k+i; j++) { 7 | // tempArr+=arr[j]; 8 | // } 9 | // if(tempArr / k >= threshold){ 10 | // res++ 11 | // } 12 | 13 | // } 14 | // return res 15 | // }; 16 | var numOfSubarrays = function (arr, k, threshold) { 17 | let res = 0; 18 | let windowSum = 0; 19 | 20 | for (let i = 0; i < k; i++) { 21 | windowSum += arr[i]; 22 | } 23 | 24 | if (windowSum / k >= threshold) { 25 | res++; 26 | } 27 | 28 | for (let i = k; i < arr.length; i++) { 29 | let nextWindow = arr[i]; 30 | let prevWindow = arr[i - k]; 31 | windowSum += nextWindow - prevWindow; 32 | if (windowSum / k >= threshold) { 33 | res++; 34 | } 35 | } 36 | 37 | return res; 38 | }; 39 | 40 | console.log(numOfSubarrays([2, 4, 6, 8, 10], 2, 8)); //3 41 | 42 | let x = 5 43 | console.log(x) 44 | x = "berubah" 45 | console.log(x) 46 | -------------------------------------------------------------------------------- /hashmap/2284medium.js: -------------------------------------------------------------------------------- 1 | var largestWordCount = function (messages, senders) { 2 | let map = new Map(); 3 | 4 | for (let i = 0; i < senders.length; i++) { 5 | map.set( 6 | senders[i], 7 | (map.get(senders[i]) || 0) + messages[i].split(" ").length 8 | ); 9 | } 10 | map; 11 | 12 | let largerName = ""; 13 | let sameValue = null; 14 | 15 | for (const [name, value] of map.entries()) { 16 | if ( 17 | sameValue === null || 18 | value > sameValue || 19 | (value === sameValue && name > largerName) 20 | ) { 21 | largerName = name; 22 | sameValue = value; 23 | } 24 | } 25 | 26 | return largerName; 27 | }; 28 | 29 | console.log(largestWordCount(["Hello userTwooo","Hi userThree","Wonderful day Alice","Nice day userThree"], ["Alice","userTwo","userThree", "Alice"])); 30 | console.log( 31 | largestWordCount( 32 | ["How is leetcode for everyone", "Leetcode is useful for practice"], 33 | ["Bob", "Charlie"] 34 | ) 35 | ); 36 | // console.log(largestWordCount(["How is leetcode for everyone","Leetcode is useful for practice"], ["Bob","Charlie"])); 37 | -------------------------------------------------------------------------------- /hashmap/73.js: -------------------------------------------------------------------------------- 1 | var setZeroes = function (matrix) { 2 | 3 | //mencari index yang bervalue 0 4 | let found = []; 5 | for (let row = 0; row < matrix.length; row++) { 6 | for (let col = 0; col < matrix[0].length; col++) { 7 | if (matrix[row][col] === 0) { 8 | let foundAt = [row, col]; 9 | found.push(foundAt); 10 | } 11 | } 12 | } 13 | console.log(found) // [ [ 0, 0 ], [ 0, 3 ] ] 14 | 15 | 16 | //replace 0 sesuai baris dan kolom yang sudah didapatkan 17 | for (let i = 0; i < found.length; i++) { 18 | const [row, col] = found[i]; 19 | 20 | console.log(row) // 0, 0 21 | console.log(col) // 0, 3 22 | 23 | //replace dari setiap baris 24 | for (let i = 0; i < matrix.length; i++) { 25 | matrix[i][col] = 0; 26 | } 27 | 28 | //replace dari setiap kolom 29 | for (let i = 0; i < matrix[0].length; i++) { 30 | matrix[row][i] = 0; 31 | } 32 | } 33 | 34 | return matrix; 35 | }; 36 | 37 | console.log( 38 | setZeroes([ 39 | [0, 1, 2, 0], 40 | [3, 4, 5, 2], 41 | [1, 3, 1, 5], 42 | ]) 43 | ); // [ [ 0, 0, 0, 0 ], [ 0, 4, 5, 0 ], [ 0, 3, 1, 0 ] ] 44 | -------------------------------------------------------------------------------- /array/numberOfSeniorCitizens.js: -------------------------------------------------------------------------------- 1 | /* 2 | You are given a 0-indexed array of strings details. Each element of details provides information about a given passenger compressed into a string of length 15. The system is such that: 3 | 4 | The first ten characters consist of the phone number of passengers. 5 | The next character denotes the gender of the person. 6 | The following two characters are used to indicate the age of the person. 7 | The last two characters determine the seat allotted to that person. 8 | Return the number of passengers who are strictly more than 60 years old. 9 | */ 10 | 11 | /* 12 | Input: details = ["7868190130M7522","5303914400F9211","9273338290F4010"] 13 | Output: 2 14 | Explanation: The passengers at indices 0, 1, and 2 have ages 75, 92, and 40. Thus, there are 2 people who are over 60 years old. 15 | */ 16 | 17 | var countSeniors = (details) => { 18 | let count = 0; 19 | details.forEach(element => { 20 | const age = element.slice(11,13) 21 | if(age > 60) count++ 22 | }); 23 | 24 | return count 25 | }; 26 | 27 | console.log(countSeniors(["7868190130M7522","5303914400F9211","9273338290F4010"])) //output 2 28 | 29 | -------------------------------------------------------------------------------- /array/1380.js: -------------------------------------------------------------------------------- 1 | // var luckyNumbers = function(lampu, waktu) { 2 | 3 | // let result = [] 4 | 5 | // for(const detik of waktu){ 6 | // let temp = [] 7 | // lampu.forEach((element) => { 8 | // temp.push(element) 9 | // }) 10 | // let res = temp.filter((element) => { 11 | // if(detik % element === 0){ 12 | // return element 13 | // } 14 | // }) 15 | // if(res.length === lampu.length){ 16 | // result.push("YA") 17 | // } else { 18 | // result.push("TIDAK") 19 | // } 20 | // } 21 | // return result 22 | // }; 23 | 24 | var lampu = function(lampu, waktu) { 25 | return waktu.map(detik => { 26 | const res = lampu.filter(element => detik % element === 0); 27 | return res.length === lampu.length ? "YA" : "TIDAK"; 28 | }); 29 | }; 30 | console.log(lampu([1,2,10],[1,1000000000000000000])); 31 | //[ 'TIDAK', 'TIDAK', 'YA', 'TIDAK', 'TIDAK', 'TIDAK', 'YA', 'YA' ] 32 | 33 | 34 | 35 | // var luckyNumbers = function(lampu, waktu) { 36 | // return waktu.map(detik => lampu.every(element => detik % element === 0) ? "YA" : "TIDAK"); 37 | // -------------------------------------------------------------------------------- /binarySearch/2389.js: -------------------------------------------------------------------------------- 1 | var answerQueries = function (nums, queries) { 2 | let sorted = nums.sort((a, b) => a - b); 3 | 4 | let prefixSum = []; 5 | prefixSum[0] = sorted[0]; 6 | for (let i = 1; i < sorted.length; i++) { 7 | prefixSum[i] = sorted[i] + prefixSum[i - 1]; 8 | } 9 | 10 | 11 | // function binarySearch(prefixSum, target){ 12 | // let left = 0 13 | // let right = prefixSum.length - 1 14 | 15 | // while(left<=right){ 16 | // let mid = Math.floor((left+right) / 2) 17 | 18 | // if(prefixSum[mid] <= target){ 19 | // left = mid + 1 20 | // } else { 21 | // right = mid - 1 22 | // } 23 | // } 24 | 25 | // return left 26 | // } 27 | 28 | // let res = [] 29 | // queries.forEach((queri) => { 30 | // res.push(binarySearch(prefixSum, queri)) 31 | // }) 32 | 33 | let res = [] 34 | queries.forEach((queri) => { 35 | let count = 0; 36 | let i = 0; 37 | while (prefixSum[i] <= queri) { 38 | count++; 39 | i++; 40 | } 41 | res.push(count); 42 | }); 43 | 44 | return res; 45 | }; 46 | 47 | console.log(answerQueries([4,5,2,1], [3,10,21])); 48 | -------------------------------------------------------------------------------- /hashmap/532medium.js: -------------------------------------------------------------------------------- 1 | // var findPairs = function (nums, k) { 2 | // let set = new Set(); 3 | 4 | // for (let i = 0; i < nums.length; i++) { 5 | // const element = nums[i]; 6 | // for (let j = i + 1; j < nums.length; j++) { 7 | // const diff = nums[j]; 8 | // if (diff === element + k || diff === element - k) { 9 | // const smaller = Math.min(element, diff); 10 | // const larger = Math.max(element, diff); 11 | // set.add(`${smaller}, ${larger}`); 12 | // } 13 | // } 14 | // } 15 | 16 | // return set.size; 17 | // }; 18 | 19 | var findPairs = function (nums, k) { 20 | let set = new Set(); 21 | 22 | for (let i = 0; i < nums.length; i++) { 23 | const element = nums[i]; 24 | for (let j = i + 1; j < nums.length; j++) { 25 | const diff = nums[j]; 26 | if (diff === element + k || diff === element - k) { 27 | const smaller = Math.min(element, diff); 28 | const larger = Math.max(element, diff); 29 | set.add(`${smaller}, ${larger}`); 30 | } 31 | } 32 | } 33 | 34 | return set.size; 35 | }; 36 | 37 | 38 | 39 | console.log(findPairs([3,1,4,1,5], 2)) -------------------------------------------------------------------------------- /matriks/circularMatrix.js: -------------------------------------------------------------------------------- 1 | function generateMatrix(n) { 2 | const result = new Array(n); 3 | for (let i = 0; i < n; i++) { 4 | result[i] = new Array(n); 5 | } 6 | 7 | let cnt = 1; 8 | for (let layer = 0; layer < Math.floor((n + 1) / 2); layer++) { 9 | layer 10 | // direction 1 - traverse from left to right 11 | for (let ptr = layer; ptr < n - layer; ptr++) { 12 | ptr 13 | layer 14 | result[layer][ptr] = cnt++; 15 | } 16 | // direction 2 - traverse from top to bottom 17 | for (let ptr = layer + 1; ptr < n - layer; ptr++) { 18 | ptr 19 | layer 20 | result[ptr][n - layer - 1] = cnt++; 21 | } 22 | // direction 3 - traverse from right to left 23 | for (let ptr = layer + 1; ptr < n - layer; ptr++) { 24 | ptr 25 | layer 26 | result[n - layer - 1][n - ptr - 1] = cnt++; 27 | } 28 | // direction 4 - traverse from bottom to top 29 | for (let ptr = layer + 1; ptr < n - layer - 1; ptr++) { 30 | ptr 31 | layer 32 | result[n - ptr - 1][layer] = cnt++; 33 | } 34 | } 35 | 36 | return result; 37 | } 38 | 39 | console.log(generateMatrix(3)); -------------------------------------------------------------------------------- /design/307medium(TLE).js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | */ 4 | var NumArray = function (nums) { 5 | this.arr = nums; 6 | this.prefixSum = nums.slice(); 7 | // Rumus prefixSum 8 | for (let i = 1; i < this.prefixSum.length; i++) { 9 | this.prefixSum[i] = this.prefixSum[i - 1] + nums[i]; 10 | } 11 | }; 12 | 13 | /** 14 | * @param {number} index 15 | * @param {number} val 16 | * @return {void} 17 | */ 18 | NumArray.prototype.update = function (index, val) { 19 | const diff = val - this.arr[index]; 20 | this.arr[index] = val; 21 | 22 | for (let i = index; i < this.prefixSum.length; i++) { 23 | this.prefixSum[i] += diff; 24 | } 25 | }; 26 | 27 | /** 28 | * @param {number} left 29 | * @param {number} right 30 | * @return {number} 31 | */ 32 | NumArray.prototype.sumRange = function (left, right) { 33 | if (left === 0) { 34 | return this.prefixSum[right]; 35 | } 36 | return this.prefixSum[right] - this.prefixSum[left - 1]; 37 | }; 38 | 39 | 40 | /** 41 | * Your NumArray object will be instantiated and called as such: 42 | * var obj = new NumArray(nums) 43 | * obj.update(index,val) 44 | * var param_2 = obj.sumRange(left,right) 45 | */ 46 | -------------------------------------------------------------------------------- /stack/844.js: -------------------------------------------------------------------------------- 1 | class Stack { 2 | constructor() { 3 | this.stack = []; 4 | } 5 | 6 | push(element) { 7 | this.stack.push(element); 8 | } 9 | 10 | pop() { 11 | if (this.isEmpty()) return "Stack Kosong"; 12 | return this.stack.pop(); 13 | } 14 | 15 | isEmpty() { 16 | return this.stack.length === 0; 17 | } 18 | 19 | peek() { 20 | return this.stack[this.stack.length - 1]; 21 | } 22 | 23 | size() { 24 | return this.stack.length; 25 | } 26 | 27 | print() { 28 | let string = ""; 29 | for (let i = 0; i < this.stack.length; i++) { 30 | string += this.stack[i]; 31 | } 32 | return string; 33 | } 34 | } 35 | 36 | var backspaceCompare = function (s, t) { 37 | let stack1 = new Stack(); 38 | let stack2 = new Stack(); 39 | 40 | s.split("").forEach((element) => { 41 | if (element === "#") { 42 | stack1.pop(); 43 | } else { 44 | stack1.push(element); 45 | } 46 | }); 47 | 48 | t.split("").forEach((element) => { 49 | if (element === "#") { 50 | stack2.pop(); 51 | } else { 52 | stack2.push(element); 53 | } 54 | }); 55 | 56 | return stack1.print() === stack2.print(); 57 | }; 58 | -------------------------------------------------------------------------------- /array/sumMultiples.js: -------------------------------------------------------------------------------- 1 | /* 2 | Given a positive integer n, find the sum of all integers in the range [1, n] inclusive that are divisible by 3, 5, or 7. 3 | Return an integer denoting the sum of all numbers in the given range satisfying the constraint. 4 | */ 5 | 6 | /* 7 | Input: n = 7 8 | Output: 21 9 | Explanation: Numbers in the range [1, 7] that are divisible by 3, 5, or 7 are 3, 5, 6, 7. The sum of these numbers is 21. 10 | */ 11 | /* 12 | Input: n = 10 13 | Output: 40 14 | Explanation: Numbers in the range [1, 10] that are divisible by 3, 5, or 7 are 3, 5, 6, 7, 9, 10. The sum of these numbers is 40. 15 | */ 16 | /* 17 | Input: n = 9 18 | Output: 30 19 | Explanation: Numbers in the range [1, 9] that are divisible by 3, 5, or 7 are 3, 5, 6, 7, 9. The sum of these numbers is 30. 20 | */ 21 | 22 | var sumOfMultiples = function (n) { 23 | let ans = [] 24 | for (let i = 1; i <= n; i++) { 25 | if(i % 3 === 0 || i % 5 === 0 || i % 7 === 0){ 26 | ans.push(i) 27 | } 28 | } 29 | 30 | ans // [3,5,6,7,9,10,12,14,15] 31 | 32 | let sum = ans.reduce((cur, num) => { 33 | return cur + num 34 | }, 0) 35 | 36 | return sum; 37 | }; 38 | 39 | console.log(sumOfMultiples(15)); //81 40 | -------------------------------------------------------------------------------- /binarySearch/2070medium.js: -------------------------------------------------------------------------------- 1 | var maximumBeauty = function(items, queries) { 2 | //karena kita ingin menggunakan binarySearch maka kita sorting price dulu 3 | items.sort((a, b) => a[0] - b[0]); 4 | 5 | let max = items[0][1]; 6 | for (let i = 0; i < items.length; i++) { 7 | max = Math.max(max, items[i][1]); 8 | items[i][1] = max; 9 | } 10 | 11 | //metode binarySearch 12 | const binarySearch = (arr, target) => { 13 | let left = 0; 14 | let right = arr.length - 1; 15 | let result = 0; 16 | while (left <= right) { 17 | let mid = Math.floor((left + right) / 2); 18 | if (arr[mid][0] <= target) { 19 | result = arr[mid][1]; 20 | left = mid + 1; 21 | } else { 22 | right = mid - 1; 23 | } 24 | } 25 | return result; 26 | }; 27 | 28 | const ans = []; 29 | queries.forEach(element => ans.push(binarySearch(items, element))) 30 | 31 | return ans; 32 | }; 33 | 34 | 35 | console.log(maximumBeauty([[1,2],[3,2],[2,4],[5,6],[3,5]], [1,2,3,4,5,6])); 36 | // console.log(maximumBeauty([[1,2],[1,2],[1,3],[1,4]], [1])); 37 | // console.log(maximumBeauty([[10,1000]], [5])); -------------------------------------------------------------------------------- /matriks/2500.js: -------------------------------------------------------------------------------- 1 | var deleteGreatestValue = function (grid) { 2 | let res = 0 3 | 4 | //sorting sub array, karena kita ingin mengambil yang terbesar 5 | for (let i = 0; i < grid.length; i++) { 6 | grid[i].sort((a, b) => b - a); 7 | } 8 | 9 | //lakukan perulangan dengan jumlah isi dari sub array 10 | let total_row = grid[0].length 11 | for (let i = 0; i < total_row; i++) { 12 | let max = -Infinity; 13 | // get max of each column 14 | for (let j = 0; j < grid.length; j++) { 15 | //bandingkan sub array sebelumnya dan sub array selanjutnya 16 | max = Math.max(max, grid[j][i]); 17 | } 18 | 19 | //tambah res dengan nilai maksnya, lalu lanjutkan ke sub array selanjutnya 20 | res += max; 21 | } 22 | 23 | return res; 24 | }; 25 | 26 | console.log( 27 | deleteGreatestValue([ 28 | [1, 2, 4], 29 | [3, 3, 1], 30 | ]) 31 | ); 32 | // console.log(deleteGreatestValue([[9,2,3], [1,2,3]])); 33 | // console.log(deleteGreatestValue([[12]])); 34 | // console.log( 35 | // deleteGreatestValue([ 36 | // [35, 52, 74, 92, 25], 37 | // [65, 77, 1, 73, 32], 38 | // [43, 68, 8, 100, 84], 39 | // [80, 14, 88, 42, 53], 40 | // [98, 69, 64, 40, 60], 41 | // ]) 42 | // ); 43 | -------------------------------------------------------------------------------- /design/counterII.js: -------------------------------------------------------------------------------- 1 | /* 2 | Input: init = 5, calls = ["increment","reset","decrement"] 3 | Output: [6,5,4] 4 | Explanation: 5 | const counter = createCounter(5); 6 | counter.increment(); // 6 7 | counter.reset(); // 5 8 | counter.decrement(); // 4 9 | */ 10 | 11 | /* 12 | Input: init = 0, calls = ["increment","increment","decrement","reset","reset"] 13 | Output: [1,2,1,0,0] 14 | Explanation: 15 | const counter = createCounter(0); 16 | counter.increment(); // 1 17 | counter.increment(); // 2 18 | counter.decrement(); // 1 19 | counter.reset(); // 0 20 | counter.reset(); // 0 21 | */ 22 | 23 | /** 24 | * @param {integer} init 25 | * @return { increment: Function, decrement: Function, reset: Function } 26 | */ 27 | var createCounter = function (init) { 28 | let currentCount = init; 29 | return { 30 | increment: function () { 31 | currentCount += 1; 32 | return currentCount; 33 | }, 34 | decrement: function () { 35 | currentCount -= 1; 36 | return currentCount; 37 | }, 38 | reset: function () { 39 | currentCount = init; 40 | return currentCount; 41 | }, 42 | }; 43 | }; 44 | 45 | /** 46 | * const counter = createCounter(5) 47 | * counter.increment(); // 6 48 | * counter.reset(); // 5 49 | * counter.decrement(); // 4 50 | */ 51 | -------------------------------------------------------------------------------- /simulation/985medium.js: -------------------------------------------------------------------------------- 1 | // var sumEvenAfterQueries = function(nums, queries) { 2 | // let res = [] 3 | // for (let i = 0; i < queries.length; i++) { 4 | // let sum = nums[queries[i][1]] + queries[i][0] 5 | // nums[queries[i][1]] = sum 6 | // let even = nums.filter((element) => { 7 | // return element % 2 == 0 8 | // }) 9 | 10 | // if(even.length === 0){ 11 | // res.push(0) 12 | // } else{ 13 | // res.push(even.reduce((a, b) => { 14 | // return a + b 15 | // })) 16 | // } 17 | // } 18 | // return res 19 | // }; 20 | var sumEvenAfterQueries = function(nums, queries) { 21 | let res = []; 22 | let evenSum = nums.reduce((acc, curr) => acc + (curr % 2 === 0 ? curr : 0), 0); 23 | 24 | for (let i = 0; i < queries.length; i++) { 25 | const val = queries[i][0]; 26 | const index = queries[i][1]; 27 | const prevNum = nums[index]; 28 | const newNum = prevNum + val; 29 | 30 | if (prevNum % 2 === 0) { 31 | evenSum -= prevNum; 32 | } 33 | if (newNum % 2 === 0) { 34 | evenSum += newNum; 35 | } 36 | 37 | nums[index] = newNum; 38 | res.push(evenSum); 39 | } 40 | 41 | return res; 42 | }; 43 | 44 | console.log(sumEvenAfterQueries([1,2,3,4], [[1,0],[-3,1],[-4,0],[2,3]])); 45 | // console.log(sumEvenAfterQueries([1], [[4,0]])); -------------------------------------------------------------------------------- /test/hashmap.js: -------------------------------------------------------------------------------- 1 | let mysql = require("mysql"); 2 | 3 | // Konfigurasi koneksi database 4 | let connection = mysql.createConnection({ 5 | host: "localhost", 6 | user: "root", 7 | database: "longcommonsubsequence", 8 | }); 9 | 10 | // Menghitung jumlah makanan dalam setiap kategori menggunakan HashMap 11 | function countFoodsByCategory(data, k) { 12 | const counter = new Map(); 13 | 14 | //counter 15 | for (const row of data) { 16 | counter.set(row.category, (counter.get(row.category) || 0) + 1) 17 | } 18 | 19 | // Menampilkan counter sesuai kondisi k 20 | for (const [category, count] of counter) { 21 | if(count>k){ 22 | console.log(`Category: ${category}, Count: ${count}`); 23 | } 24 | } 25 | } 26 | 27 | // Mengambil data dari database dan melakukan penghitungan 28 | connection.connect((err) => { 29 | if (err) { 30 | console.error("Error connecting to database:", err); 31 | return; 32 | } 33 | 34 | const query = "SELECT category FROM foods"; 35 | connection.query(query, (error, results) => { 36 | if (error) { 37 | console.error("Error executing query:", error); 38 | return; 39 | } 40 | 41 | if(!countFoodsByCategory(results, 0))console.log(-1); 42 | 43 | // Menutup koneksi database setelah selesai 44 | connection.end(); 45 | }); 46 | }); 47 | -------------------------------------------------------------------------------- /database/1934.sql: -------------------------------------------------------------------------------- 1 | 2 | SELECT s.user_id, ROUND(AVG(IF(c.action="confirmed",1,0)),2) as confirmation_rate 3 | FROM Signups s 4 | LEFT JOIN Confirmations c ON s.user_id = c.user_id 5 | GROUP BY s.user_id 6 | 7 | -- #Karena kita tetap menampilkan semua user meskipun ada yang tidak pada confirmations table 8 | -- #Maka kita akan menggunakan LEFT JOIN 9 | 10 | -- #Kita akan mengelompokan dari setiap user_id pada tabel Signups 11 | 12 | -- #Lalu kita akan menghitung rata-ratanya 13 | 14 | -- #IF(c.action="confirmed",1,0) 15 | -- #kondisi diatas akan mengecek apabila action confirmed maka akan return 1, jika tidak maka 0 16 | 17 | -- #AVG(....) 18 | -- #fungsi AVG untuk menghitung rata-rata setelah pengelompokan GROUP BY berdasarkan user_id 19 | 20 | -- #ROUND(...,2) 21 | -- #fungsi diatas untuk membulatkan dengan mengambil 2 angka setelah koma 22 | 23 | -- # .... as confirmation_rate 24 | -- # berfungsi untuk mengubah kolom menjadi "confirmation_rate" 25 | 26 | 27 | -- #contoh untuk user_id 2: 28 | -- #terdapat 2 action yaitu [confirmed, timeout], jika kita menggunakan AVG maka akan seperti: 29 | -- #AVG((1+0)/totalaction(2)) --> 1 / 2 = 0.5 30 | 31 | -- #contoh untuk user_id 7: 32 | -- #terdapat 3 action yaitu [confirmed, confirmed, confirmed], jika kita menggunakan AVG maka akan seperti: 33 | -- #AVG((1+1+1)/totalaction(3)) --> 3 / 3 = 1 -------------------------------------------------------------------------------- /string/917.js: -------------------------------------------------------------------------------- 1 | // var reverseOnlyLetters = function(s) { 2 | // let reverse = '' 3 | // for(let i = s.length - 1; i >= 0; i--){ 4 | // if(s[i] === "-") continue 5 | // reverse += s[i] 6 | // } 7 | 8 | // let res = '' 9 | // let index = 0 10 | // for (let i = 0; i < s.length; i++) { 11 | // if(s[i] === "-"){ 12 | // res += '-' 13 | // } else { 14 | // res += reverse[index] 15 | // index++ 16 | // } 17 | // } 18 | 19 | // res 20 | 21 | // return res 22 | // }; 23 | 24 | var reverseOnlyLetters = function(s) { 25 | const isLetter = (char) => /[a-zA-Z]/.test(char); 26 | 27 | // Ubah string menjadi array karakter 28 | const sArray = s.split(''); 29 | 30 | let left = 0, right = s.length - 1; 31 | 32 | while (left < right) { 33 | if (!isLetter(sArray[left])) { 34 | left++; 35 | } else if (!isLetter(sArray[right])) { 36 | right--; 37 | } else { 38 | // Tukar huruf jika keduanya adalah huruf 39 | [sArray[left], sArray[right]] = [sArray[right], sArray[left]]; 40 | left++; 41 | right--; 42 | } 43 | } 44 | 45 | // Gabungkan kembali array menjadi string 46 | return sArray.join(''); 47 | }; 48 | 49 | 50 | console.log(reverseOnlyLetters("Test1ng-Leet=code-Q!")); -------------------------------------------------------------------------------- /stack/1381.js: -------------------------------------------------------------------------------- 1 | class CustomStack { 2 | constructor(maxSize) { 3 | this.stack = []; 4 | this.count = 0; 5 | this.maxSize = maxSize; 6 | } 7 | 8 | push(element) { 9 | if (this.count !== this.maxSize) { 10 | this.stack.push(element); 11 | this.count = this.count + 1; 12 | } 13 | } 14 | 15 | pop() { 16 | if (this.isEmpty()) { 17 | return -1; 18 | } else { 19 | this.count--; 20 | return this.stack.pop(); 21 | } 22 | } 23 | 24 | isEmpty() { 25 | return this.stack.length === 0; 26 | } 27 | 28 | peek() { 29 | return this.stack[this.stack.length - 1]; 30 | } 31 | 32 | increment(k, val) { 33 | for (let i = 0; i < Math.min(k, this.count); i++) { 34 | this.stack[i] = this.stack[i] + val; 35 | } 36 | } 37 | 38 | print() { 39 | let str = ""; 40 | for (let i = 0; i < this.stack.length; i++) { 41 | str += this.stack[i]; 42 | } 43 | return str; 44 | } 45 | } 46 | 47 | var obj = new CustomStack(3); 48 | obj.push(1); 49 | obj.push(2); 50 | obj.push(3); 51 | console.log(obj.print()); 52 | obj.increment(5, 100); 53 | console.log(obj.print()); 54 | obj.increment(2, 100); 55 | obj.pop(); 56 | console.log(obj.print()); 57 | obj.pop(); 58 | obj.pop(); 59 | obj.pop(); 60 | obj.pop(); 61 | obj.pop(); 62 | console.log(obj.print()); 63 | -------------------------------------------------------------------------------- /hashmap/929.JS: -------------------------------------------------------------------------------- 1 | var numUniqueEmails = function (emails) { 2 | 3 | //menggunakan set agar value yang duplikat tidak terhitung 4 | let counter = new Set(); 5 | for (let email of emails) { 6 | 7 | //pisahkan lokal dan domain 8 | let splited = email.split("@") 9 | console.log(splited) // [ 'test.email+alex', 'leetcode.com' ] , [ 'test.email.leet+alex', 'code.com' ] 10 | 11 | //kita pakai lokal dahulu, lalu split + 12 | //karena kita tidak menggunakan karakter setelah + 13 | //maka kita akan menggunakan local[0] 14 | let local = splited[0].split("+") 15 | console.log(local) // [ 'test.email', 'alex' ], [ 'test.email.leet', 'alex' ] 16 | 17 | //ubah local[0] jika ada "."" maka hapus 18 | let localfiltered = local[0].replaceAll(".", "") 19 | console.log(localfiltered) // testemail, testemailleet 20 | 21 | //gabungkan local[0] yang sudah difilter tadi bersama splited[1] 22 | //splited[1] adalah domain nya, lalu tambahkan @ diantara keduanya 23 | counter.add(localfiltered+"@"+splited[1]) 24 | 25 | } 26 | 27 | console.log(counter) // Set { 'testemail@leetcode.com', 'testemailleet@code.com' } 28 | 29 | 30 | //return jumlah set nya 31 | return counter.size 32 | }; 33 | 34 | console.log( 35 | numUniqueEmails(["test.email+alex@leetcode.com","test.email.leet+alex@code.com"]) 36 | ); 37 | -------------------------------------------------------------------------------- /design/1357.js: -------------------------------------------------------------------------------- 1 | class Cashier { 2 | constructor(n, discount, products, prices) { 3 | this.map = new Map(); 4 | for (let i = 0; i < products.length; i++) { 5 | this.map.set(products[i], prices[i]); 6 | } 7 | 8 | this.n = n; 9 | this.discount = discount; 10 | this.count = 0; 11 | } 12 | 13 | getBill(product, amount) { 14 | this.total = 0; 15 | this.barang = 0; 16 | for (let i = 0; i < product.length; i++) { 17 | let jumlah_barang = amount[i]; 18 | this.barang++; 19 | this.total += this.map.get(product[i]) * jumlah_barang; 20 | } 21 | 22 | this.count++; 23 | if (this.count === this.n) { 24 | this.count = 0; 25 | return this.total * ((100 - this.discount) / 100); 26 | } 27 | 28 | return this.total; 29 | } 30 | } 31 | 32 | // Contoh penggunaan kelas Cashier 33 | const products = ["apple", "banana", "orange"]; 34 | const prices = [5, 2, 8]; 35 | const cashier = new Cashier(3, 10, products, prices); 36 | 37 | console.log(cashier.getBill(["apple", "banana"], [1, 2])); // 5*1 + 4*2 = 9 38 | console.log(cashier.getBill(["orange", "banana"], [3, 2])); // 8*3 + 2*2 = 28 39 | 40 | //pelanggan ke tiga dapat diskon, karena setiap perulangan 3 customer dapat diskon 41 | console.log(cashier.getBill(["orange", "apple"], [3, 2])); // 8*3 + 5*2 = 34 * ((100-10) / 100) = 30.6 42 | -------------------------------------------------------------------------------- /string/28.js: -------------------------------------------------------------------------------- 1 | // var strStr = function (haystack, needle) { 2 | 3 | // let pointer = [] 4 | // for (let i = 1; i <= haystack.length; i++) { 5 | // let scndArray = [] 6 | // for (let j = 0; j < i; j++) { 7 | // const element = haystack[j]; 8 | // scndArray.push(element) 9 | // } 10 | // pointer.push([...scndArray]) 11 | // } 12 | // let res = 0; 13 | // for (let i = 0; i < pointer.length; i++) { 14 | // const element = pointer[i]; 15 | // let temp = element.join('') 16 | // needle 17 | // temp 18 | // if(temp === needle){ 19 | // res = Math.min(res, i) 20 | // } else { 21 | // res = -1 22 | // } 23 | // } 24 | 25 | 26 | // return res 27 | // }; 28 | var strStr = function(haystack, needle) { 29 | if (needle === "") { 30 | return 0; 31 | } 32 | 33 | for (let i = 0; i <= haystack.length - needle.length; i++) { 34 | let found = true; 35 | for (let j = 0; j < needle.length; j++) { 36 | let temp = haystack[i + j] 37 | temp 38 | let temp2 = needle[j] 39 | temp2 40 | if (haystack[i + j] !== needle[j]) { 41 | found = false; 42 | break; 43 | } 44 | } 45 | if (found) { 46 | return i; 47 | } 48 | } 49 | 50 | return -1; 51 | }; 52 | 53 | console.log(strStr("sadbutsad", "sad")); 54 | // console.log(strStr("leetcode", "leeto")); 55 | -------------------------------------------------------------------------------- /array/1630.js: -------------------------------------------------------------------------------- 1 | // var checkArithmeticSubarrays = function (nums, l, r) { 2 | 3 | // let res = [] 4 | 5 | // for (let i = 0; i < r.length; i++) { 6 | // let temp = nums.slice(l[i], r[i]+1) 7 | // temp 8 | // let sorted = temp.sort((a,b) => a-b) 9 | // sorted 10 | // let op = sorted[1] - sorted[0] 11 | // op 12 | // for (let j = 0; i < sorted.length - 1; i++) { 13 | // if(sorted[j] + op !== sorted[j+1]){ 14 | // res.push(false) 15 | // break 16 | // } 17 | // } 18 | 19 | // res.push(true) 20 | 21 | // } 22 | 23 | // return res 24 | // }; 25 | 26 | 27 | var checkArithmeticSubarrays = function(nums, l, r) { 28 | let res = []; 29 | 30 | for (let i = 0; i < l.length; i++) { 31 | let temp = nums.slice(l[i], r[i] + 1); 32 | let sorted = temp.slice().sort((a, b) => a - b); 33 | let op = sorted[1] - sorted[0]; 34 | let isArithmetic = true; 35 | 36 | for (let j = 0; j < sorted.length - 1; j++) { 37 | if (sorted[j] + op !== sorted[j + 1]) { 38 | isArithmetic = false; 39 | break; 40 | } 41 | } 42 | 43 | res.push(isArithmetic); 44 | } 45 | 46 | return res; 47 | }; 48 | 49 | console.log(checkArithmeticSubarrays([4, 6, 5, 9, 3, 7], [0, 0, 2], [2, 3, 5])); 50 | 51 | 52 | console.log(checkArithmeticSubarrays([-12,-9,-3,-12,-6,15,20,-25,-20,-15,-10], [0,1,6,4,8,7], [4,4,9,7,9,10])); 53 | -------------------------------------------------------------------------------- /string/truncateSentence.js: -------------------------------------------------------------------------------- 1 | /* 2 | A sentence is a list of words that are separated by a single space with no leading or trailing spaces. Each of the words consists of only uppercase and lowercase English letters (no punctuation). 3 | 4 | For example, "Hello World", "HELLO", and "hello world hello world" are all sentences. 5 | You are given a sentence s​​​​​​ and an integer k​​​​​​. You want to truncate s​​​​​​ such that it contains only the first k​​​​​​ words. Return s​​​​​​ after truncating it. 6 | */ 7 | 8 | /* 9 | Input: s = "Hello how are you Contestant", k = 4 10 | Output: "Hello how are you" 11 | Explanation: 12 | The words in s are ["Hello", "how" "are", "you", "Contestant"]. 13 | The first 4 words are ["Hello", "how", "are", "you"]. 14 | Hence, you should return "Hello how are you". 15 | */ 16 | 17 | /* 18 | Input: s = "What is the solution to this problem", k = 4 19 | Output: "What is the solution" 20 | Explanation: 21 | The words in s are ["What", "is" "the", "solution", "to", "this", "problem"]. 22 | The first 4 words are ["What", "is", "the", "solution"]. 23 | Hence, you should return "What is the solution". 24 | */ 25 | 26 | var truncateSentence = function(s, k) { 27 | let split = s.split(' ') 28 | let res = [] 29 | for (let index = 0; index < k; index++) { 30 | res.push(split[index]) 31 | } 32 | 33 | return res.join(' ') 34 | }; 35 | 36 | console.log(truncateSentence("Hello how are you Contestant", 4)) //Hello how are you -------------------------------------------------------------------------------- /rekursif/howSum.js: -------------------------------------------------------------------------------- 1 | // const howSum = (targetSum, numbers) => { 2 | // //jika semua pengurangan selesai di angka 0, maka terdapat angka yang benar 3 | // if (targetSum === 0) return []; 4 | // //jika tidak selesai pada 0, dan hasil minus, maka tidak ada angka yang dapat mencapai target 5 | // if (targetSum < 0) return null; 6 | 7 | // //melakukan perulangan terhadap targetsum dengan numbers 8 | // for (let num of numbers) { 9 | // //targetSum 7, 3, 3, 7 10 | // //num 4, 4, 7, 7 11 | 12 | // //variabel baru untuk mengulangi perintah howSum 13 | // const remainder = targetSum - num; 14 | // //remainder 3, -1, -4, 0 () 15 | 16 | // const combinations = howSum(remainder, numbers); 17 | // //combinations = null, null, null, [] 18 | 19 | // //jika targetSum berhasil mencapai 0, tidak minus, maka akan mengembalikan nilai pengurangnya(num) 20 | // if (combinations !== null) { 21 | // return [...combinations, num]; 22 | // } 23 | // } 24 | 25 | // return null; 26 | // }; 27 | 28 | 29 | 30 | 31 | 32 | const howSum = (targetSum, numbers) => { 33 | if (targetSum === 0) return []; 34 | if (targetSum < 0) return null; 35 | 36 | for (let num of numbers) { 37 | const remainder = targetSum - num; 38 | const combinations = howSum(remainder, numbers); 39 | if (combinations !== null) { 40 | return [...combinations, num]; 41 | } 42 | } 43 | 44 | return null; 45 | }; 46 | 47 | console.log(howSum(3, [1, 2])); // [7] 48 | // console.log(howSum(7, [5, 3, 4, 7, 1])); // [4, 3] 49 | -------------------------------------------------------------------------------- /stack/71.js: -------------------------------------------------------------------------------- 1 | class Stack { 2 | constructor() { 3 | this.stack = []; 4 | } 5 | 6 | push(item) { 7 | this.stack.push(item); 8 | } 9 | 10 | pop() { 11 | if (this.isEmpty()) { 12 | return "Stack kosong"; 13 | } 14 | return this.stack.pop(); 15 | } 16 | 17 | peek() { 18 | return this.stack[this.stack.length - 1]; 19 | } 20 | 21 | isEmpty() { 22 | return this.stack.length === 0; 23 | } 24 | 25 | join(){ 26 | return this.stack.join("/") 27 | } 28 | } 29 | 30 | const simplifyPath = function (path) { 31 | const stack = new Stack(); 32 | 33 | let split = path.split('/') 34 | split 35 | 36 | for(const arr of split){ 37 | if(arr === "" || arr === ".") continue 38 | 39 | if(arr === ".."){ 40 | stack.pop() 41 | } else { 42 | stack.push(arr) 43 | } 44 | } 45 | return "/" + stack.join() 46 | }; 47 | 48 | console.log(simplifyPath("/../.././")); 49 | 50 | 51 | 52 | // const simplifyPath = function (path) { 53 | // const stack = new Stack(); 54 | 55 | // let dir = ''; 56 | // for (let i = 1; i < path.length; i++) { 57 | // const element = path[i]; 58 | // if (element === "/") { 59 | // if (dir === "..") { 60 | // if (!stack.isEmpty()) { 61 | // stack.pop(); 62 | // } 63 | // } else { 64 | // stack.push(dir); 65 | // } 66 | // dir = ''; 67 | // } else { 68 | // dir += element; 69 | // } 70 | // } 71 | 72 | // if (dir !== "" && dir !== ".") { 73 | // stack.push(dir); 74 | // } 75 | 76 | // return '/' + stack.stack.join('/'); 77 | // }; -------------------------------------------------------------------------------- /hashmap/url.js: -------------------------------------------------------------------------------- 1 | const linkCode = new Map(); 2 | const urlAsli = new Map(); 3 | const chars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; 4 | 5 | //membuat angka kode acak dari chars yang sudah disediakan diatas 6 | const getCode = () => 7 | "http://tinyurl.com/" + 8 | Array.from({ length: 6 }, () => chars.charAt(Math.random() * 62)).join(""); 9 | 10 | //membuat linkCode dari urlAsli nya 11 | const encode = (longUrl) => { 12 | 13 | //cek terlebih dahulu apakah link aslinya sudah tersedia atau belum 14 | if (urlAsli.has(longUrl)) { 15 | return urlAsli.get(longUrl); 16 | } 17 | 18 | //generate linkCode baru nya 19 | let code = getCode(); 20 | //mencari apakah linkCode sudah tersedia atau belum 21 | while (linkCode.has(code)) { 22 | code = getCode(); 23 | } 24 | 25 | //masukkan urlAsli dan linkCode kedalam Map 26 | linkCode.set(code, longUrl); 27 | urlAsli.set(longUrl, code); 28 | 29 | //kembalikan linkcode yang sudah dibuat 30 | return code; 31 | }; 32 | 33 | //mengambil dari map apakah dari linkCode nya terdapat urlAsli nya 34 | const decode = (shortUrl) => linkCode.get(shortUrl); 35 | 36 | // contoh 37 | const longUrl = "https://www.pikri1.com"; 38 | const shortUrl = encode(longUrl); 39 | console.log("Short URL:", shortUrl); // Output: Short URL: http://tinyurl.com/(randomcode) 40 | 41 | const longUrl2 = "https://www.pikri2.com"; 42 | const shortUrl2 = encode(longUrl2); 43 | console.log("Short URL:", shortUrl); // Output: Short URL: http://tinyurl.com/(randomcode) 44 | 45 | const decodedUrl = decode(shortUrl); 46 | console.log("Decoded URL:", decodedUrl); // Output: Decoded URL: https://www.(example).com 47 | 48 | linkCode 49 | urlAsli -------------------------------------------------------------------------------- /stack/1700.js: -------------------------------------------------------------------------------- 1 | class Queue { 2 | constructor() { 3 | this.items = []; 4 | } 5 | 6 | enqueue(item) { 7 | this.items.push(item); 8 | } 9 | 10 | dequeue() { 11 | if (this.isEmpty()) { 12 | return null; 13 | } 14 | return this.items.shift(); 15 | } 16 | 17 | front() { 18 | if (this.isEmpty()) { 19 | return null; 20 | } 21 | return this.items[0]; 22 | } 23 | 24 | isEmpty() { 25 | return this.items.length === 0; 26 | } 27 | 28 | size() { 29 | return this.items.length; 30 | } 31 | } 32 | 33 | const countStudents = function(students, sandwiches) { 34 | const queue = new Queue(); 35 | 36 | //masukkan semua student kedalam antrian 37 | for (const student of students) { 38 | queue.enqueue(student); 39 | } 40 | 41 | let count = 0; 42 | //lakukan perulangan jika antrian masih ada atau count lebih kecil dari antrian 43 | while (!queue.isEmpty() && count < queue.size()) { 44 | 45 | //jika antrian terdepan sama dengan sandwiches paling depan 46 | if (queue.front() === sandwiches[0]) { 47 | count = 0; 48 | //hapus antrian paling depan 49 | queue.dequeue(); 50 | //hapus sandwiches paling depan 51 | sandwiches.shift(); 52 | } else { 53 | //jika tidak maka tambahkan count, bertanda perulangan masih berjalan 54 | count++; 55 | //hapus antrian paling depan, lalu tambahkan ke paling belakang 56 | queue.enqueue(queue.dequeue()); 57 | } 58 | } 59 | 60 | //return sisa antriannya 61 | return queue.size(); 62 | }; 63 | 64 | console.log(countStudents([1, 1, 0, 0], [0, 1, 0, 1])); // 0 65 | console.log(countStudents([1,1,1,0,0,1], [1,0,0,0,1,1])); // 3 66 | -------------------------------------------------------------------------------- /array/largestSubstringTwoEqual.js: -------------------------------------------------------------------------------- 1 | /* 2 | Given a string s, return the length of the longest substring between two equal characters, excluding the two characters. If there is no such substring return -1. 3 | 4 | A substring is a contiguous sequence of characters within a string. 5 | */ 6 | 7 | /* 8 | Input: s = "aa" 9 | Output: 0 10 | Explanation: The optimal substring here is an empty substring between the two 'a's. 11 | */ 12 | 13 | /* 14 | Input: s = "abca" 15 | Output: 2 16 | Explanation: The optimal substring here is "bc". 17 | */ 18 | 19 | /* 20 | Input: s = "cbzxy" 21 | Output: -1 22 | Explanation: There are no characters that appear twice in s. 23 | */ 24 | 25 | var largestSubstring = function(s) { 26 | let array = s.split('') 27 | 28 | let temp = [] 29 | let res = [] 30 | let max = 0 31 | 32 | //mencari index keberapa saja yang stringnya sama 33 | for (let i = 0; i < array.length; i++) { 34 | for (let j = i+1; j < array.length; j++) { 35 | if(array[i] === array[j]){ 36 | temp.push(i, j) 37 | } 38 | } 39 | } 40 | 41 | //mencari jumlah perbandingan yang paling besar 42 | for (let i = 0; i < temp.length; i++) { 43 | let element = temp[i] 44 | let element2 = temp[i+1] 45 | let sum = element2 - element 46 | if(sum > max){ 47 | max = sum 48 | } 49 | } 50 | 51 | //return hasil tersebut 52 | if(temp.length && res.length >= 0){ 53 | return max-1 54 | } else if (temp.length && res.length === 0){ 55 | return temp.length 56 | } else { 57 | return -1 58 | } 59 | 60 | }; 61 | 62 | console.log(largestSubstring("abca")) // 2 63 | console.log(largestSubstring("aa")) // 0 64 | console.log(largestSubstring("cbzxy")) // -1 65 | -------------------------------------------------------------------------------- /matriks/36medium.js: -------------------------------------------------------------------------------- 1 | var isValidSudoku = function (board) { 2 | let set = new Set(); // Membuat set kosong untuk menyimpan kunci (key) unik 3 | 4 | for (let baris = 0; baris < 9; baris++) { 5 | for (let kolom = 0; kolom < 9; kolom++) { 6 | let nilaiSel = board[baris][kolom]; // Nilai dari sel (cell) saat ini 7 | 8 | if (nilaiSel !== '.') { // Jika nilai sel bukan '.' 9 | let kunciBaris = `baris${baris}${nilaiSel}`; // Kunci unik untuk baris 10 | let kunciKolom = `kolom${kolom}${nilaiSel}`; // Kunci unik untuk kolom 11 | let kunciKotak = `kotak${Math.floor(baris / 3)}${Math.floor(kolom / 3)}${nilaiSel}`; // Kunci unik untuk kotak 12 | 13 | if (set.has(kunciBaris) || set.has(kunciKolom) || set.has(kunciKotak)) { 14 | return false; // Jika kunci sudah ada di dalam set, Sudoku tidak valid 15 | } 16 | 17 | set.add(kunciBaris); // Menambahkan kunci baris ke dalam set 18 | set.add(kunciKolom); // Menambahkan kunci kolom ke dalam set 19 | set.add(kunciKotak); // Menambahkan kunci kotak ke dalam set 20 | } 21 | } 22 | } 23 | 24 | return true; // Jika semua sel memenuhi aturan Sudoku, Sudoku valid 25 | }; 26 | 27 | 28 | 29 | 30 | console.log( 31 | isValidSudoku([["8","3",".",".","7",".",".",".","."] 32 | ,["6",".",".","1","9","5",".",".","."] 33 | ,[".","9","8",".",".",".",".","6","."] 34 | ,["8",".",".",".","6",".",".",".","3"] 35 | ,["4",".",".","8",".","3",".",".","1"] 36 | ,["7",".",".",".","2",".",".",".","6"] 37 | ,[".","6",".",".",".",".","2","8","."] 38 | ,[".",".",".","4","1","9",".",".","5"] 39 | ,[".",".",".",".","8",".",".","7","9"]]) 40 | ); 41 | -------------------------------------------------------------------------------- /binarySearch/74.js: -------------------------------------------------------------------------------- 1 | //METODE BINARYSEARCH 2 | 3 | var findRow = function(matrix, target) { 4 | let top = 0; 5 | let bottom = matrix.length - 1; 6 | 7 | // Inisialisasi dengan nilai -1 untuk menandakan bahwa elemen tidak ditemukan 8 | let indexRow = -1; 9 | 10 | while (top <= bottom) { 11 | indexRow = Math.floor((top + bottom) / 2); 12 | 13 | if (matrix[indexRow][matrix[0].length - 1] < target) { 14 | top = indexRow + 1; 15 | } else if (matrix[indexRow][0] > target) { 16 | bottom = indexRow - 1; 17 | } else { 18 | return indexRow; 19 | } 20 | } 21 | 22 | // Jika elemen tidak ditemukan, maka nilai indexRow akan tetap -1 23 | return indexRow; 24 | }; 25 | 26 | var findColumn = function(matrix, row, target) { 27 | let left = 0; 28 | let right = matrix[0].length - 1; 29 | 30 | while (left <= right) { 31 | let mid = Math.floor((left + right) / 2); 32 | 33 | if (matrix[row][mid] === target) { 34 | // Elemen ditemukan, kembalikan indeks kolom 35 | return true; 36 | } else if (matrix[row][mid] < target) { 37 | left = mid + 1; 38 | } else { 39 | right = mid - 1; 40 | } 41 | } 42 | 43 | // Elemen tidak ditemukan dalam baris yang ditentukan 44 | return false; 45 | }; 46 | 47 | 48 | var searchMatrix = function(matrix, target) { 49 | if (findRow(matrix, target) === -1) { 50 | // Elemen tidak ditemukan dalam matriks, langsung kembalikan -1 51 | return false; 52 | } 53 | 54 | return findColumn(matrix, findRow(matrix, target), target); 55 | }; 56 | 57 | console.log( 58 | searchMatrix( 59 | [ 60 | [1, 3, 5, 7], 61 | [10, 11, 16, 20], 62 | [23, 30, 34, 60], 63 | ], 3 64 | ) 65 | ); 66 | -------------------------------------------------------------------------------- /array/arrayReduce.js: -------------------------------------------------------------------------------- 1 | /* 2 | Input: 3 | nums = [1,2,3,4] 4 | fn = function sum(accum, curr) { return accum + curr; } 5 | init = 0 6 | Output: 10 7 | Explanation: 8 | initially, the value is init=0. 9 | (0) + nums[0] = 1 10 | (1) + nums[1] = 3 11 | (3) + nums[2] = 6 12 | (6) + nums[3] = 10 13 | The final answer is 10. 14 | */ 15 | 16 | /* 17 | Input: 18 | nums = [1,2,3,4] 19 | fn = function sum(accum, curr) { return accum + curr * curr; } 20 | init = 100 21 | Output: 130 22 | Explanation: 23 | initially, the value is init=100. 24 | (100) + nums[0]^2 = 101 25 | (101) + nums[1]^2 = 105 26 | (105) + nums[2]^2 = 114 27 | (114) + nums[3]^2 = 130 28 | The final answer is 130. 29 | */ 30 | 31 | /* 32 | Input: 33 | nums = [] 34 | fn = function sum(accum, curr) { return 0; } 35 | init = 25 36 | Output: 25 37 | Explanation: For empty arrays, the answer is always init. 38 | */ 39 | 40 | 41 | var reduce = (nums, fn, init) => { 42 | //jika array kosong maka return initnya 43 | if (nums.length === 0) { 44 | return init; 45 | } 46 | 47 | //variabel temp untuk menyimpan hasil dari fungsi fn 48 | var temp = 0; 49 | 50 | //perulangan nums sampai habis 51 | for (let index = 0; index < nums.length; index++) { 52 | //mendapatkan value dari nums[index] 53 | const element = nums[index]; 54 | //lalu inisiasikan ke fungsi fn dengan parameter init dan element tadi dan disimpan sementara di temp 55 | temp = fn(init, element); 56 | //ubah init menjadi value setelah fungsi dijalankan 57 | init = temp; 58 | } 59 | 60 | return temp; 61 | }; 62 | 63 | 64 | 65 | const nums = [1,2,3, 4]; 66 | const fn = function sum(accum, curr) { 67 | return accum + curr * curr; 68 | }; 69 | const init = 0; 70 | console.log(reduce(nums, fn, init)); 71 | -------------------------------------------------------------------------------- /array/2125medium.js: -------------------------------------------------------------------------------- 1 | var numberOfBeams = function (bank) { 2 | 3 | //variable untuk menyimpan total device yang tersedia 4 | let devices = []; 5 | 6 | //metode matriks untuk mengambil setiap value 7 | for (let i = 0; i < bank.length; i++) { 8 | const row = bank[i].split(""); 9 | 10 | //deviceBaris untuk menentukan berapa devices dari setiap baris 11 | let deviceBaris = 0; 12 | for (let j = 0; j < row.length; j++) { 13 | const col = bank[i][j]; 14 | //jika setiap value bernilai 1, 15 | if (col === "1") { 16 | //tambah ke deviceBaris 17 | deviceBaris++; 18 | } 19 | } 20 | 21 | console.log(deviceBaris) // 3, 0, 3, 2 22 | 23 | //jika deviceBaris tidak ada, tidak usah dimasukkan ke devices 24 | if (deviceBaris > 0) { 25 | devices.push(deviceBaris); 26 | } 27 | } 28 | 29 | 30 | console.log(devices) // [3,3,2] 31 | //variable untuk menyimpan laser-lasernya 32 | let res = 0; 33 | //melalukan perhitungan Math untuk menghubungkan devices ke devices 34 | for (let i = 0; i < devices.length - 1; i++) { 35 | res += devices[i] * devices[i + 1] 36 | } 37 | 38 | return res; 39 | }; 40 | 41 | console.log(numberOfBeams(["01110","00000","10101","01010"])); // 15 42 | // 43 | // const numberOfBeams = function (bank) { 44 | // let res = 0; 45 | // let arr = []; 46 | 47 | // for (let i = 0; i < bank.length; i++) { 48 | // const row = bank[i]; 49 | // let count = row.split("").map(Number).reduce((a, b) => a + b, 0); 50 | // arr.push(count); 51 | // } 52 | 53 | // let filter = arr.filter((count) => count > 0); 54 | 55 | // for (let i = 0; i < filter.length - 1; i++) { 56 | // res += filter[i] * filter[i + 1]; 57 | // } 58 | 59 | // return res; 60 | // }; 61 | 62 | -------------------------------------------------------------------------------- /stack/682.js: -------------------------------------------------------------------------------- 1 | class Stack { 2 | constructor() { 3 | this.stack = []; 4 | } 5 | 6 | push(item) { 7 | this.stack.push(item); 8 | } 9 | 10 | pop() { 11 | if (this.isEmpty()) { 12 | return "Stack kosong"; 13 | } 14 | return this.stack.pop(); 15 | } 16 | 17 | peek() { 18 | return this.stack[this.stack.length - 1]; 19 | } 20 | 21 | isEmpty() { 22 | return this.stack.length === 0; 23 | } 24 | 25 | plus() { 26 | return ( 27 | parseInt(this.stack[this.stack.length - 1]) + 28 | parseInt(this.stack[this.stack.length - 2]) 29 | ); 30 | } 31 | 32 | getSum() { 33 | let sum = 0; 34 | for (let i = 0; i < this.stack.length; i++) { 35 | sum += parseInt(this.stack[i]); 36 | } 37 | return sum; 38 | } 39 | } 40 | 41 | var calPoints = function (operations) { 42 | let stack = new Stack(); 43 | 44 | const simulation = { 45 | C: () => stack.pop(), 46 | D: () => stack.push(stack.peek() * 2), 47 | "+": () => stack.push(stack.plus()), 48 | default: (element) => stack.push(element), 49 | }; 50 | 51 | operations.forEach((element) => { 52 | const action = simulation[element] || simulation.default; 53 | action(element); 54 | }); 55 | 56 | return stack.getSum(); 57 | }; 58 | 59 | console.log(calPoints(["5", "2", "C", "D", "+"])); // 30 60 | 61 | //IF ELSE NORMAL 62 | var calPoints = function (operations) { 63 | let stack = new Stack(); 64 | 65 | let sum = 0 66 | operations.forEach((element) => { 67 | if (element === "C") { 68 | stack.pop() 69 | } else if(element === "D"){ 70 | stack.push(stack.peek() * 2) 71 | } else if(element === "+"){ 72 | stack.push(stack.plus()) 73 | } else { 74 | stack.push(element) 75 | } 76 | }); 77 | 78 | return stack.getSum() 79 | }; 80 | 81 | console.log(calPoints(["5", "2", "C", "D", "+"])); 82 | -------------------------------------------------------------------------------- /stack/345.js: -------------------------------------------------------------------------------- 1 | var reverseVowels = function (s) { 2 | let stack = []; 3 | 4 | let vowel = "aiueoAIUEO"; 5 | let split = s.split(""); 6 | for (let i = 0; i < split.length; i++) { 7 | if (vowel.includes(split[i])) stack.push(split[i]); 8 | } 9 | 10 | let res = []; 11 | for (let i = 0; i < split.length; i++) { 12 | if (vowel.includes(split[i].toLowerCase())) { 13 | res.push(stack.pop()); 14 | } else { 15 | res.push(split[i]); 16 | } 17 | } 18 | 19 | return res.join(""); 20 | }; 21 | 22 | //fungsi swap untuk menukar array 23 | var swap = function (arr, l, r) { 24 | // [arr[l], arr[r]] = [arr[r], arr[l]]; 25 | let temp = arr[l]; 26 | arr[l] = arr[r]; 27 | arr[r] = temp; 28 | }; 29 | 30 | var reverseVowels = function (s) { 31 | //vowel untuk pengecekan nanti 32 | let vowel = "aiueo"; 33 | let arr = s.split(""); 34 | 35 | //pointer kiri 36 | let l = 0; 37 | //pointer kanan 38 | let r = s.length - 1; 39 | 40 | 41 | //lakukan perulangan sampai kedua titik bertemu di tengah 42 | while (l < r) { 43 | 44 | //jika bukan vokal, geser kiri ke kanan 1 langkah 45 | if (!vowel.includes(s[l].toLowerCase())) { 46 | l++; 47 | } 48 | 49 | //jika bukan vokal, geser kanan ke kiri 1 langkah 50 | if (!vowel.includes(s[r].toLowerCase())) { 51 | r--; 52 | } 53 | 54 | //jika keduanya sudah vokal, maka jalankan fungsi swap 55 | if (vowel.includes(s[l].toLowerCase()) &&vowel.includes(s[r].toLowerCase())) { 56 | //lakukan swap 57 | swap(arr, l, r); 58 | //geser kiri ke kanan satu langkah 59 | l++; 60 | //geser kanan ke kiri satu langkah 61 | r--; 62 | } 63 | } 64 | 65 | //gabungkan kembali agar menjadi string 66 | return arr.join(""); 67 | }; 68 | 69 | console.log(reverseVowels("leetcode")); 70 | console.log(reverseVowels("aiueo")); 71 | console.log(reverseVowels("aA")); 72 | -------------------------------------------------------------------------------- /test/penjualan.js: -------------------------------------------------------------------------------- 1 | let mysql = require("mysql"); 2 | 3 | // Konfigurasi koneksi database 4 | let connection = mysql.createConnection({ 5 | host: "localhost", 6 | user: "root", 7 | database: "longcommonsubsequence", 8 | }); 9 | 10 | // Menghitung total penjualan berdasarkan kategori dan nama menggunakan reduce 11 | function calculateTotalSalesByCategory(data) { 12 | const totalSales = data.reduce((accumulator, item) => { 13 | const { kategori, user, jumlah, harga } = item; 14 | if (!accumulator[kategori]) { 15 | accumulator[kategori] = {}; 16 | } 17 | if (!accumulator[kategori][user]) { 18 | accumulator[kategori][user] = { 19 | totalJumlah: 0, 20 | totalHarga: 0, 21 | }; 22 | } 23 | accumulator[kategori][user].totalJumlah += jumlah; 24 | accumulator[kategori][user].totalHarga += jumlah * harga; 25 | return accumulator; 26 | }, {}); 27 | 28 | // Menampilkan hasil perhitungan 29 | for (const kategori in totalSales) { 30 | console.log(`Kategori: ${kategori}`); 31 | for (const user in totalSales[kategori]) { 32 | console.log(`User: ${user}`); 33 | console.log(`Total Jumlah: ${totalSales[kategori][user].totalJumlah}`); 34 | console.log(`Total Harga: ${totalSales[kategori][user].totalHarga}`); 35 | console.log("-----------------------------"); 36 | } 37 | } 38 | } 39 | 40 | // Mengambil data dari database dan melakukan perhitungan 41 | connection.connect((err) => { 42 | if (err) { 43 | console.error("Error connecting to database:", err); 44 | return; 45 | } 46 | 47 | const query = 48 | "SELECT produk, kategori, jumlah, harga, nama FROM penjualan_data"; 49 | connection.query(query, (error, results) => { 50 | if (error) { 51 | console.error("Error executing query:", error); 52 | return; 53 | } 54 | 55 | calculateTotalSalesByCategory(results); 56 | 57 | // Menutup koneksi database setelah selesai 58 | connection.end(); 59 | }); 60 | }); 61 | -------------------------------------------------------------------------------- /test/longestcommonsubsequence.js: -------------------------------------------------------------------------------- 1 | let mysql = require("mysql"); 2 | 3 | // Konfigurasi koneksi database 4 | let connection = mysql.createConnection({ 5 | host: "localhost", 6 | user: "root", 7 | database: "longcommonsubsequence", 8 | }); 9 | 10 | function longestCommonSubsequence(str1, str2) { 11 | let table = new Array(str1.length + 1).fill(0); 12 | for (let i = 1; i <= str1.length; i++) { 13 | table[i] = new Array(str2.length + 1).fill(0); 14 | } 15 | 16 | for (let i = 1; i <= str1.length; i++) { 17 | for (let j = 1; j <= str2.length; j++) { 18 | if (str1[i - 1] === str2[j - 1]) { 19 | table[i][j] = table[i - 1][j - 1] + 1; 20 | } else { 21 | table[i][j] = Math.max(table[i - 1][j], table[i][j - 1]); 22 | } 23 | } 24 | } 25 | 26 | let lcs = ""; 27 | let i = str1.length; 28 | let j = str2.length; 29 | while (i > 0 && j > 0) { 30 | if (str1[i - 1] === str2[j - 1]) { 31 | lcs += str1[i - 1]; 32 | i--; 33 | j--; 34 | } else if (table[i - 1][j] > table[i][j - 1]) { 35 | i--; 36 | } else { 37 | j--; 38 | } 39 | } 40 | 41 | return lcs; 42 | } 43 | 44 | // Mengambil data dari database dan mencari LCS untuk setiap baris data 45 | connection.connect((err) => { 46 | if (err) { 47 | console.error("Error connecting to database:", err); 48 | return; 49 | } 50 | 51 | let query = "SELECT id, string1, string2 FROM data"; 52 | connection.query(query, (error, results) => { 53 | if (error) { 54 | console.error("Error executing query:", error); 55 | return; 56 | } 57 | let arr = [] 58 | let index = 0 59 | for (let row of results) { 60 | let string1 = row.string1; 61 | let string2 = row.string2; 62 | console.log("index : ", index, longestCommonSubsequence(string1, string2)) 63 | index++ 64 | // arr.push(...longestCommonSubsequence(string1, string2)); 65 | } 66 | 67 | console.log(arr.filter((element) => element != undefined)) 68 | // Menutup koneksi database setelah selesai 69 | connection.end(); 70 | }); 71 | }); 72 | -------------------------------------------------------------------------------- /hashmap/nextGreater.js: -------------------------------------------------------------------------------- 1 | /* 2 | The next greater element of some element x in an array is the first greater element that is to the right of x in the same array. 3 | 4 | You are given two distinct 0-indexed integer arrays nums1 and nums2, where nums1 is a subset of nums2. 5 | 6 | For each 0 <= i < nums1.length, find the index j such that nums1[i] == nums2[j] and determine the next greater element of nums2[j] in nums2. If there is no next greater element, then the answer for this query is -1. 7 | 8 | Return an array ans of length nums1.length such that ans[i] is the next greater element as described above. 9 | */ 10 | /* 11 | Input: nums1 = [4,1,2], nums2 = [1,3,4,2] 12 | Output: [-1,3,-1] 13 | Explanation: The next greater element for each value of nums1 is as follows: 14 | - 4 is underlined in nums2 = [1,3,4,2]. There is no next greater element, so the answer is -1. 15 | - 1 is underlined in nums2 = [1,3,4,2]. The next greater element is 3. 16 | - 2 is underlined in nums2 = [1,3,4,2]. There is no next greater element, so the answer is -1. 17 | */ 18 | /* 19 | Input: nums1 = [2,4], nums2 = [1,2,3,4] 20 | Output: [3,-1] 21 | Explanation: The next greater element for each value of nums1 is as follows: 22 | - 2 is underlined in nums2 = [1,2,3,4]. The next greater element is 3. 23 | - 4 is underlined in nums2 = [1,2,3,4]. There is no next greater element, so the answer is -1. 24 | */ 25 | 26 | var nextGreaterElement = function (nums1, nums2) { 27 | const hashmap = {}; 28 | const output = []; 29 | 30 | for (let i = 0; i < nums2.length; i++) { 31 | hashmap[nums2[i]] = i; 32 | } 33 | 34 | hashmap 35 | 36 | for (let i = 0; i < nums1.length; i++) { 37 | const number = nums1[i]; 38 | for (let j = hashmap[number]; j < nums2.length; j++) { 39 | if (nums2[j] > number) { 40 | output.push(nums2[j]); 41 | break; 42 | } 43 | if (j === nums2.length - 1) { 44 | output.push(-1); 45 | } 46 | } 47 | } 48 | 49 | return output; 50 | }; 51 | 52 | console.log(nextGreaterElement([4, 1, 2], [1, 3, 4, 2])); 53 | // console.log(nextGreaterElement([2,4], [1, 2, 3, 4])); 54 | // console.log(nextGreaterElement([1, 3, 5, 2, 4], [6, 5, 4, 3, 2, 1, 7])); 55 | -------------------------------------------------------------------------------- /array/applyOperationsToArray.js: -------------------------------------------------------------------------------- 1 | /* 2 | You are given a 0-indexed array nums of size n consisting of non-negative integers. 3 | 4 | You need to apply n - 1 operations to this array where, in the ith operation (0-indexed), you will apply the following on the ith element of nums: 5 | 6 | If nums[i] == nums[i + 1], then multiply nums[i] by 2 and set nums[i + 1] to 0. Otherwise, you skip this operation. 7 | After performing all the operations, shift all the 0's to the end of the array. 8 | 9 | For example, the array [1,0,2,0,0,1] after shifting all its 0's to the end, is [1,2,1,0,0,0]. 10 | Return the resulting array. 11 | 12 | Note that the operations are applied sequentially, not all at once. 13 | */ 14 | 15 | /* 16 | Input: nums = [1,2,2,1,1,0] 17 | Output: [1,4,2,0,0,0] 18 | Explanation: We do the following operations: 19 | - i = 0: nums[0] and nums[1] are not equal, so we skip this operation. 20 | - i = 1: nums[1] and nums[2] are equal, we multiply nums[1] by 2 and change nums[2] to 0. The array becomes [1,4,0,1,1,0]. 21 | - i = 2: nums[2] and nums[3] are not equal, so we skip this operation. 22 | - i = 3: nums[3] and nums[4] are equal, we multiply nums[3] by 2 and change nums[4] to 0. The array becomes [1,4,0,2,0,0]. 23 | - i = 4: nums[4] and nums[5] are equal, we multiply nums[4] by 2 and change nums[5] to 0. The array becomes [1,4,0,2,0,0]. 24 | After that, we shift the 0's to the end, which gives the array [1,4,2,0,0,0]. 25 | */ 26 | 27 | /* 28 | Input: nums = [0,1] 29 | Output: [1,0] 30 | Explanation: No operation can be applied, we just shift the 0 to the end. 31 | */ 32 | 33 | const apply = (nums) => { 34 | 35 | let result = [] 36 | let zero = [] 37 | 38 | let temp = nums 39 | for (let index = 0; index < nums.length; index++) { 40 | const first = nums[index]; 41 | const second = nums[index + 1] 42 | if(first === second){ 43 | temp[index] = nums[index] * 2 44 | temp[index+1] = 0 45 | } 46 | } 47 | 48 | for (let index = 0; index < temp.length; index++) { 49 | const element = temp[index]; 50 | if(element !== 0){ 51 | result.push(element) 52 | } else { 53 | zero.push(element) 54 | } 55 | } 56 | 57 | return result.concat(zero) 58 | } 59 | 60 | console.log(apply([1,2,2,1,1,0])); 61 | console.log(apply([0,1])); -------------------------------------------------------------------------------- /matriks/equalRowColumns.js: -------------------------------------------------------------------------------- 1 | // var equalPairs = function (grid) { 2 | // let count = 0; 3 | // const kolom = []; 4 | 5 | // for (let row = 0; row < grid.length; row++) { 6 | // let temp = []; 7 | // for (let col = 0; col < grid.length; col++) { 8 | // temp.push(grid[col][row]); 9 | // } 10 | // kolom.push([...temp]); 11 | // } 12 | 13 | // for (let i = 0; i < grid.length; i++) { 14 | // const baris = grid[i]; 15 | // for (let j = 0; j < kolom.length; j++) { 16 | // const row = kolom[j]; 17 | // if (JSON.stringify(row) === JSON.stringify(baris)) { 18 | // count++; 19 | // } 20 | // } 21 | // } 22 | 23 | // return count; 24 | // }; 25 | 26 | var equalPairs = function (grid) { 27 | 28 | const rowMap = new Map(); 29 | //membuat array untuk setiap baris dari matriks(grid) 30 | for (let row = 0; row < grid.length; row++) { 31 | const currentRow = grid[row]; 32 | console.log(currentRow) // [3,2,1], [1,7,6], [2,7,7] 33 | 34 | const rowString = currentRow.join(','); 35 | console.log(rowString) // 3,2,1 1,7,6 2,7,7 36 | 37 | //melakukan counter pada rowMap untuk menghitung key dan value dari array baris 38 | rowMap.set(rowString, (rowMap.get(rowString) || 0) + 1); 39 | } 40 | console.log(rowMap) // Map { '3,2,1' => 1, '1,7,6' => 1, '2,7,7' => 1 } 41 | 42 | let count = 0; 43 | for (let col = 0; col < grid.length; col++) { 44 | //membuat array sementara untuk menyimpan array kolom dari matriks 45 | let temp = []; 46 | for (let row = 0; row < grid.length; row++) { 47 | temp.push(grid[row][col]); 48 | } 49 | console.log(temp) //[3,1,2], [2,7,7], [1,6,7] 50 | 51 | //gabungkan dari array kolom tersebut dengan menggunakan join agar bisa dibandingkan 52 | const colString = temp.join(','); 53 | console.log(colString) // 3,1,2 2,7,7 1,6,7 54 | 55 | 56 | //membandingkan jika colString sudah ada di map atau belum 57 | if (rowMap.has(colString)) { 58 | //jika sudah kita tambahkan count dengan value dari key yang sudah ditemukan 59 | count += rowMap.get(colString); 60 | } 61 | } 62 | 63 | return count; 64 | }; 65 | 66 | console.log(equalPairs([[3,1,2,2],[1,4,4,5],[2,4,2,2],[2,4,2,2]])); // 3 67 | 68 | let a = [1,2,3] 69 | let b = [1,2,3] 70 | console.log(JSON.stringify(a)==JSON.stringify(b)) 71 | -------------------------------------------------------------------------------- /simulation/2391medium.js: -------------------------------------------------------------------------------- 1 | // var garbageCollection = function (garbage, travel) { 2 | // let prefixSum = []; 3 | // prefixSum[0] = 0 4 | // prefixSum[1] = travel[0]; 5 | // for (let i = 2; i <= travel.length; i++) { 6 | // prefixSum[i] = prefixSum[i - 1] + travel[i-1]; 7 | // } 8 | 9 | // prefixSum 10 | 11 | // let g = 0; 12 | // let index_g = 0; 13 | // let p = 0; 14 | // let index_p = 0; 15 | // let m = 0; 16 | // let index_m = 0; 17 | 18 | // for (let i = 0; i < garbage.length; i++) { 19 | // let element = garbage[i]; 20 | // if (element.includes("G")) { 21 | // index_g = i; 22 | // g = g + element.split("").filter(function (element) { 23 | // return element === "G"; 24 | // }).length; 25 | // } 26 | // if (element.includes("P")) { 27 | // index_p = i ; 28 | // p = p + element.split("").filter(function (element) { 29 | // return element === "P"; 30 | // }).length; 31 | // } 32 | // if (element.includes("M")) { 33 | // index_m = i; 34 | // m = m + element.split("").filter(function (element) { 35 | // return element === "M"; 36 | // }).length; 37 | // } 38 | // } 39 | 40 | // return prefixSum[index_g] + g + prefixSum[index_p] + p + prefixSum[index_m] + m 41 | // }; 42 | 43 | var garbageCollection = function (garbage, travel) { 44 | let count = 0; 45 | let lastindex_g = 0, lastindex_p = 0, lastindex_m = 0; 46 | 47 | // Menghitung jumlah garbage dan mencari index terakhirnya 48 | for (let i = 0; i < garbage.length; i++) { 49 | for (let j = 0; j < garbage[i].length; j++) { 50 | let it = garbage[i][j]; 51 | if (it === 'M') { 52 | lastindex_m = i; 53 | } else if (it === 'P') { 54 | lastindex_p = i; 55 | } else { 56 | lastindex_g = i; 57 | } 58 | count++; 59 | } 60 | } 61 | 62 | let total = count; 63 | let sum = 0; 64 | 65 | // Menghitung untuk menjumlahkan travelnya 66 | for (let i = 0; i < travel.length; i++) { 67 | sum += travel[i]; 68 | if (lastindex_g === i + 1) { 69 | total += sum; 70 | } 71 | if (lastindex_p === i + 1) { 72 | total += sum; 73 | } 74 | if (lastindex_m === i + 1) { 75 | total += sum; 76 | } 77 | } 78 | 79 | return total; 80 | }; 81 | 82 | 83 | 84 | console.log(garbageCollection(["G","P","GP","GG"], [2, 4, 3])); 85 | -------------------------------------------------------------------------------- /prefixsum/2090medium.js: -------------------------------------------------------------------------------- 1 | // var getAverages = function(nums, k) { 2 | 3 | // if(k === 0) return nums 4 | 5 | // let start = 0 + k 6 | // let end = nums.length - k 7 | // let arr = new Array(nums.length).fill(-1) 8 | 9 | // for (let i = start; i < end; i++) { 10 | // let element = nums[i] 11 | // let sum = 0 12 | // let left = i 13 | // while(left > i-k){ 14 | // sum += nums[left-1] 15 | // left-- 16 | // } 17 | // let right = nums.indexOf(element) + k 18 | // let mid = i 19 | // while(mid < right){ 20 | // sum+=nums[mid+1] 21 | // mid++ 22 | // } 23 | // sum 24 | // let total = sum + element 25 | // let avg = Math.floor(total / (k*2+1)) 26 | // arr[i] = avg 27 | // } 28 | // return arr 29 | // }; 30 | 31 | 32 | // var getAverages = function(nums, k) { 33 | // if (k === 0) return nums; 34 | 35 | // let arr = new Array(nums.length).fill(-1); 36 | 37 | // for (let i = k; i < nums.length - k; i++) { 38 | // let sum = 0; 39 | // for (let j = i - k; j <= i + k; j++) { 40 | // sum += nums[j]; 41 | // } 42 | // let avg = Math.floor(sum / (2 * k + 1)); 43 | // arr[i] = avg; 44 | // } 45 | 46 | // return arr; 47 | // }; 48 | 49 | // var getAverages = function(nums, k) { 50 | // const twoK = 2 * k; 51 | // const windowSize = twoK + 1; 52 | 53 | // const result = [...nums].fill(-1); 54 | // result 55 | 56 | // let sum = 0; 57 | // for (let i = 0; i < nums.length; i++) { 58 | // sum += nums[i]; 59 | // sum 60 | // if (i >= twoK) { 61 | // result[i - k] = Math.floor(sum / windowSize) 62 | // sum -= nums[i - twoK]; 63 | // } 64 | // } 65 | // return result; 66 | // }; 67 | 68 | var getAverages = function(nums, k) { 69 | 70 | const prefixSum = new Array(nums.length).fill(-1); 71 | for (let i = 0; i < nums.length; i++) { 72 | if (i === 0) { 73 | prefixSum[i] = nums[i]; 74 | } else { 75 | prefixSum[i] = nums[i] + prefixSum[i - 1]; 76 | } 77 | } 78 | console.log(prefixSum) // [7,11,14,23,24,32,37,39,45] 79 | 80 | const res = new Array(nums.length).fill(-1); 81 | for (let i = k ; i <= (nums.length - 1) - k; i++) { 82 | if (i === k) { 83 | res[i] = Math.floor(prefixSum[i + k] / (k*2+1)); 84 | } else { 85 | res[i] = Math.floor((prefixSum[i + k] - prefixSum[i - k - 1]) / (k*2+1)); 86 | } 87 | } 88 | return res; 89 | }; 90 | 91 | console.log(getAverages([1,2,3,4,5], 3)); -------------------------------------------------------------------------------- /test/maximumSumofDistinctSubarraysWithLengthK.js: -------------------------------------------------------------------------------- 1 | /* 2 | You are given an integer array nums and an integer k. Find the maximum subarray sum of all the subarrays of nums that meet the following conditions: 3 | 4 | The length of the subarray is k, and 5 | All the elements of the subarray are distinct. 6 | Return the maximum subarray sum of all the subarrays that meet the conditions. If no subarray meets the conditions, return 0. 7 | 8 | A subarray is a contiguous non-empty sequence of elements within an array. 9 | */ 10 | 11 | /* 12 | Input: nums = [1,5,4,2,9,9,9], k = 3 13 | Output: 15 14 | Explanation: The subarrays of nums with length 3 are: 15 | - [1,5,4] which meets the requirements and has a sum of 10. 16 | - [5,4,2] which meets the requirements and has a sum of 11. 17 | - [4,2,9] which meets the requirements and has a sum of 15. 18 | - [2,9,9] which does not meet the requirements because the element 9 is repeated. 19 | - [9,9,9] which does not meet the requirements because the element 9 is repeated. 20 | We return 15 because it is the maximum subarray sum of all the subarrays that meet the conditions 21 | */ 22 | 23 | /* 24 | Input: nums = [4,4,4], k = 3 25 | Output: 0 26 | Explanation: The subarrays of nums with length 3 are: 27 | - [4,4,4] which does not meet the requirements because the element 4 is repeated. 28 | We return 0 because no subarrays meet the conditions. 29 | */ 30 | 31 | var maximumSubarraySum = (nums, k) => { 32 | let subArray = []; 33 | let max = 0; 34 | let temp = k; 35 | let slicedArray = []; 36 | for (let i = 0; i < nums.length - k + 1; i++) { 37 | temp; 38 | for (let j = i; j <= nums.length; j++) { 39 | subArray.push(nums[j]); 40 | } 41 | var sliced = subArray.slice(i, temp); 42 | slicedArray[i] = sliced; 43 | temp = temp + 1; 44 | } 45 | 46 | console.log(slicedArray.length); 47 | 48 | for (let i = 0; i < slicedArray.length; i++) { 49 | let allUnique = slicedArray[i].every(function (element, index) { 50 | return slicedArray[i].indexOf(element) === index; 51 | }); 52 | if (allUnique) { 53 | //hitung jumlah 54 | let res = slicedArray[i].reduce((curr, num) => { 55 | return curr + num; 56 | }); 57 | if (res === null || res > max) { 58 | max = res; 59 | } 60 | } else { 61 | max = max + 0; 62 | } 63 | } 64 | 65 | if (k === 1) { 66 | let maxValue = Math.max(...nums); 67 | return maxValue; 68 | } 69 | return max; 70 | }; 71 | 72 | console.log(maximumSubarraySum([1,5,4,2,9,9,9], 3)); 73 | -------------------------------------------------------------------------------- /design/1865.js: -------------------------------------------------------------------------------- 1 | // /** 2 | // * @param {number[]} nums1 3 | // * @param {number[]} nums2 4 | // */ 5 | // var FindSumPairs = function (nums1, nums2) { 6 | // this.arr1 = nums1; 7 | // this.arr2 = nums2; 8 | // }; 9 | 10 | // /** 11 | // * @param {number} index 12 | // * @param {number} val 13 | // * @return {void} 14 | // */ 15 | // FindSumPairs.prototype.add = function (index, val) { 16 | // let temp = this.arr2[index] 17 | // this.arr2[index] = temp + val 18 | // }; 19 | 20 | // /** 21 | // * @param {number} tot 22 | // * @return {number} 23 | // */ 24 | // FindSumPairs.prototype.count = function (tot) { 25 | // let count = 0 26 | // for (let i = 0; i < this.arr1.length; i++) { 27 | // const element = this.arr1[i]; 28 | // for (let j = 0; j < this.arr2.length; j++) { 29 | // const arr2 = this.arr2[j]; 30 | // if(element + arr2 === tot){ 31 | // count++ 32 | // } 33 | // } 34 | // } 35 | // return count 36 | // }; 37 | 38 | // var findSumPairs = new FindSumPairs([1, 1, 2, 2, 2, 3], [1, 4, 5, 2, 5, 4]); 39 | // console.log(findSumPairs.count(7)); 40 | 41 | 42 | var FindSumPairs = function (nums1, nums2) { 43 | this.nums1 = nums1; 44 | this.nums2 = nums2; 45 | this.map = new Map(); 46 | this.map2 = new Map(); 47 | 48 | nums1.forEach((num1) => { 49 | this.map.set(num1, (this.map.get(num1) || 0) + 1); 50 | }); 51 | nums2.forEach((num2) => { 52 | this.map2.set(num2, (this.map2.get(num2) || 0) + 1); 53 | }); 54 | }; 55 | 56 | FindSumPairs.prototype.add = function (index, val) { 57 | var x = this.nums2[index]; 58 | this.map2.set(x, this.map2.get(x) - 1); 59 | this.nums2[index] += val; 60 | var newX = x + val; 61 | this.map2.set(newX, (this.map2.get(newX) || 0) + 1); 62 | }; 63 | 64 | FindSumPairs.prototype.count = function (tot) { 65 | var count = 0; 66 | for (var [key, value] of this.map) { 67 | var diff = tot - key; 68 | var value2 = this.map2.get(diff); 69 | if (value2 !== undefined) { 70 | count += value * value2; 71 | } 72 | } 73 | return count; 74 | }; 75 | 76 | FindSumPairs.prototype.print = function () { 77 | return this.map; 78 | }; 79 | 80 | FindSumPairs.prototype.print2 = function () { 81 | return this.map2; 82 | }; 83 | 84 | var findSumPairs = new FindSumPairs([1, 1, 2, 2, 2, 3], [1, 4, 5, 2, 5, 4]); 85 | console.log(findSumPairs.count(7)); 86 | console.log(findSumPairs.add(3, 2)); 87 | console.log(findSumPairs.count(8)); 88 | 89 | console.log(findSumPairs.print()); 90 | console.log(findSumPairs.print2()); 91 | -------------------------------------------------------------------------------- /binarySearch/34medium.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {number} target 4 | * @return {number[]} 5 | */ 6 | function searchRange(nums, target) { 7 | 8 | //fungsi binary search untuk mencari index pertama nya 9 | function findFirstIndex(nums, target) { 10 | let left = 0; 11 | let right = nums.length - 1; 12 | 13 | while (left <= right) { 14 | let mid = Math.floor((left + right) / 2); 15 | 16 | //kita menggunakan OR untuk mengecek apakah nums[mid] sama dengan target dan nums[mid-1] lebih kecil dari target 17 | if (nums[mid] === target && (mid === 0 || nums[mid-1] < target)) { 18 | return mid; 19 | } 20 | 21 | if (nums[mid] < target) { 22 | left = mid + 1; 23 | } else { 24 | right = mid - 1; 25 | } 26 | } 27 | return -1; 28 | } 29 | 30 | //fungsi binary search untuk mencari index terakhir nya 31 | function findLastIndex(nums, target) { 32 | let left = 0; 33 | let right = nums.length - 1; 34 | 35 | while (left <= right) { 36 | let mid = Math.floor((left + right) / 2); 37 | 38 | //kita menggunakan OR untuk mengecek apakah nums[mid] sama dengan target dan nums[mid+1] lebih besar dari target 39 | if (nums[mid] === target && (mid === nums.length - 1 || nums[mid+1] > target)) { 40 | return mid; 41 | } 42 | 43 | if (nums[mid] <= target) { 44 | left = mid + 1; 45 | } else { 46 | right = mid - 1; 47 | } 48 | } 49 | 50 | return -1; 51 | } 52 | 53 | return [findFirstIndex(nums, target), findLastIndex(nums, target)]; 54 | } 55 | 56 | // function searchRange(nums, target) { 57 | 58 | // //menggunakan metode binarySearch untuk mencari index 59 | // const findIndex = (nums, target, isLower) => { 60 | // let left = 0; 61 | // let right = nums.length - 1; 62 | // let index = -1; 63 | 64 | // while (left <= right) { 65 | // let mid = Math.floor((left + right) / 2); 66 | 67 | // if (nums[mid] > target || (isLower && nums[mid] === target)) { 68 | // right = mid - 1; 69 | // } else { 70 | // left = mid + 1; 71 | // } 72 | 73 | // if (nums[mid] === target) { 74 | // index = mid; 75 | // } 76 | // } 77 | 78 | // return index; 79 | // }; 80 | 81 | // const firstIndex = findIndex(nums, target, true); 82 | // const lastIndex = findIndex(nums, target, false); 83 | 84 | // return [firstIndex, lastIndex]; 85 | // } 86 | 87 | 88 | 89 | 90 | 91 | 92 | console.log(searchRange([5,7,7,8,8,8,10], 8)) -------------------------------------------------------------------------------- /prefixsum/1588.js: -------------------------------------------------------------------------------- 1 | function findSubarrays(arr) { 2 | const subarrays = []; 3 | 4 | for (let i = 0; i < arr.length; i++) { 5 | for (let j = i; j < arr.length; j++) { 6 | const subarray = arr.slice(i, j + 1); 7 | subarrays.push(subarray); 8 | } 9 | } 10 | 11 | return subarrays; 12 | } 13 | 14 | // var sumOddLengthSubarrays = function (arr) { 15 | // return findSubarrays(arr) 16 | // .map((element) => { 17 | // if (element.length % 2 !== 0) { 18 | // return element; 19 | // } 20 | // }) 21 | // .filter((element) => element != undefined) 22 | // .reduce((accumulator, currentArray) => { 23 | // return ( 24 | // accumulator + 25 | // currentArray.reduce((subAccumulator, currentValue) => { 26 | // return subAccumulator + currentValue; 27 | // }, 0) 28 | // ); 29 | // }, 0); 30 | // }; 31 | 32 | var sumOddLengthSubarrays = function(arr) { 33 | const n = arr.length; 34 | let res = 0; 35 | 36 | if (n === 1) return arr[0]; 37 | 38 | //Membuat prefix res dari setiap arr 39 | for (let i = 1; i < n; i++) 40 | arr[i] += arr[i-1]; 41 | 42 | console.log(arr) // [ 1, 3, 6, 10, 15, 21, 28 ] 43 | 44 | let totalWindow = Math.ceil(n/2); 45 | /**karena kita hanya mengambil subarray size ganjil saja 46 | maka kita bulatkan ke atas, contoh kita punya array size 7, 47 | maka kemungkinan subarray size ganjil sebanyak 7/2 = 3.5 = 4 48 | 0. [1], [2], [3], [4], [5], [6], [7] ~ size 1 49 | 1. [1,2,3], [2,3,4], [3,4,5] , ... ~ size 3 50 | 2. [1,2,3,4,5], [2,3,4,5,6], [3,4,5,6,7] ~ size 5 51 | 3. [1,2,3,4,5,6,7] ~ size 7 52 | */ 53 | 54 | console.log(arr) // [ 1, 3, 6, 10, 15, 21, 28 ] 55 | //Algoritma sliding window sebanyak totalWindow 56 | for (let i = 0; i < totalWindow; i++) { 57 | let windowStart = i * 2; // Batas awal jendela 58 | let windowEnd = n; // Batas akhir jendela 59 | 60 | for (let j = windowStart; j < windowEnd; j++) { 61 | if (j - (i * 2) - 1 < 0) { 62 | // Jumlahkan elemen pada posisi j ke res 63 | res += arr[j]; 64 | } else { 65 | // Jumlahkan selisih elemen pada posisi j dan jendela sebelumnya ke res 66 | res += arr[j] - arr[j - (i * 2) - 1]; 67 | } 68 | } 69 | res 70 | } 71 | 72 | return res; 73 | }; 74 | 75 | // var sumOddLengthSubarrays = function(arr) { 76 | // let sum = 0, N = arr.length; 77 | // for (let i = 0; i < arr.length; i++) { 78 | // let total = i * (N-i) + (N-i); 79 | // total 80 | // sum += Math.ceil(total / 2) * arr[i]; 81 | // sum 82 | // } 83 | // return sum; 84 | // // T.C: O(N) 85 | // // S.C: O(1) 86 | // }; 87 | 88 | console.log(sumOddLengthSubarrays([1,2,3,4,5,6,7])); //176 89 | 90 | // console.log(sumOddLengthSubarrays([1,2,3,4,5,6,7])); //176 91 | -------------------------------------------------------------------------------- /stack/97.js: -------------------------------------------------------------------------------- 1 | // class Stack { 2 | // constructor() { 3 | // this.stack = []; 4 | // } 5 | 6 | // push(item) { 7 | // this.stack.push(item); 8 | // } 9 | 10 | // pop() { 11 | // if (this.isEmpty()) { 12 | // return -1; 13 | // } 14 | // return this.stack.pop(); 15 | // } 16 | 17 | // peek() { 18 | // return this.stack[this.stack.length - 1]; 19 | // } 20 | 21 | // isEmpty() { 22 | // return this.stack.length === 0; 23 | // } 24 | 25 | // join() { 26 | // return this.stack.join("/"); 27 | // } 28 | 29 | // size() { 30 | // return this.stack.length; 31 | // } 32 | // } 33 | 34 | // var isInterleave = function (s1, s2, s3) { 35 | // if (s1.length + s2.length !== s3.length) { 36 | // return false; 37 | // } 38 | 39 | // let stack1 = new Stack(); 40 | // for (let i = s1.length - 1; i >= 0; i--) { 41 | // stack1.push(s1[i]); 42 | // } 43 | // stack1; 44 | 45 | // let stack2 = new Stack(); 46 | // for (let i = s2.length - 1; i >= 0; i--) { 47 | // stack2.push(s2[i]); 48 | // } 49 | // stack2; 50 | 51 | // for (let i = 0; i < s3.length; i++) { 52 | // const element = s3[i]; 53 | // element; 54 | 55 | // if (!stack1.isEmpty() && stack1.peek() === element) { 56 | // stack1.pop(); 57 | // } else if (!stack2.isEmpty() && stack2.peek() === element) { 58 | // stack2.pop(); 59 | // } else { 60 | // return false; 61 | // } 62 | 63 | // return stack1.isEmpty() && stack2.isEmpty(); 64 | // } 65 | // }; 66 | 67 | class Stack { 68 | constructor() { 69 | this.stack = []; 70 | } 71 | 72 | push(item) { 73 | this.stack.push(item); 74 | } 75 | 76 | pop() { 77 | if (this.isEmpty()) { 78 | return -1; 79 | } 80 | return this.stack.pop(); 81 | } 82 | 83 | peek() { 84 | return this.stack[this.stack.length - 1]; 85 | } 86 | 87 | isEmpty() { 88 | return this.stack.length === 0; 89 | } 90 | 91 | join() { 92 | return this.stack.join("/"); 93 | } 94 | 95 | size() { 96 | return this.stack.length; 97 | } 98 | } 99 | 100 | var isInterleave = function (s1, s2, s3) { 101 | if (s1.length + s2.length !== s3.length) { 102 | return false; 103 | } 104 | 105 | const stack1 = new Stack(); 106 | for (let i = s1.length - 1; i >= 0; i--) { 107 | stack1.push(s1[i]); 108 | } 109 | 110 | const stack2 = new Stack(); 111 | for (let i = s2.length - 1; i >= 0; i--) { 112 | stack2.push(s2[i]); 113 | } 114 | 115 | for (let i = s3.length - 1; i >= 0; i--) { 116 | const element = s3[i]; 117 | 118 | if (!stack1.isEmpty() && stack1.peek() === element) { 119 | stack1.pop(); 120 | } else if (!stack2.isEmpty() && stack2.peek() === element) { 121 | stack2.pop(); 122 | } else { 123 | return false; 124 | } 125 | } 126 | 127 | return true; // If the loop finishes without returning false, it means interleaving is possible 128 | }; 129 | 130 | console.log(isInterleave("aabcc", "dbbca", "aadbbcbcac")); // Output: true 131 | 132 | -------------------------------------------------------------------------------- /stack/20.js: -------------------------------------------------------------------------------- 1 | class Stack { 2 | constructor() { 3 | this.stack = []; 4 | } 5 | 6 | push(item) { 7 | this.stack.push(item); 8 | } 9 | 10 | pop() { 11 | if (this.isEmpty()) { 12 | return "Stack kosong"; 13 | } 14 | return this.stack.pop(); 15 | } 16 | 17 | peek() { 18 | return this.stack[this.stack.length - 1]; 19 | } 20 | 21 | isEmpty() { 22 | return this.stack.length === 0; 23 | } 24 | } 25 | 26 | var isValid = function(s) { 27 | //base kondisi jika jumlah ganjil maka return false 28 | if (s.length % 2 !== 0) return false; 29 | 30 | const stack = new Stack(); 31 | const map = { 32 | '(': ')', 33 | '{': '}', 34 | '[': ']', 35 | }; 36 | 37 | s.split("").forEach((c) => { 38 | if (map[c]) { 39 | stack.push(c); 40 | } else { 41 | if (stack.isEmpty() || map[stack.peek()] !== c) { 42 | stack.push(c); 43 | } else { 44 | stack.pop(); 45 | } 46 | } 47 | }); 48 | 49 | return stack.isEmpty(); 50 | }; 51 | 52 | console.log(isValid("([}}])")); // false 53 | console.log(isValid("(){}[]")); // true 54 | console.log(isValid("([)]")); // false 55 | 56 | 57 | 58 | // var isValid = function (s) { 59 | // if(s.length % 2 !== 0) return false 60 | 61 | // const stack = new Stack(); 62 | 63 | // s.split("").forEach((c) => { 64 | // if(c === "(" || c === "{" || c === "["){ 65 | // stack.push(c) 66 | // } else if(c === ")" && !stack.isEmpty() && stack.peek() === "("){ 67 | // stack.pop() 68 | // } else if(c === "}" && !stack.isEmpty() && stack.peek() === "{"){ 69 | // stack.pop() 70 | // } else if(c === "]" && !stack.isEmpty() && stack.peek() === "["){ 71 | // stack.pop() 72 | // } else{ 73 | // stack.push(c) 74 | // } 75 | // }); 76 | 77 | // return stack.isEmpty(); 78 | // }; 79 | 80 | var isValid = function(s) { 81 | if (s.length % 2 !== 0) return false; 82 | 83 | const stack = new Stack(); 84 | const map = { 85 | '(': ')', 86 | '{': '}', 87 | '[': ']', 88 | }; 89 | 90 | s.split("").forEach((c) => { 91 | if (map[c]) { 92 | stack.push(c); 93 | } else { 94 | if (stack.isEmpty() || map[stack.peek()] !== c) { 95 | stack.push(c); 96 | } else { 97 | stack.pop(); 98 | } 99 | } 100 | }); 101 | 102 | return stack.isEmpty(); 103 | }; 104 | 105 | 106 | console.log(isValid("([}}])")); 107 | 108 | 109 | // // Jika hari adalah "Senin" sampai "Jumat", maka output adalah "Hari kerja" 110 | // // Jika hari adalah "Sabtu" atau "Minggu", maka output adalah "Hari libur" 111 | // const day = "Senin"; 112 | 113 | // if (day === "Senin" || day === "Selasa" || day === "Rabu" || day === "Kamis" || day === "Jumat") { 114 | // console.log("Hari kerja"); 115 | // } else if (day === "Sabtu" || day === "Minggu") { 116 | // console.log("Hari libur"); 117 | // } else { 118 | // console.log("Hari tidak valid"); 119 | // } 120 | 121 | 122 | // // Objek yang memetakan hari kerja dan hari libur 123 | // const dayMap = { 124 | // "Senin": "Hari kerja", 125 | // "Selasa": "Hari kerja", 126 | // "Rabu": "Hari kerja", 127 | // "Kamis": "Hari kerja", 128 | // "Jumat": "Hari kerja", 129 | // "Sabtu": "Hari libur", 130 | // "Minggu": "Hari libur" 131 | // }; 132 | 133 | // const day = "Senin"; 134 | 135 | // if (dayMap[day]) { 136 | // console.log(dayMap[day]); 137 | // } else { 138 | // console.log("Hari tidak valid"); 139 | // } 140 | --------------------------------------------------------------------------------