Sam and substrings Discussions | Algorithms | HackerRank
We use cookies to ensure you have the best browsing experience on our website. Please read our cookie policy for more information about how we use cookies.
  1. Prepare
  2. Algorithms
  3. Dynamic Programming
  4. Sam and substrings
  5. Discussions

Sam and substrings

Sort by

recency

|

206 Discussions

|

  • vishnubabu94in
     + 0 comments

    js

    const mod = BigInt(10 ** 9 + 7);
const zero = BigInt(0);
const one = BigInt(1);
const ten = BigInt(10);
function substrings(n) {
    const len = BigInt(n.length);
    let sum = zero;
    let f1 = one;
    let f2 = ten;
    for (let i = len - one; i >= zero; i--) {
        [sum, f1, f2] = [
            (sum + BigInt(n[i]) * (i + one) * f1) % mod,
            (f1 + f2) % mod,
            (f2 * ten) % mod
        ];
    }

    return sum;
}

  • dehaka
     + 0 comments
    long substrings(string s) {
    long total = 0, endRight = 0, mod = 1000000007;
    for (int i=0; i < s.size(); i++) {
        int k = s[i] - '0';
        endRight = (10*endRight + (i+1)*k) % mod;
        total = (total + endRight) % mod;
    }
    return total;
}

  • pierog
     + 0 comments

    Kotlin solution:

    fun substrings(n: String): Long {
    val modulo = 1000000007L
    var frontier = (n[0] - '0').toLong()

    if (n.length == 1) {
        return frontier
    }

    var currentSum = 0L

    for(i in 1.until(n.length)) {
        val newDigit = n[i] - '0'

        currentSum += frontier

        frontier = (10 * frontier) + (newDigit * (i + 1))
        frontier %= modulo
    }

    // add the frontier to the currentSum
    currentSum += frontier

    return currentSum % modulo
}

    To help understand the above solution, I'm posting a slower solution, where the "frontier" represents the set of all subsets ending at the current "last" character. Note that when encountering a new character, a new frontier is formed by appending the new charater to every element of the old frontier (plus, the lone character itself, set of one character). While doing that, the numerical sum of the old frontier is added to the result. The fast solution transforms the frontier from a set to a number (representing the set's sum). Instead of adding a new character to the end of every element of the frontier, we calculate the new sum directly. You can do that by multiplying the old frontier's sum by 10 (because every digit is shifted left by one position), plus adding the new digit n times (once to each element of the old frontier, plus the lone digit itself, the set of one character).

    private fun sub(n: String, start: Int, end: Int): String {
    return n.subSequence(start, end).toString()
}

private fun num(n: String): BigInteger {
    return n.toBigInteger()
}

private fun <T> Queue<T>.consume(consumer: (T) -> Unit) {
    while(isNotEmpty()) {
        consumer(remove())
    }
}

fun substrings(n: String): Long {
    val moduloLong = 1000000007L
    val modulo = BigInteger.valueOf(moduloLong)

    if (n.length == 1) {
        return n.toLong() % modulo.longValueExact()
    }

    var frontier: Queue<String> = LinkedList()
    frontier.offer(sub(n, 0, 1))
    var currentSum = 0L

    for(i in 1.until(n.length)) {
        val newChar = n[i]
        val newFrontier: Queue<String> = LinkedList()

        frontier.consume { s ->
            currentSum += num(s).mod(modulo).longValueExact()
            if (currentSum > moduloLong) {
                currentSum %= moduloLong
            }
            newFrontier.offer(s + newChar)
        }

        newFrontier.offer(newChar.toString())

        frontier = newFrontier
    }

    frontier.consume { s ->
        currentSum += num(s).mod(modulo).longValueExact()
        if (currentSum > moduloLong) {
            currentSum %= moduloLong
        }
    }

    return currentSum
}

  • alexey_shayakhm1
     + 0 comments
    // a = {a1, a2, a3} = {1,2,3}
// t0 = 0
// s0 = 0
// t1 = t0*10 + 1*a1 = 1 
// s1 = s0 + t1 = 1
// t2 = t1*10 + 2*a2 = 2 + 12
// s2 = s1 + t2 = 1 + 2 + 12 
// t3 = t2*10 + 3*a3 = 3 + 23 + 123
// s3 = s2 + t3 = (1 + 2 + 12) + (3 + 23 + 123)
// ...
int substrings(string str) 
{
    long long s = 0, t = 0;
    for(long long i = 1; i <= str.size(); i++) {
        t = (t * 10 + i * (str[i-1] - '0')) % 1000000007;
        s = (s + t) % 1000000007;        
    }
    return s;
}

  • yashparihar729
     + 0 comments

    Here is my solution in java, javascript, python, C, C++, Csharp HackerRank Sam and substrings Problem Solution