Mayan numerals: Difference between revisions

{{trans|Nim}}

 

UL = ‘╔’

UC = ‘╦’

V mayans = digits.map(d -> toMayanNumeral(d))

draw(mayans)

 

{{out}}

 

=={{header|8080 Assembly}}==

puts: equ 9

org 100h

d0: db '| $| . $| .. $|... $|....$'

d5: db '|----$'

 

{{out}}

|....|----|----|----|----|----|....|----|----|----|----|----|....|

+----+----+----+----+----+----+----+----+----+----+----+----+----+</pre>

 

=={{header|APL}}==

{{works with|Dyalog APL}}

ds←6 4⍴' . .. ... ....────'

d←{ ⍵=0:4 4⍴¯14↑'Θ'

btm←'╚',(1↓∊(≢d)⍴⊂'╩════'),'╝'

top⍪((⊃,/'║',¨d),'║')⍪btm

 

{{out}}

=={{header|AppleScript}}==

Applescript supports only small integers (up to (2^29)-1 = 536870911).

use framework "Foundation"

use scripting additions

end |λ|

end script

{{Out}}

Mayan 4005:

|style="width:3em;vertical-align:bottom;"|Θ

|}

 

=={{header|BASIC}}==

15 FOR I=0 TO 5: READ L$(I): NEXT I

20 LINE INPUT I$

210 FOR I=S TO M: PRINT "+----";: NEXT I: PRINT "+"

220 END

 

{{out}}

 

=={{header|BCPL}}==

 

let reads(v) be

mayan(v)

$) repeat

{{out}}

<pre style='height:50ex;'>Number? 4005

 

=={{header|C}}==

#include <string.h>

#include <stdint.h>

free(m);

return 0;

 

{{out}}

|....|----|----|----|----|----|....|

+----+----+----+----+----+----+----+</pre>

 

=={{header|CLU}}==

 

base20 = proc (n: bigint) returns (sequence[int])

n: bigint := bigint$parse(sequence[string]$bottom(get_argv()))

stream$puts(po, mayan(base20(n)))

{{out}}

<pre>$ ./mayan 4005

 

=={{header|Cowgol}}==

include "argv.coh";

 

(n, arg) := AToI(arg);

if n <= 0 then Error(); end if;

 

{{out}}

 

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

// Mayan numerals. Nigel Galloway: February 19th., 2021

let N=[|"│ ";"│. ";"│.. ";"│... ";"│....";"│~~~~"|]

printfn "┘"

[4005L;8017L;326205L;886205L]|>List.iter(fun n->printfn "%d" n; mayan n)

{{out}}

<pre>

</pre>

=={{header|Factor}}==

sequences ;

IN: rosetta-code.mayan-numerals

{ 4005 8017 326205 886205 } [ .mayan ] each ;

 

{{out}}

Mayan 4005:

|}

 

 

 

 

=={{header|Go}}==

 

import (

fmt.Println()

}

 

{{out}}

 

=={{header|Haskell}}==

import Data.List (intercalate, transpose)

import qualified Data.Map.Strict as M

leftPadded xs =

let w = maximum (length <$> xs)

{{Out}}

Mayan 4005:

 

=={{header|J}}==

 

digit =: (elems{~5:<.0:>.15 10 5 0-~])`((4 4$_14{.'@')&[)@.(0&=)

 

{{out}}

=={{header|Java}}==

Unicode characters used. See <code>Character.toChars</code>.

import java.math.BigInteger;

 

 

}

{{out}}

<pre>

 

=={{header|JavaScript}}==

'use strict';

 

// MAIN ---

return main();

{{Out}}

Mayan 4005:

'''Works with gojq, the Go implementation of jq'''

{{trans|Wren}}

{ ul: "╔",

uc: "╦",

# decimal number to base-20 array, most significant digit first

def dec2vig:

| reverse;

 

4005, 8017, 326205, 886205, 1081439556

{{out}}

<pre>

=={{header|Julia}}==

<h4> First version, using a style sheet, output to html, with the capability of proper style within the browser.</h4>

mayan_glyphs(x, y) = (x == 0 && y == 0) ? "\n<td>Θ</td>\n" : "<td>\n" * "●" ^ x * "<br />\n───" ^ y * "</td>\n"

 

testmayan()

<h4> Version 2, using local wiki style table formatting: translation of style code from the Raku version. </h4>

 

inttomayan(n) = (s = string(n, base=20); map(ch -> reverse(divrem(parse(Int, ch, base=20), 5)), split(s, "")))

 

testmayan()

{{out}}

 

 

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

MakeLengthFive[ci_String] := Module[{c},

c = If[EvenQ[StringLength[ci]], ci <> " ", ci];

MayanNumeral[326205]

MayanNumeral[886205]

{{out}}

Outputs a graphical representation of the cartouches.

{{trans|Go}}

Free adaptation of the Go version.

import algorithm

 

let mayans = digits.mapIt(it.toMayanNumeral)

mayans.draw()

 

{{out}}

{{trans|Raku}}

{{libheader|ntheory}}

 

my $t_style = '"border-collapse: separate; text-align: center; border-spacing: 3px 0px;"';

}

 

{{out}}

{| style="border-collapse: separate; text-align: center; border-spacing: 3px 0px;"

 

=={{header|PL/M}}==

THIS PROGRAM RUNS UNDER CP/M AND TAKES THE NUMBER ON THE COMMAND LINE */

 

CALL EXIT;

{{out}}

<pre style='height:50ex;'>A>MAYAN 4005

{{trans|Raku}}

Three-way output controlled by the first two constants.

<span style="color: #000080;font-style:italic;">-- demo\rosetta\Mayan_numerals.exw</span>

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (file i/o [when as_html is true])</span>

<span style="color: #0000FF;">{}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">wait_key</span><span style="color: #0000FF;">()</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

{{out}}

With inline_css set to false. Note these are always height-4.

 

=={{header|PureBasic}}==

Dim pl$(5)

pl$(0)=" Θ " : pl$(1)=" • " : pl$(2)=" •• "

ConsoleLocate(0,#START_Y+7) : Print("Dezimal = "+i$)

ConsoleLocate(0,#START_Y+8) : Print("Vigesimal= "+j$)

{{out}}

<pre>MAYAN: ?

=={{header|Python}}==

{{Works with|Python|3.7}}

 

from functools import (reduce)

# MAIN ---

if __name__ == '__main__':

{{Out}}

Mayan numeral representations of various integers:

These don't particularly resemble the Mayan cartouche, more like mahjong tiles actually. It would have been ''so'' much easier and more compact if I could have put all the styling into a CSS file instead of inlining it, but oh well, it was entertaining to do.

 

my $t-style = '"border-collapse: separate; text-align: center; border-spacing: 3px 0px;"';

my $c-style = '"border: solid black 2px;background-color: #fffff0;border-bottom: double 6px;'~

 

say @output.join: "\n$joiner\n";

 

{{out}}

Or, plain old text mode. Not as pretty, but still serviceable.

 

use Terminal::Boxer;

my $joiner = "\n";

}

 

 

{{out}}

 

=={{header|REXX}}==

parse arg $ /*obtain optional arguments from the CL*/

if $='' then $= 4005 8017 326205 886205, /*Not specified? Then use the default.*/

call $MAYAN # '(overlap)' /*invoke the $MAYAN (REXX) subroutine.*/

say

The &nbsp; '''$MAYAN.REX''' &nbsp; (REXX program) subroutine can be seen here &nbsp; ───► &nbsp; [[Mayan_numerals\$MAYAN.REX]].

 

</pre>

=={{header|Ruby}}==

if numbers.length == 0

puts

end

end

end

puts(('+----' * digits5s1s.length) + '+')

puts(num)

maya_print(num)

{{out}}

<pre>$ ruby mayan.rb 4005 8017 326205 886205 4294967296

 

=={{header|Rust}}==

const FIVE: &str = "——";

const ZERO: &str = "Θ";

}

mayan

{{out}}

<pre>

{{trans|Go}}

{{libheader|Wren-fmt}}

 

var ul = "╔"

draw.call(mayans)

System.print()

 

{{out}}

 

=={{header|zkl}}==

var ds=T(" "," \u2219 "," \u2219\u2219 ","\u2219\u2219\u2219 ","\u2219\u2219\u2219\u2219");

fcn mayan(m){ //--> lists of lists of strings (each line of tile)

String(fill*(3-bars), ds[dots],"\n", five*bars)[0,-1].split("\n") // tile

})

fcn displayMayan(m){ // eg 11 is ( ( ),( * ),(----),(----) )

println("\u2554", ut*(m.len()-1), hbar,"\u2557"); // top

foreach n in (4){ println(vbar, m.apply("get",n).concat(vbar), vbar) }

println("\u255a", bt*(m.len()-1), hbar,"\u255d"); // bottom

println("\n%,d:".fmt(m)); mayan(m):displayMayan(_);

{{out}}

<pre style="height:40ex">

The Raku numerals look so good, let's copy them.

{{trans|Raku}}

t_style=0''"border-collapse: separate; text-align: center; border-spacing: 3px 0px;"',

c_style=0''"border: solid black 2px;background-color: #fffff0;border-bottom: double 6px;'

}).replace("!","<br>") : display(m,_)

})

{{out}}

{| style="border-collapse: separate; text-align: center; border-spacing: 3px 0px;"