-1

For the below problem:

A subsequence of a number is a series of (not necessarily contiguous) digits of the number. For example, 12345 has subsequences that include 123, 234, 124, 245, etc. Your task is to generate subsequence below a certain length.

def generate_subseq(n, m):
    """
    Print all subsequence of length at most m that can be found in the given number n.
    For example, for n = 20125 and m = 3, we have that the subsequences are
        201
        202
        205
        212
        215
        225
        012
        015
        025
        125
   

    >>> generate_subseq(20125, 3)
        201
        202
        205
        212
        215
        225
        012
        015
        025
        125
     >>> generate_subseq(20125, 5)
        20125
    """

Below is the non-working solution :

package main

import (
    "fmt"
    "strconv"
)

func generateSubSequence(n int, subSequenceSize int) []int {

    digitSequence := intToSequenceOfDigits(n) // [2,0,1,2,5]

    var f func([]int, int, int) []int
    f = func(digitSequence []int, pickingIndex int, currentSubSequenceSize int) []int {

        if pickingIndex+1 == currentSubSequenceSize {
            value := sequenceOfDigitsToInt(digitSequence[0:currentSubSequenceSize])
            return []int{value}
        }

        if currentSubSequenceSize == 0 {
            return []int{}
        }

        digit := digitSequence[pickingIndex]

        withM := mapDigit(f(digitSequence, pickingIndex-1, currentSubSequenceSize-1), digit)
        withoutM := f(digitSequence, pickingIndex-1, currentSubSequenceSize)

        return append(withM, withoutM...)
    }

    return f(digitSequence, len(digitSequence)-1, subSequenceSize)
}

func mapDigit(slice []int, digit int) []int {
    result := make([]int, len(slice))
    for i, value := range slice {
        result[i] = value*10 + digit
    }
    return result
}

func sequenceOfDigitsToInt(digits []int) int {
    result := 0
    for _, value := range digits {
        result = result*10 + value
    }
    return result
}

func intToSequenceOfDigits(n int) []int { // [2,0,1,2,5]
    var convert func(int) []int
    sequence := []int{}
    convert = func(n int) []int {
        if n != 0 {
            digit := n % 10
            sequence = append([]int{digit}, sequence...)
            convert(n / 10)
        }
        return sequence
    }
    return convert(n)
}


func main() {
    fmt.Println(generateSubSequence(20125, 3))
}

Actual output is: [225 215 205 212 202 201]

Expected output is: [201 202 205 212 215 225 012 015 025 125]

Why the actual output is missing some subsequences? like 125 etc...

overexchange
  • 15,768
  • 30
  • 152
  • 347
  • Hint: you get a subsequence of length m by choosing the first digit and then a subsequence of length m-1 from the digits right of it. – Henry Aug 24 '20 at 04:52
  • You can use set bits of numbers in binary representation to get the subsequences as well. – nice_dev Aug 24 '20 at 06:49
  • Problem is not stated clearly. The first example shows combinations with all lengths, but second example - only combinations of length 3. Also example says ` maxumum number is 225, so our answer is 225` while question does not mention max value. – MBo Aug 24 '20 at 08:48
  • @MBo Query edited with appropriate details – overexchange Aug 24 '20 at 15:22

1 Answers1

1

Something like this? Modifying my other answer:

function f(s, i, l){
  if (i + 1 == l)
    return [s.substr(0, l)];

  if (!l)
    return [''];
    
  const left = f(s, i - 1, l);
  const right = f(s, i - 1, l - 1);

  return left.concat(
    right.map(x => x + s[i]));
}

var input = [
  ['20125', 3],
  ['12345', 3]
];

for (let [s, l] of input){
  console.log(s + ', l: ' + l);
  console.log(JSON.stringify(f(s, s.length-1, l)));
  console.log('');
}
גלעד ברקן
  • 23,602
  • 3
  • 25
  • 61