API tools faq
paste
Advertisement
samimwebdev

problem -solving-leetcode-1

samimwebdev
Jun 24th, 2022
214
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 12.03 KB | None | 0 0
raw download clone embed print report
  1. // function findLongestSubstring(str){
  2.  
  3. //   if(!str) return 0
  4.  
  5. //   let j = 0
  6. //   let charSet = new Set()
  7. //   let total = 1
  8.  
  9. //   for (let i = 0; i < str.length; i++) {
  10.  
  11. //     let char = str[i]
  12.  
  13. //      while(charSet.has(char)){
  14.  
  15. //        charSet.delete(str[j])
  16. //        j++
  17.  
  18. //      }
  19.  
  20. //       charSet.add(char)
  21. //       console.log(charSet)
  22.  
  23. //      total = Math.max(total, charSet.size)
  24.  
  25. //   }
  26.  
  27. //  console.log({total})
  28.  
  29. // var uniqueOccurrences = function (arr) {
  30. //     const hashMap = {}
  31. //     for (let i = 0; i < arr.length; i++) {
  32. //       hashMap[arr[i]] = (hashMap[arr[i]] || 0) + 1
  33. //     }
  34. //     const uniqueValues = new Set(Object.values(hashMap))
  35. //     console.log(uniqueValues.size === Object.values(hashMap).length)
  36. //   }
  37.  
  38. //   uniqueOccurrences([-3, 0, 1, -3, 1, 1, 1, -3, 10, 0])
  39.  
  40. //finding firstUnique character index
  41.  
  42. // var firstUniqChar = function (s) {
  43. //   for (let i = 0; i < s.length; i++) {
  44. //     let found = true
  45. //     for (let j = i + 1; j < s.length; j++) {
  46. //       if (s[i] === s[j]) {
  47. //         found = false
  48. //         break
  49. //       }
  50. //     }
  51. //     if (found) {
  52. //       return i
  53. //     }
  54. //   }
  55. //   return -1
  56. // }
  57. // var firstUniqChar = function (s) {
  58. //   const hashMap = {}
  59. //   for (let i = 0; i < s.length; i++) {
  60. //     hashMap[s[i]] = (hashMap[s[i]] || 0) + 1
  61. //   }
  62.  
  63. //   for (let i = 0; i < s.length; i++) {
  64. //     if (hashMap[s[i]] === 1) {
  65. //       return i
  66. //     }
  67. //   }
  68. //   return -1
  69. //   console.log(hashMap)
  70. // }
  71.  
  72. // console.log(firstUniqChar('leetcode'))
  73. // console.log(firstUniqChar('loveleetcode'))
  74. // console.log(firstUniqChar('aabb'))
  75.  
  76. //unique number of occurrences
  77.  
  78. // var uniqueOccurrences = function (arr) {
  79. //     const hashMap = {}
  80. //     for (let i = 0; i < arr.length; i++) {
  81. //       hashMap[arr[i]] = (hashMap[arr[i]] || 0) + 1
  82. //     }
  83. //     const uniqueValues = new Set(Object.values(hashMap))
  84. //    return uniqueValues.size === Object.values(hashMap).length
  85. //   }
  86.  
  87. //anagram
  88.  
  89. //finding all duplicates in a array
  90. // var findDuplicates = function(nums) {
  91. //     const outputArr = []
  92. //     for(let i = 0; i < nums.length; i++){
  93. //        const index =  Math.abs(nums[i]) - 1
  94. //        if(nums[index] < 0 ){
  95. //            outputArr.push(index + 1)
  96. //        }else{
  97. //            nums[index] = -nums[index]
  98. //        }
  99. //     }
  100.  
  101. //     return outputArr
  102.  
  103. // };
  104.  
  105. //sum zero problem
  106.  
  107. // let left = 0
  108. //   let right = arr.length - 1
  109. //   while (left < right) {
  110. //     let sum = arr[left] + arr[right]
  111. //     if (sum === 0) {
  112. //       return [arr[left], arr[right]]
  113. //     } else if (sum < 0) {
  114. //       left++
  115. //     } else {
  116. //       right--
  117. //     }
  118. //   }
  119.  
  120. //1304- Find Unique integers sum up to zero
  121.  
  122. // const sumZero = (n) => {
  123. //   const arr = []
  124. //   if (n === 1) {
  125. //     return [0]
  126. //   }
  127. //   if (n % 2 !== 0) {
  128. //     arr.push(0)
  129. //   }
  130. //   for (let i = 1; i <= n / 2; i++) {
  131. //     console.log(i)
  132. //     arr.push(i, -i)
  133. //   }
  134. //   return arr
  135. // }
  136.  
  137. // sumZero(5)
  138.  
  139. // // [1, -1, 2, -2]
  140.  
  141. // var subarraySum = function (nums, k) {
  142. //   const hashMap = {
  143. //     0: 1,
  144. //   }
  145. //   let result = 0
  146. //   let sum = 0
  147. //   for (let i = 0; i < nums.length; i++) {
  148. //     sum += nums[i]
  149. //     console.log(sum - k)
  150. //     if (hashMap[sum - k] in hashMap) {
  151. //       result += hashMap[sum - k]
  152. //     }
  153. //     hashMap[sum] = (hashMap[sum] || 0) + 1
  154. //   }
  155. //   console.log(result)
  156. //   console.log(hashMap)
  157. // }
  158.  
  159. // subarraySum([1, 2, 3], 3)
  160.  
  161. // var findDuplicates = function (nums) {
  162. //   let outputArr = []
  163. //   for (let i = 0; i < nums.length; i++) {
  164. //     const index = Math.abs(nums[i]) - 1
  165. //     if (nums[index] < 0) {
  166. //       outputArr.push(index + 1)
  167. //     } else {
  168. //       nums[index] = -nums[index]
  169. //     }
  170. //   }
  171.  
  172. //   return outputArr
  173. // }
  174.  
  175. // var lengthOfLongestSubstring = function (s) {
  176. //   let i = 0
  177. //   let j = 0
  178. //   let max = 0
  179. //   const uniqueCharSet = new Set()
  180. //   while (j < s.length) {
  181. //     if (!uniqueCharSet.has(s[j])) {
  182. //       uniqueCharSet.add(s[j])
  183. //       max = Math.max(max, uniqueCharSet.size)
  184. //       j++
  185. //     } else {
  186. //       uniqueCharSet.delete(s[i])
  187. //       i++
  188. //     }
  189. //     console.log(uniqueCharSet)
  190. //   }
  191. //   console.log(max)
  192. //   return max
  193. // }
  194.  
  195. // lengthOfLongestSubstring('abcabcbb')
  196.  
  197. // var maxSubArray = function (nums) {
  198. //   let current_sum = nums[0]
  199. //   let max_sum = current_sum
  200. //   for (let i = 1; i < nums.length; i++) {
  201. //     console.log(current_sum, nums[i], current_sum + nums[i], max_sum)
  202. //     current_sum = Math.max(current_sum + nums[i], nums[i])
  203. //     max_sum = Math.max(current_sum, max_sum)
  204. //   }
  205. //   console.log(max_sum)
  206. //   // return max_sum
  207. // }
  208.  
  209. // maxSubArray([-2, 1, -3, 4, -1, 2, 1, -5, 4])
  210. // maxSubArray([5, 4, -1, 7, 8])
  211.  
  212. // function palindrome(str) {
  213. //   let left = 0
  214. //   let right = str.length - 1
  215. //   while (left < right) {
  216. //     console.log(str[left], str[right])
  217. //     if (str[left] !== str[right]) return false
  218. //     left++
  219. //     right--
  220. //   }
  221. //   return true
  222. // }
  223.  
  224. // console.log(palindrome('raceecar'))
  225.  
  226. var isPalindrome = function (s) {
  227.   const normalizeStr = s.replace(/[\W_]/g, '').toLowerCase()
  228.   let left = 0
  229.   let right = normalizeStr.length - 1
  230.  
  231.   while (left < right) {
  232.     console.log(normalizeStr[left], normalizeStr[right])
  233.     if (normalizeStr[left] !== normalizeStr[right]) return false
  234.     left++
  235.     right--
  236.   }
  237.   return true
  238. }
  239.  
  240. console.log(isPalindrome('A man, a plan, a canal: Panama'))
  241.  
  242. // var isAnagram = function (s, t) {
  243. //   const hashTableS = {}
  244. //   const hashTableT = {}
  245. //   for (let elm of s) {
  246. //     hashTableS[elm] = (hashTableS[elm] || 0) + 1
  247. //   }
  248. //   for (let elm of t) {
  249. //     hashTableT[elm] = (hashTableT[elm] || 0) + 1
  250. //   }
  251.  
  252. //   if (Object.keys(hashTableS).length !== Object.keys(hashTableT).length)
  253. //     return false
  254. //   for (let char in hashTableS) {
  255. //     if (hashTableS[char] !== hashTableT[char]) return false
  256. //   }
  257. //   return true
  258.  
  259. // }
  260.  
  261. // console.log(isAnagram('anagram', 'nagaram'))
  262.  
  263. //Group Anagram
  264. // var groupAnagrams = function (strs) {
  265. //   const ht = {}
  266. //   for (elm of strs) {
  267. //     const sorted = elm.split('').sort().join('')
  268. //     if (ht[sorted]) {
  269. //       ht[sorted].push(elm)
  270. //     } else {
  271. //       ht[sorted] = [elm]
  272. //     }
  273. //   }
  274.  
  275. //   return Object.values(ht)
  276. //   console.log(ht)
  277. // }
  278.  
  279. // console.log(groupAnagrams(['eat', 'tea', 'tan', 'ate', 'nat', 'bat']))
  280.  
  281. // function maxSubarraySum(nums, k) {
  282. //   if (k > nums.length) {
  283. //     return null
  284. //   }
  285. //   var max = -Infinity
  286. //   for (let i = 0; i < nums.length - k + 1; i++) {
  287. //     temp = 0
  288.  
  289. //     for (let j = 0; j < k; j++) {
  290. //       temp += nums[i + j]
  291. //     }
  292. //     if (temp > max) {
  293. //       max = temp
  294. //     }
  295. //   }
  296. //   return max
  297. // }
  298.  
  299. // function maxSubarraySum(arr, num) {
  300. //   let maxSum = 0
  301. //   let tempSum = 0
  302. //   if (arr.length < num) return null
  303. //   for (let i = 0; i < num; i++) {
  304. //     maxSum += arr[i]
  305. //   }
  306. //   tempSum = maxSum
  307. //   for (let i = num; i < arr.length; i++) {
  308. //     tempSum = tempSum - arr[i - num] + arr[i]
  309. //     maxSum = Math.max(maxSum, tempSum)
  310. //   }
  311. //   return maxSum
  312. // }
  313. // console.log(maxSubarraySum([1, 2, 3, 4], 2))
  314.  
  315. // var minSubArrayLen = function (target, nums) {
  316. //   let result = Infinity
  317. //   let left = 0
  318. //   let val_sum = 0
  319.  
  320. //   for (let i = 0; i < nums.length; i++) {
  321. //     val_sum += nums[i]
  322.  
  323. //     console.log(val_sum, i + 1 - nums[i])
  324. //     while (val_sum >= target) {
  325. //       result = Math.min(result, i + 1 - left)
  326. //       console.log(result)
  327. //       val_sum -= nums[left]
  328. //       left++
  329. //     }
  330. //   }
  331.  
  332. //   return result !== Infinity ? result : 0
  333. // }
  334.  
  335. // nums = [1,1,1], k = 2
  336. var subarraySum = function (nums, k) {
  337.   const hash = {
  338.     0: 1,
  339.   }
  340.   let sum = 0
  341.   let result = 0
  342.   for (let elm of nums) {
  343.     sum += elm
  344.     console.log(sum, sum - k)
  345.     if ([sum - k] in hash) {
  346.       console.log(true)
  347.       result += hash[sum - k]
  348.     }
  349.     hash[sum] = (hash[sum] || 0) + 1
  350.   }
  351.   console.log(hash, result)
  352.   return result
  353. }
  354.  
  355. subarraySum([1, -1, 0], 0)
  356.  
  357. // --- Directions
  358. // Write a function that accepts a positive number N.
  359. // The function should console log a step shape
  360. // with N levels using the # character.  Make sure the
  361. // step has spaces on the right hand side!
  362. // --- Examples
  363. //   steps(2)
  364. //       '# '
  365. //       '##'
  366. //   steps(3)
  367. //       '#  '
  368. //       '## '
  369. //       '###'
  370. //   steps(4)
  371. //       '#   '
  372. //       '##  '
  373. //       '### '
  374. //       '####'
  375.  
  376. // function steps(n) {
  377. //   for (let row = 0; row < n; row++) {
  378. //     let stair = ''
  379. //     for (let column = 0; column < n; column++) {
  380. //       if (column <= row) {
  381. //         stair += '#'
  382. //       } else {
  383. //         stair += ' '
  384. //       }
  385. //     }
  386. //     console.log(stair)
  387. //   }
  388. // }
  389.  
  390. //recursive solution
  391. function steps(n, row = 0, stair = '') {
  392.   if (row === n) {
  393.     return
  394.   }
  395.   if (stair.length === n) {
  396.     console.log(stair)
  397.     return steps(n, row + 1)
  398.   }
  399.  
  400.   const add = stair.length <= row ? '#' : ' '
  401.   steps(n, row, stair + add)
  402.   //   console.log(stair)
  403. }
  404. console.log(steps(3))
  405.  
  406. // --- Directions
  407. // Write a function that accepts a positive number N.
  408. // The function should console log a pyramid shape
  409. // with N levels using the # character.  Make sure the
  410. // pyramid has spaces on both the left *and* right hand sides
  411. // --- Examples
  412. //   pyramid(1)
  413. //       '#'
  414. //   pyramid(2)
  415. //       ' # '
  416. //       '###'
  417. //   pyramid(3)
  418. //       '  #  '
  419. //       ' ### '
  420. //       '#####'
  421.  
  422. // function pyramid(n) {
  423. //   //midpoint of proposed column
  424. //   const midPoint = Math.floor((2 * n - 1) / 2)
  425. //   for (let row = 0; row < n; row++) {
  426. //     let level = ''
  427. //     for (let column = 0; column < 2 * n - 1; column++) {
  428. //       if (midPoint - row <= column && midPoint + row >= column) {
  429. //         level += '#'
  430. //       } else {
  431. //         level += ' '
  432. //       }
  433. //     }
  434. //     console.log(level)
  435. //   }
  436. //   console.log(midPoint)
  437. // }
  438.  
  439. //recursive solution
  440. function pyramid(n, row = 0, level = '') {
  441.   if (row == n) return
  442.   if (level.length === 2 * n - 1) {
  443.     console.log(level)
  444.     return pyramid(n, row + 1)
  445.   }
  446.   const midpoint = Math.floor((2 * (n - 1)) / 2)
  447.   let add = ''
  448.   if (midpoint - row <= level.length && midpoint + row >= level.length) {
  449.     add += '#'
  450.   } else {
  451.     add += ' '
  452.   }
  453.   pyramid(n, row, level + add)
  454. }
  455.  
  456. pyramid(3)
  457.  
  458. // --- Directions
  459. // Write a function that accepts an integer N
  460. // and returns a NxN spiral matrix.
  461. // --- Examples
  462. //   matrix(2)
  463. //     [[undefined, undefined],
  464. //     [undefined, undefined]]
  465. //   matrix(3)
  466. //     [[1, 2, 3],
  467. //     [8, 9, 4],
  468. //     [7, 6, 5]]
  469. //  matrix(4)
  470. //     [[1,   2,  3, 4],
  471. //     [12, 13, 14, 5],
  472. //     [11, 16, 15, 6],
  473. //     [10,  9,  8, 7]]
  474.  
  475. function matrix(n) {
  476.   const results = []
  477.   for (let i = 0; i < n; i++) {
  478.     results.push([])
  479.   }
  480.   let counter = 1
  481.   let startColumn = 0
  482.   let endColumn = n - 1
  483.   let startRow = 0
  484.   let endRow = n - 1
  485.   while (startColumn <= endColumn && startRow <= endRow) {
  486.     //top row
  487.     for (let i = startColumn; i <= endColumn; i++) {
  488.       results[startRow][i] = counter
  489.       counter++
  490.     }
  491.     startRow++
  492.  
  493.     //right column
  494.     for (let i = startRow; i <= endRow; i++) {
  495.       results[i][endColumn] = counter
  496.       counter++
  497.     }
  498.     endColumn--
  499.     console.log(endColumn)
  500.  
  501.     //Bottom row
  502.     for (let i = endColumn; i >= startColumn; i--) {
  503.       results[endRow][i] = counter
  504.       counter++
  505.     }
  506.     endRow--
  507.     console.log(endRow)
  508.     //start column
  509.     for (let i = endRow; i >= startRow; i--) {
  510.       results[i][startColumn] = counter
  511.       counter++
  512.     }
  513.  
  514.     startColumn++
  515.     // if (startColumn === endColumn && startRow === endRow) {
  516.     //   results[startColumn][startRow] = counter
  517.     // }
  518.     console.log(startColumn, endColumn, startRow, endRow)
  519.   }
  520.  
  521.   console.log(results)
  522. }
  523.  
  524. matrix(4)
  525.  
  526.  
  527. // log₂⁸ = 3 // 2³
  528.  //2  * 2 * 2
  529.  
  530.  
  531.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!