Find the Divisibility Array of a String solution and explanation

def find_divisibility_array(word, m):
    result = []
    prefix = 0
    for char in word:
        prefix = (prefix * 10 + int(char)) % m
        result.append(1 if prefix == 0 else 0)
    return result

word = "998244353"
m = 3
print(find_divisibility_array(word, m))

import java.util.*;

public class DivisibilityArray {
    public static int[] findDivisibilityArray(String word, int m) {
        int[] result = new int[word.length()];
        long prefix = 0;
        for (int i = 0; i < word.length(); i++) {
            prefix = (prefix * 10 + (word.charAt(i) - '0')) % m;
            result[i] = (prefix == 0) ? 1 : 0;
        }
        return result;
    }

    public static void main(String[] args) {
        String word = "998244353";
        int[] result = findDivisibilityArray(word, 3);
        System.out.println(Arrays.toString(result));
    }
}

#include <iostream>
#include <vector>
using namespace std;

vector<int> findDivisibilityArray(string word, int m) {
    vector<int> result(word.size(), 0);
    long long prefix = 0;
    for (size_t i = 0; i < word.size(); i++) {
        prefix = (prefix * 10 + (word[i] - '0')) % m;
        result[i] = (prefix == 0) ? 1 : 0;
    }
    return result;
}

int main() {
    string word = "998244353";
    int m = 3;
    vector<int> result = findDivisibilityArray(word, m);
    for (int r : result) {
        cout << r << " ";
    }
    return 0;
}

function findDivisibilityArray(word, m) {
    const result = [];
    let prefix = 0;
    for (let char of word) {
        prefix = (prefix * 10 + parseInt(char)) % m;
        result.push(prefix === 0 ? 1 : 0);
    }
    return result;
}

const word = "998244353";
const m = 3;
console.log(findDivisibilityArray(word, m));

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

void findDivisibilityArray(const char *word, int m, int *result) {
    long long prefix = 0;
    int n = strlen(word);
    for (int i = 0; i < n; i++) {
        prefix = (prefix * 10 + (word[i] - '0')) % m;
        result[i] = (prefix == 0) ? 1 : 0;
    }
}

int main() {
    char word[] = "998244353";
    int m = 3;
    int result[strlen(word)];
    findDivisibilityArray(word, m, result);
    for (int i = 0; i < strlen(word); i++) {
        printf("%d ", result[i]);
    }
    return 0;
}

using System;

class DivisibilityArray {
    static int[] FindDivisibilityArray(string word, int m) {
        int[] result = new int[word.Length];
        long prefix = 0;
        for (int i = 0; i < word.Length; i++) {
            prefix = (prefix * 10 + (word[i] - '0')) % m;
            result[i] = prefix == 0 ? 1 : 0;
        }
        return result;
    }

    static void Main() {
        string word = "998244353";
        int m = 3;
        int[] result = FindDivisibilityArray(word, m);
        Console.WriteLine(string.Join(" ", result));
    }
}

import java.math.BigInteger;
import java.util.*;

public class DivisibilityArray {
    public static int[] findDivisibilityArray(String word, int m) {
        int[] result = new int[word.length()];
        BigInteger modulus = BigInteger.valueOf(m);
        BigInteger prefix = BigInteger.ZERO;
        for (int i = 0; i < word.length(); i++) {
            prefix = prefix.multiply(BigInteger.TEN).add(BigInteger.valueOf(word.charAt(i) - '0'));
            result[i] = prefix.mod(modulus).equals(BigInteger.ZERO) ? 1 : 0;
        }
        return result;
    }

    public static void main(String[] args) {
        String word = "998244353";
        int m = 3;
        int[] result = findDivisibilityArray(word, m);
        System.out.println(Arrays.toString(result));
    }
}

function divisibilityArray(word: string, m: number): number[] {
    const ans: number[] = [];
    let x = 0;
    for (const c of word) {
        x = (x * 10 + Number(c)) % m;
        ans.push(x === 0 ? 1 : 0);
    }
    return ans;
}

func divisibilityArray(word string, m int) (ans []int) {
	x := 0
	for _, c := range word {
		x = (x*10 + int(c-'0')) % m
		if x == 0 {
			ans = append(ans, 1)
		} else {
			ans = append(ans, 0)
		}
	}
	return ans
}

impl Solution {
    pub fn divisibility_array(word: String, m: i32) -> Vec<i32> {
        let m = m as i64;
        let mut x = 0i64;
        word.as_bytes()
            .iter()
            .map(|&c| {
                x = (x * 10 + i64::from(c - b'0')) % m;
                if x == 0 {
                    1
                } else {
                    0
                }
            })
            .collect()
    }
}