Old Russian measure of length: Difference between revisions

:<code>commandname <value> <unit></code>

 

‘fut’ = 0.3048, ‘kilometer’ = 1000.0, ‘liniya’ = 0.00254,

‘meter’ = 1.0, ‘milia’ = 7467.6, ‘piad’ = 0.1778,

print(‘#. #. to:’.format(value, unit))

L(unt, mlt) sorted(unit2mult.items())

 

{{out}}

versta: 0.000937383

</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f OLD_RUSSIAN_MEASURE_OF_LENGTH.AWK

BEGIN {

printf("error: invalid measure; choose from: %s\n\n",units)

}

{{out}}

<pre>

</pre>

 

@% = &90E

PROColdrus(1, "meter")

NEXT

ENDIF

{{out}}

<pre>1 meter =

2800 liniya

28000 tochka</pre>

 

=={{header|C}}==

Accepts length and unit as input, prints out length in all other units. Usage printed on incorrect invocation.

#include<string.h>

#include<stdlib.h>

return 0;

}

Output :

<pre>

 

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

#include <iostream>

#include <iomanip>

}

//-------------------------------------------------------------------------------------------

Output:

<pre>

=={{header|D}}==

{{trans|Raku}}

 

void main(in string[] args) {

foreach (immutable key; factor.keys.schwartzSort!(k => factor[k]))

writefln("%10s: %s", key, meters / factor[key]);

{{out}}

<pre>1 meter to:

{{libheader| System.SysUtils}}

{{Trans|Go}}

program Old_Russian_measure_of_length;

 

readln(yn);

until yn.toLower = 'n';

 

=={{header|Elena}}==

{{trans|Julia}}

import system'routines;

import extensions;

{

if (program_arguments.Length != 3)

real value := program_arguments[1].toReal();

{

console.printLine("only following units are supported:",

AbortException.raise()

console.printLine(value," ",unit," to:");

 

{

console.printPaddingLeft(30, u, ":").printLine(value * unit2mult[unit] / mlt)

}

{{out}}

<pre>2.3 meter to:

=={{header|Factor}}==

This solution makes use of Factor's rather robust <code>units</code> vocabulary. Units may be defined in terms of any unit and converted to any unit through the power of inverse functions (via the <code>inverse</code> vocabulary). This means that we also have access to a variety of units defined in <code>units.si</code>, <code>units.imperial</code>, etc.

sequences units.imperial units.si vocabs ;

IN: rosetta-code.units.russian

PRIVATE>

 

{{out}}

<pre>

 

=={{header|Fortran}}==

IMPLICIT NONE

REAL, PARAMETER:: E_m = 1.

WRITE (*, '(F20.3, " ", A)') RD_V / wert(J), nam(J)

END DO

{{out}}

<pre>m mm km cm arshin fut piad vershok dyuim liniya tochka ladon lokot sazhen versta milya

10.000 arshin</pre>

 

=={{header|Forth}}==

Tested with GForth.

create values 1000.0e f, 1.0e f, 0.01e f, 0.000254e f, 0.00254e f, 0.0254e f, 0.04445e f, 0.1778e f, 0.3048e f, 0.7112e f, 2.1336e f, 1066.8e f, 7467.6e f,

: unit ( u1 -- caddr u1 )

1e s" meter" show

20e s" versta" show

{{out}}

<pre>

 

 

</pre>

 

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

}

}

 

{{out}}

=={{header|Haskell}}==

 

 

import Text.Printf (printf)

(_) -> do

name <- getProgName

 

Output:

=={{header|J}}==

Translation of python.

 

else.

else.

end.

end.

end.

)

<pre>

8 meter to:

┌──────────┬──────────┐

│versta │0.00749906│

└──────────┴──────────┘

</pre>

 

=={{header|Java}}==

 

final static String[] keys = {"tochka", "liniya", "centimeter", "diuym",

return Double.NaN;

}

 

<pre>1 meter to:

versta: 7,00000

milia: 1,00000</pre>

 

=={{header|Julia}}==

{{trans|Python}}

 

 

const unit2mult = Dict(

for (unt, mlt) in sort(unit2mult)

@printf(" %10s: %g\n", unt, value * unit2mult[unit] / mlt)

 

{{out}}

=={{header|Kotlin}}==

{{trans|FreeBASIC}}

 

/* clears console on Windows 10 */

}

while (yn == "y")

Sample input/output

{{out}}

Do another one y/n : n

</pre>

 

=={{header|МК-61/52}}==

П9 ИП7 1 0 6 7 / П0 5 0

0 * ПC 3 * ПA 1 6 * ПB

С/П ПB 1 6 / ПA 3 / ПC 5

0 0 / П0 1 0 6 7 / БП

 

''Instruction:''

100 m = 2249,2971 vershoks = 140,58107 arshins = 46,860366 sazhens = 0,093790712 versts;

3 vershoks = 13,3375 cm; 2 sazhens = 96 vershoks = 6 arshins = 4,268 m; 1 verst = 1,067 km.

 

=={{header|Perl}}==

Displaying converted values to 5 significant digits.

{{trans|Raku}}

my($magnitude, $unit) = @_;

my %factor = (

 

print convert(1,'meter'), "\n\n";

{{out}}

<pre> tochka: 3937.0

 

=={{header|Phix}}==

{{out}}

<pre>

:<code>commandname <value> <unit></code>

 

unit2mult = {"arshin": 0.7112, "centimeter": 0.01, "diuym": 0.0254,

print("%g %s to:" % (value, unit))

for unt, mlt in sorted(unit2mult.items()):

 

{{out}}

=={{header|Racket}}==

Follows the Raku solution, produces similar output.

#lang racket

 

(show 'meter)

(show 'milia)

 

=={{header|Raku}}==

Fairly straightfoward. Define a hash of conversion factors then apply them. Makes no attempt to do correct pluralization because I have no idea what the correct plurals are and little interest in researching them. Conversion factors from Wikipedia: [[wp:Obsolete_Russian_units_of_measurement#Length|Obsolete Russian units of measurement]].

 

 

say '*' x 40, "\n";

for %factor.keys.sort:{ +%factor{$_} }

}

 

<pre>

::* &nbsp; uses the correct length unit names when not plural

::* &nbsp; columnarized the output &nbsp; (instead of a horizontal stream).

numeric digits 200 /*lots of digits. */

/*──translation───*/

err: say center(' error ', sw % 2, "*"); do j=1 to arg(); say arg(j); end; exit 13

s: if arg(1)=1 then return arg(3); return word( arg(2) 's', 1) /*plurals.*/

This REXX program makes use of &nbsp; '''LINESIZE''' &nbsp; REXX program (or BIF) which is used to determine the screen width (or linesize) of the terminal (console).

 

 

=={{header|Ring}}==

# Project : Old Russian measure of length

 

end

end

Output:

<pre>

centimeter : 10000

meter : 100

</pre>

 

:<code>commandname <value> <unit></code>

 

use std::process;

use std::collections::HashMap;

 

}

<pre>

$ ./oldrus test

 

=={{header|Scala}}==

 

object OldRussianLengths extends App {

} else println("Please provide a number and unit on the command line.")

 

 

=={{header|Sidef}}==

{{trans|Raku}}

var factor = Hash(

tochka => 0.000254,

convert(1, 'meter')

say('')

{{out}}

<pre>1 meter to:

Tcllib already has a [http://core.tcl.tk/tcllib/doc/trunk/embedded/www/tcllib/files/modules/units/units.html units] package which knows about a lot of things, and can be taught more. Since the other examples in this page provide a nicely tabulated conversions for 1 meter, we can copy that directly to get started ...

 

package require units

 

add_russian_units

demo

 

{{out}}

One nice side effect of this implementation is that units can work with more complex dimensions:

 

% units::convert "1 piad^2" "hectare"

3.1612805858160454e-6

% units::convert "100 km/h" "versta/minute"

1.562305

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

{{libheader|Wren-str}}

 

var units = [

if (yn == "n") break

System.print()

 

{{out}}

centimeter : 10000.0

meter : 100.0

 

Do another one y/n : n