Me pareceu desafiador, então resolvi fazer.

algoritmo "divide"
var
    divs, divd, res, x, y, i: inteiro
    sub: inteiro
    quo, i: real
inicio
    escreva("Informe o dividendo: ")
    leia(y)
    escreva("Informe o divisor: ")
    leia(x)

    divs = x
    divd = y

    se (x < 0) entao
        divs = divs * -1
    fimse
    se (y < 0) entao
        divd = divd * -1
    fimse

    res = divd

    enquanto (res >= divd) e (divs <= divd) faca
        i = 0
        enquanto (sub < divd) e (sub + divs <= divd) faca
            sub = sub + divs
            i = i + 1       
        fimenquanto

        quo = (quo + i * 0,1) * 10
        divd = divd - sub
        res = divd

    fimenquanto

    se (x xor y < 0) entao
        quo = quo * -1
    fimse

    escreva("Resultado: ", quo)
    escreva("Resto: ", res)
fimalgoritmo

Se você utiliza o Visualg, altere os sinais de atribuição "=" por ":=" sem aspas e terá que fazer outras adaptações. Vou explicar o que eu fiz e a lógica que utilizei.

Lógica
Um laço de repetição para ir subtraindo valores do dividendo, que sejam múltiplos do divisor. E um laço dentro do laço para pegar os múltiplos do divisor que sejam menor ou igual ao dividendo. Depois ir armazenando o quociente e resultado do resto da divisão.

x e y: essas variáveis foram só para ler o dividendo e divisor, caso eu quisesse pôr a mensagem no final: escreva(x / y = quo e x % y = res)

divs e divd: são o divisor e o dividendo. Uma das condições para que o primeiro laço se repita, é exatamente que o divisor seja menor ou igual ao dividendo.

res e quo: são o resto da divisão e o quociente. O resto da divisão é sempre igual ao dividendo. E o quociente é igual ao número do múltiplo do divisor utilizado na subtração "concatenado" com os outros múltiplos do divisor utilizado. Essa conta estranha de multiplicar por 0,1 e depois 10 foi uma forma que encontrei de fazer essa "concatenação". Se não funcionar aí, tente retirar os parênteses.
Note que o quociente é real, exatamente por causa dessa conta fracionária.

sub e i: sub é o valor que subtrairemos do dividendo. Esse valor é múltiplo do divisor. E o i indica qual múltiplo foi, se foi 2x o divisor, 3x, 5x, nx...

Em resumo esse algoritmo recebe os valores do divisor e dividendo, e enquanto o resto da divisão for maior ou igual dividendo e o divisor for menor ou igual ao dividendo, ele vai calcular qual é o maior valor que pode subtrair do dividendo, que seja múltiplo do divisor e armazenar no quociente. E também pegar o resto da divisão, fazendo isso até não poder dividir mais.

Obs.: esse algoritmo só aceita valores inteiros. Codifiquei em C e funcionou com todos os valores que testei, que não foram poucos.
Segue o anexo do teste de mesa

Valores Negativos
O algoritmo aceita valores negativos, ele os converte em positivo lá no começo e para o resultado ser positivo ou negativo temos o seguinte:
positivo / positivo = positivo
positivo / negativo = negativo
negativo / positivo = negativo
negativo / negativo = positivo

É a complementar da tabela verdade do XOR (Exclusive OR), ou XNOR. Então se x xor y = verdadeiro, eu exibo o resultado como negativo. Se x xor y = falso, então eu exibo o resultado como positivo. Teste o algoritmo com valores como 25/5, 25/-5, -25/5, -25/-5 e etc... e outros valores.