Minimum Number of Pushes to Type Word I solution and explanation

def getMinimumPushes(word):
    word = sorted(word)
    minPushes = 0
    for i in range(len(word)):
        minPushes += (i // 9) + 1
    return minPushes

if __name__ == "__main__":
    word = "xycdefghij"
    print(getMinimumPushes(word))

import java.util.Arrays;

public class MinimumPushes {

    public static int getMinimumPushes(String word) {
        char[] letters = word.toCharArray();
        Arrays.sort(letters);
        int minPushes = 0;
        for (int i = 0; i < letters.length; i++) {
            minPushes += (i / 9) + 1;
        }
        return minPushes;
    }

    public static void main(String[] args) {
        String word = "xycdefghij";
        System.out.println(getMinimumPushes(word));
    }
}

#include <iostream>
#include <algorithm>
#include <string>

int getMinimumPushes(std::string word) {
    std::sort(word.begin(), word.end());
    int minPushes = 0;
    for (int i = 0; i < word.size(); i++) {
        minPushes += (i / 9) + 1;
    }
    return minPushes;
}

int main() {
    std::string word = "xycdefghij";
    std::cout << getMinimumPushes(word) << std::endl;
    return 0;
}

function getMinimumPushes(word) {
    let sortedWord = word.split('').sort().join('');
    let minPushes = 0;
    for (let i = 0; i < sortedWord.length; i++) {
        minPushes += Math.floor(i / 9) + 1;
    }
    return minPushes;
}

let word = "xycdefghij";
console.log(getMinimumPushes(word));

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int compare(const void *a, const void *b) {
    char first = *(const char *)a;
    char second = *(const char *)b;
    return first - second;
}

int getMinimumPushes(char* word) {
    int length = strlen(word);
    qsort(word, length, sizeof(char), compare);

    int minPushes = 0;
    for(int i = 0; i < length; i++) {
        minPushes += (i / 9) + 1;
    }
    return minPushes;
}

int main() {
    char word[] = "xycdefghij";
    printf("%d\n", getMinimumPushes(word));
    return 0;
}

using System;
using System.Linq;

public class MinimumPushes {
    public static int GetMinimumPushes(string word) {
        var letters = word.OrderBy(c => c).ToArray();
        int minPushes = 0;
        for (int i = 0; i < letters.Length; i++) {
            minPushes += (i / 9) + 1;
        }
        return minPushes;
    }

    public static void Main() {
        string word = "xycdefghij";
        Console.WriteLine(GetMinimumPushes(word));
    }
}

def minPushes(word):
    n = len(word)
    dp = [float('inf')] * (n + 1)
    dp[0] = 0

    for i in range(n):
        for j in range(1, 10):
            if i + j <= n:
                dp[i + j] = min(dp[i + j], dp[i] + j)

    return dp[n]

if __name__ == "__main__":
    word = "abcde"
    print(minPushes(word))

import java.util.Arrays;

public class MinPushesDP {
    public static int minPushes(String word) {
        int n = word.length();
        int[] dp = new int[n + 1];
        Arrays.fill(dp, Integer.MAX_VALUE);
        dp[0] = 0;

        for (int i = 0; i < n; i++) {
            for (int j = 1; j <= 9 && i + j <= n; j++) {
                dp[i + j] = Math.min(dp[i + j], dp[i] + j);
            }
        }
        return dp[n];
    }

    public static void main(String[] args) {
        String word = "abcde";
        System.out.println(minPushes(word));
    }
}

#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>

int minPushes(const std::string &word) {
    int n = word.length();
    std::vector<int> dp(n + 1, INT_MAX);
    dp[0] = 0;

    for (int i = 0; i < n; ++i) {
        for (int j = 1; j <= 9 && i + j <= n; ++j) {
            dp[i + j] = std::min(dp[i + j], dp[i] + j);
        }
    }
    return dp[n];
}

int main() {
    std::string word = "abcde";
    std::cout << minPushes(word) << std::endl;
    return 0;
}

function minPushes(word) {
    const n = word.length;
    const dp = new Array(n + 1).fill(Infinity);
    dp[0] = 0;

    for (let i = 0; i < n; i++) {
        for (let j = 1; j <= 9; j++) {
            if (i + j <= n) {
                dp[i + j] = Math.min(dp[i + j], dp[i] + j);
            }
        }
    }
    return dp[n];
}

const word = "abcde";
console.log(minPushes(word));

#include <stdio.h>
#include <string.h>
#include <limits.h>

int minPushes(const char *word) {
    int n = strlen(word);
    int dp[n + 1];
    for (int i = 0; i <= n; ++i) dp[i] = INT_MAX;
    dp[0] = 0;

    for (int i = 0; i < n; ++i) {
        for (int j = 1; j <= 9 && i + j <= n; ++j) {
            dp[i + j] = fmin(dp[i + j], dp[i] + j);
        }
    }
    return dp[n];
}

int main(void) {
    const char* word = "abcde";
    printf("%d\n", minPushes(word));
    return 0;
}

using System;

public class MinPushesDP {
    public static int MinPushes(string word) {
        int n = word.Length;
        int[] dp = new int[n + 1];
        Array.Fill(dp, int.MaxValue);
        dp[0] = 0;

        for (int i = 0; i < n; i++) {
            for (int j = 1; j <= 9 && i + j <= n; j++) {
                dp[i + j] = Math.Min(dp[i + j], dp[i] + j);
            }
        }
        return dp[n];
    }

    public static void Main() {
        string word = "abcde";
        Console.WriteLine(MinPushes(word));
    }
}

function minimumPushes(word: string): number {
    const n = word.length;
    let ans = 0;
    let k = 1;
    for (let i = 0; i < ((n / 8) | 0); ++i) {
        ans += k * 8;
        ++k;
    }
    ans += k * (n % 8);
    return ans;
}

func minimumPushes(word string) (ans int) {
	n := len(word)
	k := 1
	for i := 0; i < n/8; i++ {
		ans += k * 8
		k++
	}
	ans += k * (n % 8)
	return
}