JavaScript/String/PermutateString.js at master · Guduly/JavaScript · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
'use strict'

constpermutate=(aString)=>{
if(typeofaString!=='string'||!aString){
thrownewError('The arg must be a valid, non empty string')
}
constcharacters=aString.split('')
letpermutations=[[characters.shift()]]
while(characters.length){
constcurrentCharacter=characters.shift()
permutations=calculateCurrentCharacterPermutation(permutations,currentCharacter)
}
returnpermutations
.map(character=>character.join(''))
.filter((item,index,self)=>(self.indexOf(item)===index))
.sort()
}

constcalculateCurrentCharacterPermutation=(allPermutations,currentCharacter)=>{
constcurrentPermutations=[]
allPermutations.forEach(permutation=>{
letindex=0
while(index<=permutation.length){
consttmp=[...permutation]
tmp.splice(index,0,currentCharacter)
currentPermutations.push(tmp)
index++
}
})
returncurrentPermutations
}

export{permutate}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
'use strict'

constpermutate=(aString)=>{
if(typeofaString!=='string'||!aString){
thrownewError('The arg must be a valid, non empty string')
}
constcharacters=aString.split('')
letpermutations=[[characters.shift()]]
while(characters.length){
constcurrentCharacter=characters.shift()
permutations=calculateCurrentCharacterPermutation(permutations,currentCharacter)
}
returnpermutations
.map(character=>character.join(''))
.filter((item,index,self)=>(self.indexOf(item)===index))
.sort()
}

constcalculateCurrentCharacterPermutation=(allPermutations,currentCharacter)=>{
constcurrentPermutations=[]
allPermutations.forEach(permutation=>{
letindex=0
while(index<=permutation.length){
consttmp=[...permutation]
tmp.splice(index,0,currentCharacter)
currentPermutations.push(tmp)
index++
}
})
returncurrentPermutations
}

export{permutate}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
'use strict'

constpermutate=(aString)=>{
if(typeofaString!=='string'||!aString){
thrownewError('The arg must be a valid, non empty string')
}
constcharacters=aString.split('')
letpermutations=[[characters.shift()]]
while(characters.length){
constcurrentCharacter=characters.shift()
permutations=calculateCurrentCharacterPermutation(permutations,currentCharacter)
}
returnpermutations
.map(character=>character.join(''))
.filter((item,index,self)=>(self.indexOf(item)===index))
.sort()
}

constcalculateCurrentCharacterPermutation=(allPermutations,currentCharacter)=>{
constcurrentPermutations=[]
allPermutations.forEach(permutation=>{
letindex=0
while(index<=permutation.length){
consttmp=[...permutation]
tmp.splice(index,0,currentCharacter)
currentPermutations.push(tmp)
index++
}
})
returncurrentPermutations
}

export{permutate}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
'use strict'

constpermutate=(aString)=>{
if(typeofaString!=='string'||!aString){
thrownewError('The arg must be a valid, non empty string')
}
constcharacters=aString.split('')
letpermutations=[[characters.shift()]]
while(characters.length){
constcurrentCharacter=characters.shift()
permutations=calculateCurrentCharacterPermutation(permutations,currentCharacter)
}
returnpermutations
.map(character=>character.join(''))
.filter((item,index,self)=>(self.indexOf(item)===index))
.sort()
}

constcalculateCurrentCharacterPermutation=(allPermutations,currentCharacter)=>{
constcurrentPermutations=[]
allPermutations.forEach(permutation=>{
letindex=0
while(index<=permutation.length){
consttmp=[...permutation]
tmp.splice(index,0,currentCharacter)
currentPermutations.push(tmp)
index++
}
})
returncurrentPermutations
}

export{permutate}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
'use strict'

constpermutate=(aString)=>{
if(typeofaString!=='string'||!aString){
thrownewError('The arg must be a valid, non empty string')
}
constcharacters=aString.split('')
letpermutations=[[characters.shift()]]
while(characters.length){
constcurrentCharacter=characters.shift()
permutations=calculateCurrentCharacterPermutation(permutations,currentCharacter)
}
returnpermutations
.map(character=>character.join(''))
.filter((item,index,self)=>(self.indexOf(item)===index))
.sort()
}

constcalculateCurrentCharacterPermutation=(allPermutations,currentCharacter)=>{
constcurrentPermutations=[]
allPermutations.forEach(permutation=>{
letindex=0
while(index<=permutation.length){
consttmp=[...permutation]
tmp.splice(index,0,currentCharacter)
currentPermutations.push(tmp)
index++
}
})
returncurrentPermutations
}

export{permutate}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
'use strict'

constpermutate=(aString)=>{
if(typeofaString!=='string'||!aString){
thrownewError('The arg must be a valid, non empty string')
}
constcharacters=aString.split('')
letpermutations=[[characters.shift()]]
while(characters.length){
constcurrentCharacter=characters.shift()
permutations=calculateCurrentCharacterPermutation(permutations,currentCharacter)
}
returnpermutations
.map(character=>character.join(''))
.filter((item,index,self)=>(self.indexOf(item)===index))
.sort()
}

constcalculateCurrentCharacterPermutation=(allPermutations,currentCharacter)=>{
constcurrentPermutations=[]
allPermutations.forEach(permutation=>{
letindex=0
while(index<=permutation.length){
consttmp=[...permutation]
tmp.splice(index,0,currentCharacter)
currentPermutations.push(tmp)
index++
}
})
returncurrentPermutations
}

export{permutate}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
'use strict'

constpermutate=(aString)=>{
if(typeofaString!=='string'||!aString){
thrownewError('The arg must be a valid, non empty string')
}
constcharacters=aString.split('')
letpermutations=[[characters.shift()]]
while(characters.length){
constcurrentCharacter=characters.shift()
permutations=calculateCurrentCharacterPermutation(permutations,currentCharacter)
}
returnpermutations
.map(character=>character.join(''))
.filter((item,index,self)=>(self.indexOf(item)===index))
.sort()
}

constcalculateCurrentCharacterPermutation=(allPermutations,currentCharacter)=>{
constcurrentPermutations=[]
allPermutations.forEach(permutation=>{
letindex=0
while(index<=permutation.length){
consttmp=[...permutation]
tmp.splice(index,0,currentCharacter)
currentPermutations.push(tmp)
index++
}
})
returncurrentPermutations
}

export{permutate}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
'use strict'

constpermutate=(aString)=>{
if(typeofaString!=='string'||!aString){
thrownewError('The arg must be a valid, non empty string')
}
constcharacters=aString.split('')
letpermutations=[[characters.shift()]]
while(characters.length){
constcurrentCharacter=characters.shift()
permutations=calculateCurrentCharacterPermutation(permutations,currentCharacter)
}
returnpermutations
.map(character=>character.join(''))
.filter((item,index,self)=>(self.indexOf(item)===index))
.sort()
}

constcalculateCurrentCharacterPermutation=(allPermutations,currentCharacter)=>{
constcurrentPermutations=[]
allPermutations.forEach(permutation=>{
letindex=0
while(index<=permutation.length){
consttmp=[...permutation]
tmp.splice(index,0,currentCharacter)
currentPermutations.push(tmp)
index++
}
})
returncurrentPermutations
}

export{permutate}