Nimber arithmetic: Difference between revisions

 

The '''nimbers''', also known as '''Grundy''' numbers, are the values of the heaps in the game of [https://en.wikipedia.org/wiki/Nim Nim]. They have '''addition''' and '''multiplication''' operations, unrelated to the addition and multiplication of the integers. Both operations are defined recursively:

# Find the nim-sum and nim-product of two five digit integers of your choice

<br><br>

 

=={{header|C}}==

{{trans|FreeBASIC}}

#include <stdint.h>

 

printf("%d * %d = %d\n", a, b, nimprod(a, b));

return 0;

 

{{out}}

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

{{trans|FreeBASIC}}

#include <functional>

#include <iomanip>

std::cout << a << " * " << b << " = " << nimprod(a, b) << '\n';

return 0;

 

{{out}}

21508 * 42689 = 35202

</pre>

 

=={{header|Factor}}==

{{trans|FreeBASIC}}

{{works with|Factor|0.99 2020-07-03}}

 

! highest power of 2 that divides a given number

33333 77777

[ 2dup nim-sum "%d + %d = %d\n" printf ]

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

'highest power of 2 that divides a given number

return n and -n

 

print using "##### + ##### = ##########"; a; b; nimsum(a,b)

{{out}}

<pre>

=={{header|Go}}==

{{trans|FreeBASIC}}

 

import (

fmt.Printf("%d + %d = %d\n", a, b, nimsum(a, b))

fmt.Printf("%d * %d = %d\n", a, b, nimprod(a, b))

 

{{out}}

21508 * 42689 = 35202

</pre>

 

=={{header|Java}}==

{{trans|FreeBASIC}}

 

public class Nimber {

System.out.print(" " + op + " |");

for (int a = 0; a <= n; ++a)

System.out.print("\n--- -");

for (int a = 0; a <= n; ++a)

System.out.println();

for (int b = 0; b <= n; ++b) {

for (int a = 0; a <= n; ++a)

System.out.println();

}

}

 

{{out}}

=={{header|Julia}}==

{{trans|FreeBASIC}}

hpo2(n) = n & -n

 

println("nim-sum: $a ⊕ $b = $(nimsum(a, b))")

println("nim-product: $a ⊗ $b = $(nimprod(a, b))")

<pre>

⊕ | 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

=={{header|Nim}}==

{{trans|FreeBASIC}}

 

type Nimber = Natural

const B = 42689

echo "$1 ⊕ $2 = $3".format(A, B, ⊕(A, B))

 

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use feature 'say';

say nim_prod(21508, 42689);

say nim_sum(2150821508215082150821508, 4268942689426894268942689);

{{out}}

<pre> + │ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

=={{header|Phix}}==

{{trans|FreeBASIC}}

{{out}}

<pre>

{{trans|FreeBASIC}}

{{works with|SWI Prolog}}

hpo2(N, P):-

P is N /\ -N.

nimprod(A, B, Product),

writef('%w + %w = %w\n', [A, B, Sum]),

 

{{out}}

=={{header|Python}}==

{{trans|Go}}

def hpo2(n): return n & (-n)

 

a, b = 21508, 42689

print(f"{a} + {b} = {nimsum(a,b)}")

{{out}}

<pre>

=={{header|Quackery}}==

{{trans|Julia}} (Mostly translated from Julia, although 'translated' doesn't do the process justice.)

[ dup negate & ] is hpo2 ( n --> n )

say " 10547 (+) 14447 = " 10547 14447 nim+ echo cr

say " 10547 (*) 14447 = " 10547 14447 nim* echo cr

{{Out}}

<pre>

Not limited by integer size. Doesn't rely on twos complement bitwise and.

 

 

sub infix:<⊗> (Int $x, Int $y) {

 

put "2150821508215082150821508 ⊕ 4268942689426894268942689 = ", 2150821508215082150821508 ⊕ 4268942689426894268942689;

{{out}}

<pre> ⊕ │ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

The table size &nbsp; (for nimber sum and nimber products) &nbsp; may be specified on the <u>c</u>ommand <u>l</u>ine ('''CL''') &nbsp; as well as the

<br>two test numbers.

numeric digits 40; d= digits() % 8 /*use a big enough number of decimals. */

parse arg sz aa bb . /*obtain optional argument from the CL.*/

if bb=='' | bb=="," then bb= 42689 /* " " " " " " */

w= max(4,length(sz)); @.= '+'; @.1= "*"; _= '═' /*calculate the width of the table cols*/

do am=0 for 2 /*perform sums, then perform multiplies*/

do k=0 for sz1 /*build a row of table. */

if am then $= $ || right( nprod(j, k), w) /*append to a table row.*/

else $= $ || right( nsum(j, k), w) /* " " " " " */

end /*k*/

end /*j*/

call bot

exit 0 /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

top: $= '╔'copies(_, w1)"╦"copies(copies(_, w), sz1)_; say $'╗'; arg ?; call hdr; return

sep: $= '╠'copies(_, w1)"╬"copies(copies(_, w), sz1)_; say $'╣'; return

if hpo2(y)<y then return nprod(y, x)

ands= c2d(bitand(d2c(lhpo2(x), d), d2c(lhpo2(y), d))); if ands==0 then return x*y

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> 25 </tt>}}

<pre>

=={{header|Rust}}==

{{trans|FreeBASIC}}

fn hpo2(n: u32) -> u32 {

n & (0xFFFFFFFF - n + 1)

println!("\n{} + {} = {}", a, b, nimsum(a, b));

println!("{} * {} = {}", a, b, nimprod(a, b));

 

{{out}}

=={{header|Swift}}==

{{trans|Rust}}

 

// highest power of 2 that divides a given number

let b: Int = 42689

print("\n\(a) + \(b) = \(nimSum(x: a, y: b))")

 

{{out}}

{{trans|FreeBASIC}}

{{libheader|Wren-fmt}}

 

// Highest power of two that divides a given number.

var b = 42689

System.print("%(a) + %(b) = %(nimsum.call(a, b))")

 

{{out}}

21508 + 42689 = 62149

21508 * 42689 = 35202

</pre>