Egyptian division: Difference between revisions

{{trans|Python}}

 

assert(divisor != 0)

V (pwrs, dbls) = ([1], [divisor])

V (i, j) = (580, 34)

V (d, m) = egyptian_divmod(i, j)

 

{{out}}

 

=={{header|Action!}}==

 

PROC EgyptianDivision(CARD dividend,divisor Answer POINTER res)

EgyptianDivision(dividend,divisor,res)

PrintF("%U / %U = %U reminder %U",dividend,divisor,res.result,res.reminder)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Egyptian_division.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

 

with Ada.Text_IO;

 

Ada.Text_IO.put_line ("Quotient="&q'Img & " Remainder="&r'img);

end Egyptian_Division;

{{Out}}

<pre>Quotient= 17 Remainder= 2</pre>

 

=={{header|ALGOL 68}}==

# performs Egyptian division of dividend by divisor, setting quotient and remainder #

# this uses 32 bit numbers, so a table of 32 powers of 2 should be sufficient #

egyptian division( 580, 34, quotient, remainder );

print( ( "580 divided by 34 is: ", whole( quotient, 0 ), " remainder: ", whole( remainder, 0 ), newline ) )

{{out}}

<pre>

 

Unfold to derive successively doubled rows, fold to sum quotient and derive remainder

 

-- eqyptianQuotRem :: Int -> Int -> (Int, Int)

end tell

return xs

{{Out}}

<pre>{17, 2}</pre>

=={{header|Arturo}}==

 

ensure -> and? dividend >= 0

divisor > 0

[quotient, remainder]: egyptianDiv dividend divisor

 

 

{{out}}

 

=={{header|AutoHotkey}}==

divisor := 34

 

obj.pop() ; remove current row

}

Outputs:<pre>580/34 = 17 r2</pre>

 

=={{header|BaCon}}==

 

'---Ported from the c code example to BaCon by bigbass

 

 

 

=={{header|C}}==

#include <stdio.h>

#include <stdlib.h>

go(580, 32);

}

 

=={{header|C sharp|C#}}==

using System;

using System.Collections;

}

}

{{out| Program Input and Output : Instead of bold and strikeout text format, numbers are represented in different color}}

<pre>

=={{header|C++}}==

{{trans|C}}

#include <iostream>

 

 

return 0;

{{out}}

<pre>580 / 34 = 17 remainder 2</pre>

=={{header|Common Lisp}}==

 

(defun egyptian-division (dividend divisor)

(let* ((doublings (reverse (loop for n = divisor then (* 2 n)

do (incf answer p)

(incf accumulator d))))

 

{{out}}

 

=={{header|D}}==

import std.stdio;

 

assert(remainder == 2);

}

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

{{libheader| System.Console}}Thanks for JensBorrisholt [https://github.com/JensBorrisholt/DelphiConsole].

{{Trans|C#}}

program Egyptian_division;

 

Console.Write('Press any key to continue . . . ');

Console.ReadKey(true);

{{out}}<pre>

 

Press any key to continue . . .</pre>

=={{header|Erlang}}==

 

-export([ediv/2]).

accumulate(N, [T|Ts], [D|Ds], Q, C) when (C + D) =< N -> accumulate(N, Ts, Ds, Q+T, C+D);

accumulate(N, [_|Ts], [_|Ds], Q, C) -> accumulate(N, Ts, Ds, Q, C).

{{out}}

<pre>

 

=={{header|F_Sharp|F#}}==

let egyptianDivision N G =

let rec fn n g = seq{yield (n,g); yield! fn (n+n) (g+g)}

Seq.foldBack (fun (n,i) (g,e)->if (i<=g) then ((g-i),(e+n)) else (g,e)) (fn 1 G |> Seq.takeWhile(fun (_,g)->g<=N)) (N,0)

Which may be used:

let (n,g) = egyptianDivision 580 34

printfn "580 divided by 34 is %d remainder %d" g n

{{out}}

<pre>

=={{header|Factor}}==

{{works with|Factor|0.98}}

IN: rosetta-code.egyptian-division

 

} 2cleave ;

 

{{out}}

<pre>

 

=={{header|Forth}}==

variable tab-end

 

: .egypt ( m n -- )

cr 2dup swap . ." divided by " . ." is " e/mod swap . ." remainder " . ;

{{Out}}

<pre>

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>580 divided by 34 using Egytian division returns 17 mod(ulus) 2</pre>

=={{header|Go}}==

{{trans|Kotlin}}

 

import "fmt"

quotient, remainder := egyptianDivide(dividend, divisor)

fmt.Println(dividend, "divided by", divisor, "is", quotient, "with remainder", remainder)

 

{{out}}

=={{header|Groovy}}==

{{trans|Java}}

/**

* Runs the method and divides 580 by 34

println(String.format("%d, remainder %d", answer, dividend - accumulator))

}

{{out}}

<pre>17, remainder 2</pre>

=={{header|Haskell}}==

Deriving division from (+) and (-) by unfolding from a seed pair (1, divisor) up to a series of successively doubling pairs, and then refolding that series of 'two column rows' back down to a (quotient, remainder) pair, using (0, dividend) as the initial accumulator value. In other words, taking the divisor as a unit, and deriving the binary composition of the dividend in terms of that unit.

 

egyptianQuotRem :: Integer -> Integer -> (Integer, Integer)

 

main :: IO ()

{{Out}}

<pre>(17,2)</pre>

We can make the process of calculation more visible by adding a trace layer:

 

import Debug.Trace (trace)

 

 

main :: IO ()

{{Out}}

<pre>Number pair unfolded to series of doubling rows:

Another approach, using lazy lists and foldr:

 

 

powers = doublings 1

 

main :: IO ()

{{Out}}

<pre>17</pre>

Implementation:

 

ansacc=: 1 }. (] + [ * {.@[ >: {:@:+)/@([,.doublings)

 

Task example:

 

1 34

2 68

17 578

580 egydiv 34

 

Notes:

 

=={{header|Java}}==

import java.util.ArrayList;

import java.util.List;

}

 

{{Out}}

<pre>17, remainder 2</pre>

=={{header|JavaScript}}==

===ES6===

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>[17,2]</pre>

=={{header|Julia}}==

{{works with|Julia|0.6}}

N = 64

powers = Vector{Int}(N)

@test egyptiandivision(x, y) == divrem(x, y)

end

 

{{out}}

 

=={{header|Kotlin}}==

 

data class DivMod(val quotient: Int, val remainder: Int)

val (quotient, remainder) = egyptianDivide(dividend, divisor)

println("$dividend divided by $divisor is $quotient with remainder $remainder")

 

{{out}}

=={{header|Lua}}==

{{trans|Python}}

local pwrs, dbls = {1}, {divisor}

while dbls[#dbls] <= dividend do

local i, j = 580, 34

local d, m = egyptian_divmod(i, j)

{{out}}

<pre>580 divided by 34 using the Egyptian method is 17 remainder 2</pre>

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

EgyptianDivide[dividend_, divisor_] := Module[{table, i, answer, accumulator},

table = {{1, divisor}};

{answer, dividend - accumulator}

]

{{out}}

<pre>{17, 2}</pre>

 

=={{header|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT WriteString,ReadChar;

 

ReadChar

 

=={{header|Nim}}==

 

func egyptianDivision(dividend, divisor: int): tuple[quotient, remainder: int] =

let divisor = 34

var (quotient, remainder) = egyptianDivision(dividend, divisor)

{{out}}

<pre>

=={{header|Perl}}==

{{trans|Raku}}

my($dividend, $divisor) = @_;

die "Invalid divisor" if $divisor <= 0;

my($n,$d) = @$_;

printf "Egyption divmod %s %% %s = %s remainder %s\n", $n, $d, egyptian_divmod( $n, $d )

{{out}}

<pre>Egyption divmod 580 % 34 = 17 remainder 2

 

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">procedure</span> <span style="color: #000000;">egyptian_division</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">dividend</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">divisor</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">egyptian_division</span><span style="color: #0000FF;">(</span><span style="color: #000000;">580</span><span style="color: #0000FF;">,</span><span style="color: #000000;">34</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

 

=={{header|PicoLisp}}==

 

(de divmod (Dend Disor)

(let (A (rand 1 1000) B (rand 1 A))

(test (divmod A B) (egyptian A B)) ) )

 

{{out}}

=={{header|Prolog}}==

{{works with|SWI Prolog}}

powers2_multiples(Dividend, [1], Powers, [Divisor], Multiples),

accumulate(Dividend, Powers, Multiples, 0, Quotient, 0, Acc),

 

main:-

 

{{out}}

=={{header|Python}}==

===Idiomatic=== <!-- When compared to a Haskell translation -->

 

def egyptian_divmod(dividend, divisor):

i, j = 580, 34

print(f'{i} divided by {j} using the Egyption method is %i remainder %i'

 

'''Sample output'''

 

{{Trans|Haskell}}

 

from functools import reduce

# MAIN ----------------------------------------------------

if __name__ == '__main__':

{{Out}}

<pre>(17, 2)</pre>

=={{header|Quackery}}==

 

[ $ "Cannot divide by zero."

fail ]

say "." ] is task ( n n --> )

 

 

{{out}}

 

=={{header|R}}==

pow2 = 0

row = 1

Egyptian_division(580, 34)

Egyptian_division(300, 2)

 

{{out}}

 

=={{header|Racket}}==

 

(define (quotient/remainder-egyptian dividend divisor (trace? #f))

 

(module+ main

 

{{out}}

===Normal version===

Only works with positive real numbers, not negative or complex.

my $accumulator = 0;

([1, $divisor], { [.[0] + .[0], .[1] + .[1]] } … ^ *.[1] > $dividend)

printf "%s divmod %s = %s remainder %s\n",

$n, $d, |egyptian-divmod( $n, $d )

{{out}}

<pre>580 divmod 34 = 17 remainder 2

 

This is intended to be humorous and should not be regarded as good (or even sane) programming practice. That being said, 𓂽 & 𓂻 really are the ancient Egyptian symbols for addition and subtraction, and the Egyptian number notation is as accurate as possible. Everything else owes more to whimsy than rigor.

sub infix:<𓂽> { $^𓃠 + $^𓃟 }

sub infix:<𓂻> { $^𓃲 - $^𓆊 }

printf "%s divmod %s = %s remainder %s =OR= %s 𓅓 %s = %s remainder %s\n",

𓃾, 𓆙, |(𓃾 𓅓 𓆙), (𓃾, 𓆙, |(𓃾 𓅓 𓆙))».&𓁶;

 

{{out}}

=={{header|REXX}}==

Only addition and subtraction is used in this version of the Egyptian division method.

numeric digits 1000 /*support gihugic numbers & be gung-ho.*/

parse arg n d . /*obtain optional arguments from the CL*/

ans= ans + pow.s /*calculate the (newer) running answer.*/

end /*s*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Ring}}==

load "stdlib.ring"

 

see string(dividend) + " divided by " + string(divisor) + " using egytian division" + nl

see " returns " + string(answer) + " mod(ulus) " + string(dividend-accumulator)

Output:

<pre>

 

=={{header|Ruby}}==

table = [[1, divisor]]

table << table.last.map{|e| e*2} while table.last.first * 2 <= dividend

 

puts "Quotient = %s Remainder = %s" % egyptian_divmod(580, 34)

{{out}}

<pre>Quotient = 17 Remainder = 2

 

=={{header|Rust}}==

let dividend = dividend as u64;

let divisor = divisor as u64;

let (div, rem) = egyptian_divide(580, 34);

println!("580 divided by 34 is {} remainder {}", div, rem);

{{out}}

<pre>580 divided by 34 is 17 remainder 2</pre>

=={{header|Scala}}==

{{Out}}Best seen running in your browser either by [https://scalafiddle.io/sf/sYSdo9u/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/3yry7OurSQS72xNMK0GMEg Scastie (remote JVM)].

 

private def divide(dividend: Int, divisor: Int): Unit = {

divide(580, 34)

 

 

=={{header|Sidef}}==

{{trans|Ruby}}

var table = [[1, divisor]]

table << table[-1].map{|e| 2*e } while (2*table[-1][0] <= dividend)

}

 

{{out}}

<pre>

=={{header|Swift}}==

 

@inlinable

public func egyptianDivide(by divisor: Self) -> (quo: Self, rem: Self) {

 

print("\(dividend) divided by \(divisor) = \(quo) rem \(rem)")

 

{{out}}

 

=={{header|Tailspin}}==

templates egyptianDivision

def dividend: $(1);

[580"1", 34"1"] -> egyptianDivision -> 'Quotient: $.answer; Remainder: $: 580"1" - $.accumulator;' -> !OUT::write

 

{{out}}

 

=={{header|VBA}}==

 

Private Type MyTable

Divise.Quotient = a.answer

Divise.Remainder = Deg.Dividend - a.accumulator

{{out}}

<pre>Quotient = 17 Remainder = 2</pre>

=={{header|Visual Basic .NET}}==

{{trans|D}}

 

Function EgyptianDivision(dividend As ULong, divisor As ULong, ByRef remainder As ULong) As ULong

End Sub

 

{{out}}

<pre>580 / 34 = 17 rem 2</pre>

=={{header|Vlang}}==

{{trans|Go}}

 

if dividend < 0 || divisor <= 0 {

quotient, remainder := egyptian_divide(dividend, divisor)?

println("$dividend divided by $divisor is $quotient with remainder $remainder")

 

{{out}}

=={{header|Wren}}==

{{trans|Go}}

if (dividend < 0 || divisor <= 0) Fiber.abort("Invalid argument(s).")

if (dividend < divisor) return [0, dividend]

var divisor = 34

var res = egyptianDivide.call(dividend, divisor)

 

{{out}}

 

=={{header|zkl}}==

table:=[0..].pump(List, 'wrap(n){ // (2^n,divisor*2^n)

r:=T( p:=(2).pow(n), s:=divisor*p); (s<=dividend) and r or Void.Stop });

}

return(accumulator,dividend);

println("%d %% %d = %s".fmt(dividend,divisor,egyptianDivmod(dividend,divisor)));

{{out}}

<pre>