Egyptian division: Difference between revisions

;Related tasks:

:*   [[Egyptian_fractions|Egyptian fractions]]

 

;References:

:*   [https://discoveringegypt.com/egyptian-hieroglyphic-writing/egyptian-mathematics-numbers-hieroglyphs/ Egyptian Number System]

<br><br>

 

=={{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|AutoHotkey}}==

divisor := 34

 

obj.pop() ; remove current row

}

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

 

 

 

'==================================================================================

EGYPTIAN_DIVISION(580,34,0)

 

 

 

 

 

=={{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)

collect n))))

(loop

with accumulator = 0

with answer = 0

finally (return (values answer (- dividend (* answer divisor))))

when (<= (+ accumulator d) dividend)

do (incf answer p)

 

{{out}}

 

=={{header|D}}==

import std.stdio;

 

assert(remainder == 2);

}

 

=={{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>

580 divided by 34 is 17 remainder 2 ok

</pre>

 

=={{header|Go}}==

{{trans|Kotlin}}

 

import "fmt"

quotient, remainder := egyptianDivide(dividend, divisor)

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

 

{{out}}

580 divided by 34 is 17 with 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

 

 

egy n = snd . foldr (k n) (0, 0) . zip powers . takeWhile (<= n) . doublings

 

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>

 

 

 

end

end

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}}

580 divided by 34 is 17 with remainder 2

</pre>

 

=={{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|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>

580 divided by 34 is 17 with remainder 2

</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}}==

{{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|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

As a preceding version was determined to be "let's just say ... not Egyptian" we submit an alternate which is hopefully more "Egyptian". Now only handles positive Integers up to 10 million, mostly due to limitations on Egyptian notation for numbers.

 

 

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}}

 

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

 

=={{header|VBA}}==

 

Private Type MyTable

Divise.Quotient = a.answer

Divise.Remainder = Deg.Dividend - a.accumulator

{{out}}

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

 

 

 

 

 

 

 

 

 

{{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>