Negative base numbers: Difference between revisions

* supply an integer, that when encoded to base &nbsp; -62 &nbsp; (or something "higher"), &nbsp; expresses the <br>name of the language being used &nbsp; (with correct capitalization). &nbsp; If the computer language has <br>non-alphanumeric characters, &nbsp; try to encode them into the negatory numerals, &nbsp; or use other <br>characters instead.

<br><br>

 

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

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

# Note - no checks for valid bases or digits bases -2 .. -63 are handled #

# A-Z represent the digits 11 .. 35, a-z represent the digits 36 .. 61 #

# The defining document for ALGOL 68 spells the name "Algol 68" on the cover, though inside it is "ALGOL 68" #

# at the risk of "judging a language by it's cover", we use "Algol 68" as the name here... #

{{out}}

<pre>

=={{header|C}}==

{{trans|modula-2}}

 

const char DIGITS[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

 

return 0;

{{out}}

<pre> 10 encoded in base -2 = 11110

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

{{trans|Java}}

using System.Collections.Generic;

using System.Linq;

}

}

{{out}}

<pre> 10 encoded in base -2 = 11110

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

{{trans|C#}}

#include <iostream>

#include <tuple>

 

return 0;

{{out}}

<pre> 10 encoded in base -2 = 11110

 

=={{header|D}}==

 

immutable DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

}

return total;

 

{{out}}

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

===The Functions===

//I provide 2 fuctions D2N takes a radix and an integer returning a sequence of integers

// N2D takse a radix and a sequence of integers returning an integer

|_->Some(g-(α+1)*n,α+1)) g|>Seq.rev

let N2D n g=fst(Seq.foldBack(fun g (Σ,α)->(Σ+α*g,n*α)) g (0,1))

===The Task===

let t0,t146,t10,t15=D2N -13 0,D2N -3 146,D2N -2 10,D2N -10 15

Seq.iter(fun n->Seq.iter(printf "%d ")n; printfn "")[t0;t146;t10;t15]

Seq.iter(printfn "%d ")[N2D -13 t0;N2D -3 t146;N2D -2 t10;N2D -10 t15]

{{out}}

<pre>

=={{header|Factor}}==

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

math.extras math.functions math.parser sequences ;

 

"%d_10 is %s_%d\n%s_%d is %d_10\n\n" printf ;

 

{{out}}

<pre>

195_-10 is 15_10

</pre>

 

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

fmt.Printf("%13s decoded in base %-3d = %d\n\n", ns, b, n)

}

 

{{out}}

 

=={{header|Haskell}}==

import Numeric (showIntAtBase)

 

printAtBase (-10) 15

printAtBase (-16) 107

 

{{out}}

{{trans|Kotlin}}

{{works with|Java|9}}

import java.util.Map;

import java.util.Objects;

}

}

{{out}}

<pre> 10 encoded in base -2 = 11110

{{works with|jq|1.5}}

If your jq does not have `trunc/0` then use this:

if ($b >= 0) then error("negbase requires negative base")

elif . == 0 then "0"

;

 

{{out}}

[true,true]

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

function negbase(n, b)

if n == 0 return "0" end

decoded = invnegbase(encoded, base)

println("\nencode $num in base $base:\n-> expected: $rst\n-> resulted: $encoded\n-> decoded: $decoded")

 

{{out}}

 

=={{header|Kotlin}}==

 

const val DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"

System.out.printf("%12s decoded in base %-3d = %d\n\n", ns, p.second, n)

}

 

{{out}}

</pre>

 

out={},

rem,n=number,b=base

Print[EncodeNegBase[10,-2],"=",DecodeBase[EncodeNegBase[10,-2],-2]];

Print[EncodeNegBase[146,-3],"=",DecodeBase[EncodeNegBase[146,-3],-3]];

<pre>{1,1,1,1,0}=10

{2,1,1,0,2}=146

{1,9,5}=15</pre>

Extra Credit:

<pre>805433247971592164648901981307140864173502418954511864100981464890629926293823767730118860531000284192172723837

1402171866107096793294662824351970913227448502019658754262020315290937172496459102043149157175108006798078612200544768242812932737034448604720533372980987964929785521161173764118702296122915325508945150191589743829011670147956776269027485433441427722106</pre>

 

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

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

 

ReadChar

{{out}}

<pre> 10 encoded in base -2 = 11110

-19425187910 encoded in base -62 = Modula

Modula decoded in base -62 = -19425187910</pre>

 

=={{header|ooRexx}}==

{{trans|REXX}}

* Adapt for ooRexx (use of now invalid variable names)

* and make it work for base -63 (Algol example)

Else

r='ok'

{{out}}

<pre> 10 converted to base -2 ----> 11110 ok

=={{header|Perl}}==

{{libheader|ntheory}}

use feature 'say';

use POSIX qw(floor);

say '11110 from base -2: ', decode("11110", -2);

say '21102 from base -3: ', decode("21102", -3);

{{out}}

<pre>

 

=={{header|Phix}}==

{{out}}

<pre>

=={{header|Python}}==

 

from __future__ import print_function

 

print (result)

if DecodeNegBase(result, -10) == 15: print ("Converted back to decimal")

 

{{out}}

195

Converted back to decimal</pre>

 

=={{header|Racket}}==

 

 

(define all-digits (string->list "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-"))

 

(define-values (->hexadecimal hexadecimal->) (negabase-convertors 16))

 

{{out}}

Note that the parse-base routine will handle 'illegal' negative negative-base values without blowing up.

 

my $result;

while $value {

 

# 'Illegal' negative-base value

{{out}}

<pre> 4.&base( -4) = 130 : '130'.&parse-base( -4) = 4

Doing pretty much the same tests as the explicit version.

 

 

for < 4 -4 0 -7 10 -2 146 -3 15 -10 -19 -10 107 -16

printf "%21s.&to-base\(%5d\) = %-11s : %13s.&from-base\(%5d\) = %s\n",

+$v, $r, $nbase, "'$nbase'", $r, $nbase.&from-base($r);

{{out}}

<pre> 4.&to-base( -4) = 130 : '130'.&from-base( -4) = 4

<br>negative base back to the original number in base ten &nbsp; (and issues an error message if not correct).

===handles up to base -10===

@=' converted to base '; numeric digits 300 /*be able to handle ginormous numbers. */

n= 10; b= -2; q= nBase(n, b); say right(n, 20) @ right(b, 3) '────►' q ok()

p= p + 1 /*bump the power by 1. */

end /*j*/ /* [↓] process the number "bottom-up".*/

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

<pre>

<br>because the symbols (glyphs or numerals) used herein may not be in the same exact order. &nbsp; The symbols represented

<br>in this REXX program should be able to represent almost any programming language used on Rosetta Code.

@=' converted to base '; numeric digits 300 /*be able to handle ginormous numbers. */

n= 10; b= -2; q= nBase(n, b); say right(n, 20) @ right(b,3) '────►' q ok()

$= $ + v * r**p; p= p + 1 /*add it to $ (result); bump power by 1*/

end /*j*/ /* [↑] process the number "bottom-up".*/

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

<pre>

 

=={{header|Ring}}==

# Project : Negative base numbers

 

next

return svect

{{out}}

<pre>

195 decoded in base -10 = 15

</pre>

 

=={{header|Rust}}==

{{trans|Go}}

 

}

return out.chars().rev().collect();

 

 

=={{header|Scala}}==

val digits = ('0' to '9') ++ ('a' to 'z') ++ ('A' to 'Z')

}._1

}

 

println(s"$n in base -$b = ${NegativeBase.intToStr(n, b)}")

println(s"$s from base -$b = ${NegativeBase.strToInt(s, b)}")

testConversion(3)(146, "21102")

testConversion(10)(15, "195")

 

{{out}}

 

=={{header|Seed7}}==

 

const string: DIGITS is "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

doCheck(15, -10);

doCheck(404355637, -62);

 

{{out}}

{{trans|Raku}}

{{trans|Python}}

var out = []

var r = 0

# Extra

say ("25334424 in base -31: ", EncodeNegBase(25334424, -31))

{{out}}

<pre>

=={{header|VBA}}==

{{trans|Modula-2}}

Dim Str(63) As String

Private Function mod2(a As Long, b As Integer) As Long

Driver 15, -10

Driver 118492, -62

{{out}}

<pre>10 encoded in base -2 = 11110

{{trans|Kotlin}}

{{libheader|Wren-fmt}}

 

var digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"

var n = decodeNegBase.call(ns, p[1])

Fmt.print("$8s decoded in base $-3d = $d\n", ns, p[1], n)

 

{{out}}

 

=={{header|zkl}}==

var [const] cs=[0..9].chain(["a".."z"]).pump(String); //"0123456789abcd..z"

_assert_(-37 < radix < -1,"invalid radix");

fcn toInt(str,radix){ // the toInt(radix) method radix is 2..36

str.reduce('wrap(s,d,rdx){ s*radix + d.toInt(rdx); },0,radix.abs());

results:=ns.pump(List,Void.Xplode,toNBase);

foreach nb,r in (ns.zip(results)){

_,b:=nb;

println("%10d.base(%3d) = \"%s\" --> %d".fmt(nb.xplode(),r,toInt(r,b)));

{{out}}

<pre>