У меня есть код на java выполняющий деление с остатком и деление с остатком методом из книги кнута.
Перепиши его так чтобы в методе кнута не использовался biginteger
package KnuthDivisionBase10;

import java.math.BigInteger;
import java.util.Scanner;

public class KnuthDivisionBase10 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        BigInteger uBig = readBigInteger(scanner, "Введите делимое (u):");
        BigInteger vBig = readNonZeroBigInteger(scanner, "Введите делитель (v):");
        
        // Измеряем время выполнения стандартного деления
        long startTime = System.nanoTime();
        BigInteger[] standardResult = uBig.divideAndRemainder(vBig);
        long endTime = System.nanoTime();
        double standardTime = (endTime - startTime) / 1e9;
        
        // Измеряем время выполнения алгоритма Кнута
        startTime = System.nanoTime();
        BigInteger[] knuthResult = knuthDivision(uBig, vBig);
        endTime = System.nanoTime();
        double knuthTime = (endTime - startTime) / 1e9;
        
        // Выводим результаты
        System.out.println("\nСтандартное деление:");
        System.out.println("Частное: " + standardResult[0]);
        System.out.println("Остаток: " + standardResult[1]);
        System.out.printf("Время выполнения: %.5f сек.\n", standardTime);
        
        System.out.println("\nАлгоритм Кнута:");
        System.out.println("Частное: " + knuthResult[0]);
        System.out.println("Остаток: " + knuthResult[1]);
        System.out.printf("Время выполнения: %.5f сек.\n", knuthTime);
        
        // Проверка корректности результатов
        if (!standardResult[0].equals(knuthResult[0]) || !standardResult[1].equals(knuthResult[1])) {
            System.out.println("\nОшибка: Результаты алгоритмов не совпадают!");
        } else {
            System.out.println("\nПроверка: Результаты совпадают.");
        }
        
        scanner.close();
    }
    
    private static BigInteger readBigInteger(Scanner scanner, String prompt) {
        while (true) {
            System.out.println(prompt);
            try {
                return new BigInteger(scanner.nextLine().trim());
            } catch (NumberFormatException e) {
                System.out.println("Ошибка: Введите корректное целое число. Попробуйте снова.");
            }
        }
    }
    
    private static BigInteger readNonZeroBigInteger(Scanner scanner, String prompt) {
        while (true) {
            BigInteger num = readBigInteger(scanner, prompt);
            if (num.equals(BigInteger.ZERO)) {
                System.out.println("Ошибка: Делитель не может быть нулем. Попробуйте снова.");
            } else {
                return num;
            }
        }
    }
    
    public static BigInteger[] knuthDivision(BigInteger u, BigInteger v) {
        // Проверка тривиальных случаев
        if (v.equals(BigInteger.ZERO)) {
            throw new ArithmeticException("Деление на ноль");
        }
        if (u.compareTo(v) < 0) {
            return new BigInteger[] { BigInteger.ZERO, u };
        }
        if (v.equals(BigInteger.ONE)) {
            return new BigInteger[] { u, BigInteger.ZERO };
        }
        
        // D1. Нормализация
        int n = v.bitLength();
        int m = u.bitLength() - n;
        
        // Вычисляем d как число бит до следующей границы слова
        int d = (32 - (n % 32)) % 32;
        BigInteger b = BigInteger.ONE.shiftLeft(d);
        BigInteger uHat = u.multiply(b);
        BigInteger vHat = v.multiply(b);
        
        // Основные переменные алгоритма
        BigInteger q = BigInteger.ZERO;
        int j = m;
        
        while (j >= 0) {
            // D3. Вычисление q̂
            int shift = j + n;
            BigInteger uPart = shift < uHat.bitLength() ? 
                uHat.shiftRight(shift) : 
                BigInteger.ZERO;
            
            BigInteger qHat = uPart.divide(vHat.shiftRight(n));
            
            // D4. Проверка и коррекция q̂
            BigInteger temp = uHat.shiftRight(j).subtract(qHat.multiply(vHat));
            while (temp.compareTo(BigInteger.ZERO) < 0) {
                qHat = qHat.subtract(BigInteger.ONE);
                temp = temp.add(vHat);
            }
            
            // D5. Умножение и вычитание
            uHat = uHat.subtract(vHat.multiply(qHat).shiftLeft(j));
            
            // D6. Проверка остатка
            if (uHat.compareTo(BigInteger.ZERO) < 0) {
                // D7. Компенсация
                qHat = qHat.subtract(BigInteger.ONE);
                uHat = uHat.add(vHat.shiftLeft(j));
            }
            
            // D8. Сохранение цифры частного
            q = q.add(qHat.shiftLeft(j));
            j--;
        }
        
        // Денормализация остатка
        BigInteger r = uHat.shiftRight(d);
        
        return new BigInteger[] { q, r };
    }
}