const findMult_3 = (num) => {
 const powerset = (set) => {
 const combinations = []
 const combine = (prefix, chars) => {
 for (let i = 0; i < chars.length; i++) {
 const newPrefix = parseInt(prefix + chars[i])
 if (!combinations.includes(newPrefix)) {
 combinations.push(newPrefix)
 } else {
 console.log('encountered duplicate')
 }
 combine(newPrefix, chars.filter((x, ind) => ind !== i))
 }
 }
 combine('', set)
 return combinations.sort((a, b) => a - b)
 }
 const allCombinations = powerset(num.toString().split(''))
 const factorsOfThree = allCombinations.filter(x => x % 3 === 0).filter(x => x !== 0)
 return [factorsOfThree.length, factorsOfThree.pop()]
}
findMult_3(43522283000229)

I'm working on this kata from Codewars. The task is:

Given a certain number, how many multiples of three could you obtain with its digits?

Supose that you have the number 362. The numbers that can be generated from it are:

362 → 3, 6, 2, 36, 63, 62, 26, 32, 23, 236, 263, 326, 362, 623, 632

I've written the following recursive function to calculate all possiblities:

const findMult_3 = (num) => {
 const powerset = (set) => {
 const combinations = []
 const combine = (prefix, chars) => {
 for (let i = 0; i < chars.length; i++) {
 const newPrefix = parseInt(prefix + chars[i])
 if (!combinations.includes(newPrefix)) {
 combinations.push(newPrefix)
 } else {
 console.log('encountered duplicate')
 }
 combine(newPrefix, chars.filter((x, ind) => ind !== i))
 }
 }
 combine('', set)
 return combinations.sort((a, b) => a - b)
 }
 const allCombinations = powerset(num.toString().split(''))
 const factorsOfThree = allCombinations.filter(x => x % 3 === 0).filter(x => x !== 0)
 return [factorsOfThree.length, factorsOfThree.pop()]
}
findMult_3(43522283000229)

I noticed early on that I encountered a lot of duplicate cases, hence the console.log('encountered duplicate') flag.

Execution of this algorithm is taking an extremely long time for large numbers, eg 43522283000229.

How can I improve the performance of this code? Or should it be scrapped entirely?

I'm working on this kata from Codewars. The task is:

Given a certain number, how many multiples of three could you obtain with its digits?

Supose that you have the number 362. The numbers that can be generated from it are:

362 → 3, 6, 2, 36, 63, 62, 26, 32, 23, 236, 263, 326, 362, 623, 632

I've written the following recursive function to calculate all possiblities:

const findMult_3 = (num) => {
 const powerset = (set) => {
 const combinations = []
 const combine = (prefix, chars) => {
 for (let i = 0; i < chars.length; i++) {
 const newPrefix = parseInt(prefix + chars[i])
 if (!combinations.includes(newPrefix)) {
 combinations.push(newPrefix)
 } else {
 console.log('encountered duplicate')
 }
 combine(newPrefix, chars.filter((x, ind) => ind !== i))
 }
 }
 combine('', set)
 return combinations.sort((a, b) => a - b)
 }
 const allCombinations = powerset(num.toString().split(''))
 const factorsOfThree = allCombinations.filter(x => x % 3 === 0).filter(x => x !== 0)
 return [factorsOfThree.length, factorsOfThree.pop()]
}
findMult_3(43522283000229)

I noticed early on that I encountered a lot of duplicate cases, hence the console.log('encountered duplicate') flag.

Execution of this algorithm is taking an extremely long time for large numbers, eg 43522283000229.

How can I improve the performance of this code? Or should it be scrapped entirely?

const findMult_3 = (num) => {
 const powerset = (set) => {
 const combinations = []
 const combine = (prefix, chars) => {
 for (let i = 0; i < chars.length; i++) {
 const newPrefix = parseInt(prefix + chars[i])
 if (!combinations.includes(newPrefix)) {
 combinations.push(newPrefix)
 } else {
 console.log('encountered duplicate')
 }
 combine(newPrefix, chars.filter((x, ind) => ind !== i))
 }
 }
 combine('', set)
 return combinations.sort((a, b) => a - b)
 }
 const allCombinations = powerset(num.toString().split(''))
 const factorsOfThree = allCombinations.filter(x => x % 3 === 0).filter(x => x !== 0)
 return [factorsOfThree.length, factorsOfThree.pop()]
}
findMult_3(43522283000229)

I'm working on this kata from Codewars. The task is:

Given a certain number, how many multiples of three could you obtain with its digits?

Supose that you have the number 362. The numbers that can be generated from it are:

362 ----> 3, 6, 2, 36, 63, 62, 26, 32, 23, 236, 263, 326, 362, 623, 632

I've written the following recursive function to calculate all possiblities:

const findMult_3 = (num) => {
 const powerset = (set) => {
 const combinations = []
 const combine = (prefix, chars) => {
 for (let i = 0; i < chars.length; i++) {
 const newPrefix = parseInt(prefix + chars[i])
 if (!combinations.includes(newPrefix)) {
 combinations.push(newPrefix)
 } else {
 console.log('encountered duplicate')
 }
 combine(newPrefix, chars.filter((x, ind) => ind !== i))
 }
 }
 combine('', set)
 return combinations.sort((a, b) => a - b)
 }
 const allCombinations = powerset(num.toString().split(''))
 const factorsOfThree = allCombinations.filter(x => x % 3 === 0).filter(x => x !== 0)
 return [factorsOfThree.length, factorsOfThree.pop()]
}
findMult_3(43522283000229)

I noticed early on that I encountered a lot of duplicate cases, hence the console.log('encountered duplicate') flag.

Execution of this algorithm is taking an extremely long time for large numbers, eg 43522283000229.

How can I improve the performance of this code? Or should it be scrapped entirely?

I'm working on this kata from Codewars. The task is:

Given a certain number, how many multiples of three could you obtain with its digits?

Supose that you have the number 362. The numbers that can be generated from it are:

362 → 3, 6, 2, 36, 63, 62, 26, 32, 23, 236, 263, 326, 362, 623, 632

I've written the following recursive function to calculate all possiblities:

const findMult_3 = (num) => {
 const powerset = (set) => {
 const combinations = []
 const combine = (prefix, chars) => {
 for (let i = 0; i < chars.length; i++) {
 const newPrefix = parseInt(prefix + chars[i])
 if (!combinations.includes(newPrefix)) {
 combinations.push(newPrefix)
 } else {
 console.log('encountered duplicate')
 }
 combine(newPrefix, chars.filter((x, ind) => ind !== i))
 }
 }
 combine('', set)
 return combinations.sort((a, b) => a - b)
 }
 const allCombinations = powerset(num.toString().split(''))
 const factorsOfThree = allCombinations.filter(x => x % 3 === 0).filter(x => x !== 0)
 return [factorsOfThree.length, factorsOfThree.pop()]
}
findMult_3(43522283000229)

I noticed early on that I encountered a lot of duplicate cases, hence the console.log('encountered duplicate') flag.

Execution of this algorithm is taking an extremely long time for large numbers, eg 43522283000229.

How can I improve the performance of this code? Or should it be scrapped entirely?

const findMult_3 = (num) => {
 const powerset = (set) => {
 const combinations = []
 const combine = (prefix, chars) => {
 for (let i = 0; i < chars.length; i++) {
 const newPrefix = parseInt(prefix + chars[i])
 if (!combinations.includes(newPrefix)) {
 combinations.push(newPrefix)
 } else {
 console.log('encountered duplicate')
 }
 combine(newPrefix, chars.filter((x, ind) => ind !== i))
 }
 }
 combine('', set)
 return combinations.sort((a, b) => a - b)
 }
 const allCombinations = powerset(num.toString().split(''))
 const factorsOfThree = allCombinations.filter(x => x % 3 === 0).filter(x => x !== 0)
 return [factorsOfThree.length, factorsOfThree.pop()]
}
findMult_3(43522283000229)

I'm working on this kata from Codewars. The task is:

Given a certain number, how many multiples of three could you obtain with its digits?

Supose that you have the number 362. The numbers that can be generated from it are:

362 ----> 3, 6, 2, 36, 63, 62, 26, 32, 23, 236, 263, 326, 362, 623, 632

I've written the following recursive function to calculate all possiblities:

const findMult_3 = (num) => {
 const powerset = (set) => {
 const combinations = []
 const combine = (prefix, chars) => {
 for (let i = 0; i < chars.length; i++) {
 const newPrefix = parseInt(prefix + chars[i])
 if (!combinations.includes(newPrefix)) {
 combinations.push(newPrefix)
 } else {
 console.log('encountered duplicate')
 }
 combine(newPrefix, chars.filter((x, ind) => ind !== i))
 }
 }
 combine('', set)
 return combinations.sort((a, b) => a - b)
 }
 const allCombinations = powerset(num.toString().split(''))
 const factorsOfThree = allCombinations.filter(x => x % 3 === 0).filter(x => x !== 0)
 return [factorsOfThree.length, factorsOfThree.pop()]
}
findMult_3(43522283000229)

I noticed early on that I was encountered a lot of duplicate cases, hence the console.log('encountered duplicate') flag.

Execution of this algorithm is taking an extremely long time for large numbers, eg 43522283000229.

How can I improve the performance of this code, or should it be scrapped entirely?

I'm working on this kata from Codewars. The task is:

Given a certain number, how many multiples of three could you obtain with its digits?

Supose that you have the number 362. The numbers that can be generated from it are:

362 ----> 3, 6, 2, 36, 63, 62, 26, 32, 23, 236, 263, 326, 362, 623, 632

I've written the following recursive function to calculate all possiblities:

const findMult_3 = (num) => {
 const powerset = (set) => {
 const combinations = []
 const combine = (prefix, chars) => {
 for (let i = 0; i < chars.length; i++) {
 const newPrefix = parseInt(prefix + chars[i])
 if (!combinations.includes(newPrefix)) {
 combinations.push(newPrefix)
 } else {
 console.log('encountered duplicate')
 }
 combine(newPrefix, chars.filter((x, ind) => ind !== i))
 }
 }
 combine('', set)
 return combinations.sort((a, b) => a - b)
 }
 const allCombinations = powerset(num.toString().split(''))
 const factorsOfThree = allCombinations.filter(x => x % 3 === 0).filter(x => x !== 0)
 return [factorsOfThree.length, factorsOfThree.pop()]
}
findMult_3(43522283000229)

I noticed early on that I encountered a lot of duplicate cases, hence the console.log('encountered duplicate') flag.

Execution of this algorithm is taking an extremely long time for large numbers, eg 43522283000229.

How can I improve the performance of this code? Or should it be scrapped entirely?