Box the compass: Difference between revisions

=={{header|11l}}==

{{trans|Python}}

majors *= 2

V quarter1 = ‘N,N by E,N-NE,NE by N,NE,NE by E,E-NE,E by N’.split(‘,’)

d -= 5.62

V n = i % 32 + 1

{{out}}

<pre>

Atari 8-bit computer is able to show up to 40 characters per row. Therefore abbreviations of direction have been used instead of the full names.

{{libheader|Action! Tool Kit}}

INCLUDE "D2:REAL.ACT" ;from the Action! Tool Kit

Position(x,y) PrintAngle(rh)

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Box_the_compass.png Screenshot from Atari 8-bit computer]

Inspired by [[#C++|the C++ program]], but without the need for a specific library.

procedure Box_The_Compass is

Put_Line(Degrees(Degrees'Base(I) * 11.25 + Difference(I mod 3)));

end loop;

Output:

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

[]STRING

))

OD

Output:

<pre>

Functional composition, allowing for additional languages, and different numbers of compass points – see the test section)

use scripting additions

((ca's NSString's stringWithString:(str))'s ¬

uppercaseStringWithLocale:(ca's NSLocale's currentLocale())) as text

{{Out}}

<pre> 1 0.00° North 北

{{trans|C++}}

{{works with|AutoHotkey_L}}

return Mod(floor(angle / 11.25 +0.5), 32) + 1

}

. " ", 1, 24) . SubStr(" " a, -5) . "`r`n" ;

}

;Output

<pre> 1 North 0.00

=={{header|AutoIt}}==

Local $avArray[33] = [0.0, 16.87, 16.88, 33.75, 50.62, 50.63, 67.5, 84.37, 84.38, 101.25, 118.12, 118.13, 135.0, _

151.87, 151.88, 168.75, 185.62, 185.63, 202.5, 219.37, 219.38, 236.25, 253.12, 253.13, 270.0, 286.87, 286.88, _

StringFormat("%-20s", $namearray[Mod(Floor($Degree / 11.25 + 0.5), 32)]) & " : " & $Degree & @CRLF)

EndFunc ;==>Boxing_the_compass

Output : <pre>0 : North : 0

=={{header|AWK}}==

BEGIN {

split("N NbE NNE NEbN NE NEbE ENE EbN E EbS ESE SEbE SE SEbS SSE SbE S SbW SSW SWbS SW SWbW WSW WbS W WbN WNW NWbW NW NWbN NNW NbW",A," ");

printf "%6.2f : %2d\t%s\n",$1,box,A[box];

}

Output:

<pre> 0.00 : 1 N

=={{header|BASIC256}}==

dim names$ = {"North", "North by east", "North-northeast", "Northeast by north", "Northeast", "Northeast by east", "East-northeast", "East by north", "East", "East by south", "East-southeast", "Southeast by east", "Southeast", "Southeast by south", "South-southeast", "South by east", "South", "South by west", "South-southwest", "Southwest by south", "Southwest", "Southwest by west", "West-southwest", "West by south", "West", "West by north", "West-northwest", "Northwest by west", "Northwest", "Northwest by north", "North-northwest", "North by west", "North"}

if j > 31 then j -= 32

print rjust(string(j),2); " "; ljust(string(names$[j+1]),20); grados[i]

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

bearing() = 0.0, 16.87, 16.88, 33.75, 50.62, 50.63, 67.5, 84.37, \

\ 84.38, 101.25, 118.12, 118.13, 135.0, 151.87, 151.88, 168.75, \

pt$() = "north", "east", "south", "west"

= pt$(pt% DIV 8)

Output:

<pre>0 1 North

=={{header|Befunge}}==

^_@#!`*84:+1<v*9"}"*+55,,,".",,,$$_^#!:-1g60/+55\<

>_06g:v>55+,^>/5+55+/48*::::,,,,%:1+.9,:06p48*\-0v

W>0"tsaE"0"htron yb tsaE"0"tsaehtron-tsaE"0"tsae"v

#v"rtheast by north"0"Northeast"0"Northeast by "<<

{{output}}

Like [[wp:Box the compass|Wikipedia's article]], this program uses indexes to count the headings. There are now 33 headings, from 1 to 33, because 0.0 and 354.38 are different angles. (This differs from the task pseudocode, which mapped the 32 compass points to indexes.)

int main()

return 0;

<pre>

1 North 0.00

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

using System;

using System.Collections.Generic;

}

}

{{out}}

<pre>

Using the Boost libraries

{{libheader|Boost}}

#include <boost/array.hpp>

#include <boost/assign/list_of.hpp>

}

return 0;

Output:

<pre>

=={{header|Clojure}}==

{{trans|Tcl}}

(:use [clojure.string :only [capitalize]]))

(apply str (map-indexed #(format "%2s %-18s %7.2f\n"

(inc (mod %1 32)) (angle2compass %2) %2)

Output:

<pre> 1 North 0.00

=={{header|COBOL}}==

Works with GnuCOBOL

program-id. box-compass.

data division.

display compass-point space show-degrees

end-perform

{{out}}

=={{header|D}}==

{{trans|Java}}

struct boxTheCompass {

heading.boxTheCompass, heading);

}

{{out}}

<pre>1 North 0

===Alternative version===

import std.stdio;

writefln("%2d %18s %6.2f", i + 1, box[i], phi);

}

{{out}}

<pre> 1 North 0.00

=={{header|Elixir}}==

{{trans|Ruby}}

defp head do

Enum.chunk(~w(north east south west north), 2, 1)

end

{{out}}

=={{header|Euphoria}}==

"Northeast","Northeast by east","East-northeast","East by north","East",

"East by south","East-southeast","Southeast by east","Southeast","Southeast by south",

j = deg2ind(degrees[i])

printf(1, "%6.2f %2d %-22s\n", {degrees[i], j, names[j]})

Output:

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

{{trans|Perl}}

"North"; "North by east"; "North-northeast"; "Northeast by north";

"Northeast"; "Northeast by east"; "East-northeast"; "East by north";

|> List.iter (fun phi ->

let i = (int (phi * 32. / 360. + 0.5)) % 32

{{out}}

<pre> 1 North 0.00°

=={{header|Factor}}==

CONSTANT: box

dup 32 * 360 /f 0.5 + >integer 32 mod [ 1 + ] [ box nth ] bi

"%6.2f° %2d %s\n" printf

{{out}}

<pre>

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

implicit none

compasspoint = points(int(x))

end function compasspoint

Output:

<pre>

=={{header|FreeBASIC}}==

' compile with: fbc -s console

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre> 0.00 0 North

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=823a56ac094b8963cf11f792b381fbcc Click this link to run this code]'''

Dim fDeg As Float[] = [0.0, 16.87, 16.88, 33.75, 50.62, 50.63, 67.5, 84.37, 84.38, 101.25, 118.12, 118.13, 135.0, 151.87, 151.88, 168.75, 185.62, 185.63, 202.5, 219.37, 219.38, 236.25, 253.12, 253.13, 270.0, 286.87, 286.88, 303.75, 320.62, 320.63, 337.5, 354.37, 354.38]

Dim cHeading As Collection = ["N": "North", "S": "South", "W": "West", "E": "East", "b": "by"]

Next

Output:

<pre>

=={{header|Go}}==

import "fmt"

fmt.Printf("%4d %-19s %7.2f°\n", index, degrees2compasspoint(h), h)

}

<pre>

Index Compass point Degree

=={{header|Groovy}}==

def cardinalDirections = ["north", "east", "south", "west"]

354.37, 354.38].eachWithIndex { angle, index ->

println "${(index % 32) + 1}".padRight(3) + "${angle.asCompassPoint().padLeft(20)} $angle\u00b0"

Output:

<pre>1 North 0.0°

=={{header|Haskell}}==

import Data.Maybe (fromMaybe)

main :: IO ()

Output:

<pre> 1 North 0.00°

=={{header|Huginn}}==

import Text as text;

print( "{:2d} | {:6.2f}° | {}\n".format( n, d, c.degrees_to_compasspoint( d ) ) );

}

Output:<pre> # | Angle | Compass point

---+---------|-------------------

=={{header|Icon}} and {{header|Unicon}}==

{{incomplete|Icon|354.38?}}

procedure main()

return dirs[round(((((d%360)+360)%360)/11.25)%32 + 1)]

{{libheader|Icon Programming Library}}

=={{header|IS-BASIC}}==

110 STRING DR$(1 TO 33)*18

120 FOR I=1 TO 33

210 DATA North,North by east,North-northeast,Northeast by north,Northeast,Northeast by east,East-northeast,East by north,East,East by south,East-southeast,Southeast by east,Southeast,Southeast by south,South-southeast,South by east

220 DATA South,South by west,South-southwest,Southwest by south,Southwest,Southwest by west,West-southwest,West by south,West,West by north,West-northwest,Northwest by west,Northwest,Northwest by north,North-northwest,North by west,North

Output:<pre> 0 1 North

=={{header|J}}==

subs=: 'N,north,S,south,E,east,W,west,b, by ,'

dirs=: subs (toupper@{., }.)@rplc~L:1 0&(<;._2) 0 :0 -. ' ',LF

)

indice=: 32 | 0.5 <.@+ %&11.25

Example use:

0 1 2 3 4 5 6 7 8 9

deg2pnt i.10

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

│North│North│North│North│North│North│North by east│North by east│North by east│North by east│

Required example:

1 North 0

2 North by east 16.87

31 North-northwest 337.5

32 North by west 354.37

=={{header|Java}}==

{{trans|Visual Basic .NET}}

private static String[] points = new String[32];

return points[(int)Math.floor(testD % 32)];

}

Output:

<pre>1 North 0.0°

An iterative, web-based approach:

var tr = document.createElement('tr'),

td;

table.appendChild(tbody);

document.body.appendChild(table);

Output:

<pre>1 North 0°

Functional composition, allowing for additional languages (and different numbers of compass points)

'use strict';

return compassTable(5, xs); // 2^5 -> 32 boxes

{{Out}}

{{trans|Python}}

function degree2compasspoint(d::Float64)

i % 3 == 2 && (d -= 5.62)

@printf("%2i %-17s %10.2f°\n", i % 32 + 1, degree2compasspoint(d), d)

{{out}}

The representation of the names was inspired by Tcl (etc.).

d,:("E;Ebs;E-se;Sebe;Se;Sebs;S-se;Sbe;")

d,:("S;Sbw;S-sw;Swbs;Sw;Swbw;W-sw;Wbs;")

/ calculate the degrees

The table:

1 North 0.00

2 North by east 16.87

31 North-northwest 337.50

32 North by west 354.37

=={{header|Kotlin}}==

fun expand(cp: String): String {

println(f.format(index + 1, heading, expand(cp[index])))

}

{{out}}

{{trans|D}}

{{works with|langur|0.6.13}}

"Northeast", "Northeast by east", "East-northeast", "East by north",

"East", "East by south", "East-southeast", "Southeast by east",

val .i = truncate(.phi x 32 / 360 + 0.5) rem 32 + 1

writeln $"\.i:5; \.phi:r2:6; \.box[.i];"

{{out}}

=={{header|Lasso}}==

local(points = array)

loop(-from=0,-to=32) => {

#pformatted + ' | ' + (#counter < 10 ? ' ') + #counter + ' | ' + compassLong(compassShort->get(#counter)) + '\r'

{{out}}

=={{header|Liberty BASIC}}==

for i =1 to 32

data "West by south ", "West ", "West by north ", "West-northwest "

data "Northwest by west ", "Northwest ", "Northwest by north", "North-northwest "

Output:

=={{header|LLVM}}==

{{trans|C}}

; LLVM does not provide a way to print values, so the alternative would be

; to just load the string into memory, and that would be boring.

attributes #0 = { noinline nounwind optnone uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }

{{out}}

<pre> 1 North 0.00

=={{header|Logo}}==

make "compass_points [ N NbE N-NE NEbN NE NEbE E-NE EbN

E EbS E-SE SEbE SE SEbS S-SE SbE

; and exit

bye

Output:

=={{header|Lua}}==

{{trans|Logo}}

compass_points = { "N", "NbE", "N-NE", "NEbN", "NE", "NEbE", "E-NE", "EbN",

"E", "EbS", "E-SE", "SEbE", "SE", "SEbS", "S-SE", "SbE",

label = expand_point(abbr)

print(row_format:format(angle, label, index))

Output:

In a For Next loop we can change loop variable inside block, but the actual loop hidden variable can't change so for next iteration we get the proper value.

Module CheckIt {

Locale 1033 'change decimal point char to dot.

}

CheckIt

{{out}}

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

<pre>1 North 0.°

2 North by east 16.87°

=={{header|MATLAB}} / {{header|Octave}}==

b = ceil(mod(d+360/64,360)*32/360);

Output:

<pre>>> x=[0.0, 16.87, 16.88, 33.75, 50.62, 50.63, 67.5, 84.37, 84.38, 101.25, 118.12, 118.13, 135.0, 151.87, 151.88, 168.75, 185.62, 185.63, 202.5, 219.37, 219.38, 236.25, 253.12, 253.13, 270.0, 286.87, 286.88, 303.75, 320.62, 320.63, 337.5, 354.37, 354.38]';

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

FROM FormatString IMPORT FormatString;

FROM RealStr IMPORT RealToStr;

ReadChar

=={{header|MUMPS}}==

The TCL implementation was the starting point, but this isn't an exact translation.

;This takes in a degree heading, nominally from 0 to 360, and returns the compass point name.

QUIT:((DEGREE<0)||(DEGREE>360)) "land lubber can't read a compass"

. WRITE $PIECE(X,"^"),?5,DIR,?40,$JUSTIFY($PIECE(POINTS,",",P),10,2),!

KILL POINTS,UP,LO,DIR,P,X

<p>Output:<pre>

Debugger executing 'BOXWRITE^COMPASS'

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols nobinary utf8

return table

;Output

=={{header|Nim}}==

const

index = heading.toCompassIndex

compassHeading = heading.toCompassHeading.alignLeft(maxNameLength)

Output:

<pre> 1 North 0.00

=={{header|Objeck}}==

class BoxCompass {

function : Main(args : String[]) ~ Nil {

}

}

Output

=={{header|OCaml}}==

let test_cases = [0.0; 16.87; 16.88; 33.75; 50.62; 50.63; 67.5;

84.37; 84.38; 101.25; 118.12; 118.13; 135.0;

List.iter (print_direction) test_cases;;

Sample output:

<pre>

=={{header|OoRexx}}==

Do

End

Exit

;Output

=={{header|PARI/GP}}==

"Northeast by east","East-northeast","East by north","East","East by south","East-southeast",

"Southeast by east","Southeast","Southeast by south","South-southeast","South by east","South",

"West by south","West","West by north","West-northwest","Northwest by west","Northwest",

"Northwest by north","North-northwest","North by west"][round(x*4/45)%32+1]};

Output:

=={{header|Pascal}}==

{{trans|Fortran}}

function compasspoint(angle: real): string;

writeln((i mod 32) + 1:2, ' ', compasspoint(heading), ' ', heading:8:4);

end;

Output:

<pre>

=={{header|Perl}}==

Don't waste brain cells calculating names, not worth the effort. Code is probably shorter, faster, and easier to read this way.

my @names = (

my $i = int(($_ * 32 / 360) + .5) % 32;

printf "%3d %18s %6.2f°\n", $i + 1, $names[$i], $_;

2 North by east 16.87°

3 North-northeast 16.88°

31 North-northwest 337.50°

32 North by west 354.37°

=={{header|Phix}}==

Unlike the Perl guy, for me the maths is the boring bit, building those strings is the fun!<br>

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">get225</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">d</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">p1</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">p2</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">p4</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"%2d %-22s %6.2f\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">compass_point</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">compass_points</span><span style="color: #0000FF;">[</span><span style="color: #000000;">compass_point</span><span style="color: #0000FF;">],</span> <span style="color: #000000;">test_point</span><span style="color: #0000FF;">})</span>

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

If you like, you can regard d=1 (both of them) as "clockwise-name-inherit" and d=0 as "anti-clockwise-name-inherit".<br>

{{out}}

</pre>

of course the following (more sensible but less fun, full standalone program) way works just as well, and produces the same output

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">compass_points</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span> <span style="color: #008000;">"North"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"North by east"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"North-northeast"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Northeast by north"</span><span style="color: #0000FF;">,</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"%2d %-22s %6.2f\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">compass_point</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">compass_points</span><span style="color: #0000FF;">[</span><span style="color: #000000;">compass_point</span><span style="color: #0000FF;">],</span> <span style="color: #000000;">test_points</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]})</span>

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

=={{header|Picat}}==

{{trans|Nim}}

Names = ["North", "North by east", "North-northeast", "Northeast by north",

"Northeast", "Northeast by east", "East-northeast", "East by north",

printf("%2d %-20s %6.2f\n", J+1, Names[J+1], D)

end,

{{out}}

=={{header|PicoLisp}}==

(setq *Compass # Build lookup table

NIL

(cdr (heading H))

Output:

<pre> 1 north 0.00

=={{header|PowerShell}}==

{

$x = 0.0, 16.87, 16.88, 33.75, 50.62, 50.63, 67.5, 84.37, 84.38, 101.25, 118.12, 118.13, 135.0, 151.87, 151.88, 168.75, 185.62, 185.63, 202.5, 219.37, 219.38, 236.25, 253.12, 253.13, 270.0, 286.87, 286.88, 303.75, 320.62, 320.63, 337.5, 354.37, 354.38

{{out}}

<pre>north

north</pre>

A more general solution allowing you to choose whether to use 4, 8, 16, or 32 compass points.

{

8 = ( Convert-DegreeToDirection -Degree $Degree -Points 8 )

4 = ( Convert-DegreeToDirection -Degree $Degree -Points 4 ) } }

{{out}}

<pre>Degree 32 16 8 4

=={{header|Prolog}}==

Part 1 : The following knowledge base takes a heading in degrees and returns the correct 32-point compass heading. It can also go in the other direction.

compassangle(1, 'North',n, 0.00).

compassangle(2, 'North by east', nbe, 11.25).

resolveindex(Angle, Index) :- N is Angle / 11.25 + 0.5, I is floor(N),Index is (I mod 32) + 1.

Part 2 : The following rules print a table of indexes.

printTableRow(Angle) :- compassangle(Index, Name, _, Angle),

write(Index), write(' '),

printTable([X|Xs]) :- printTableRow(X), nl, printTable(Xs),!.

printTable([]).

The following query prints the required table.

?- printTable([0.0, 16.87, 16.88, 33.75, 50.62, 50.63, 67.5, 84.37, 84.38, 101.25, 118.12, 118.13, 135.0, 151.87, 151.88, 168.75, 185.62,

185.63, 202.5, 219.37, 219.38, 236.25, 253.12, 253.13, 270.0, 286.87, 286.88, 303.75, 320.62, 320.63, 337.5, 354.37, 354.38]).

1 North 354.38

true.

=={{header|PureBasic}}==

Data.s "N", "north", "E", "east", "W", "west", "S", "south", "b", " by " ;abbreviations, expansions

Data.s "N NbE N-NE NEbN NE NEbE E-NE EbN E EbS E-SE SEbE SE SEbS S-SE SbE" ;dirs

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

Sample output:

<pre> 1 North 0.00

=={{header|Python}}==

majors *= 2 # no need for modulo later

quarter1 = 'N,N by E,N-NE,NE by N,NE,NE by E,E-NE,E by N'.split(',')

elif m == 2: d -= 5.62

n = i % 32 + 1

;Output

{{works with|QuickBasic|4.5}}

{{trans|Liberty BASIC}}

DIM SHARED point$(32)

IF (x >= 33!) THEN x = x - 32!

compasspoint$ = point$(INT(x))

R (also known as Arrr me hearties!) is ideally suited to this task. Here's an easy to understand but inefficient way to solve it:

# Build a table of directions

pts <- data.frame(

res[1,]$des[1]

})

Here are the test inputs:

test <- data.frame(

deg = c( 0.0, 16.87, 16.88, 33.75, 50.62, 50.63, 67.5, 84.37,

test$heading <- heading(test$deg)

test

Check that the output headings cover the full range of headings:

all.equal(test$heading, pts$des)

{{out}}

=={{header|Racket}}==

;;; Generate the headings and boxes

(check-= (heading->box 5.62) 1 0)

(check-= (heading->box 5.63) 2 0)

Output:

(formerly Perl 6)

{{works with|Rakudo|2015.12}}

my $ix = $index % 32;

if $ix +& 1

𝜽,

tc point angle-to-point 𝜽;

Output:

1 354.38° North</pre>

=={{header|Red}}==

d: charset [#"N" #"E" #"S" #"W"] ;; main directions

hm/:heading: reduce [ (i % 32 + 1 ) expand to-string compass-points/1 [N north b " by " S south E east W west] ]

print-line heading

'''output'''

<pre>

=={{header|REXX}}==

This version does normalization of the (degree) heading and can also handle negative headings.

parse arg $ /*allow º headings to be specified.*/

if $='' then $= 0 16.87 16.88 33.75 50.62 50.63 67.5 84.37 84.38 101.25 118.12 118.13 ,

z= changestr( left(d, 1), z, d)

end /*k*/ /* [↑] old, haystack, new*/

Some older REXXes don't have a &nbsp; '''changestr''' &nbsp; BIF, &nbsp; so one is included here &nbsp; ──► &nbsp; [[CHANGESTR.REX]].

<br><br>

=={{header|Ring}}==

# Project : Box the compass

ok

next

Output:

<pre>

=={{header|Ruby}}==

[a,

"#{a} by #{b}",

index, name = heading degrees

printf "%2d %20s %6.2f\n", index, name.center(20), degrees

{{output}}

=={{header|Run BASIC}}==

dim direct$(22)

direct$(1) = "y" 'by

data "N","N b e","N-ne","Ne b n","Ne","Ne b e","E-ne","E b n","E","E b s","E-se"

data "Se b e","Se","Se b s","S-se","S b e","S","S b w","S-sw","Sw b s","Sw","Sw b w"

<code><table border=1>

<TR><TD align=right>1</td><td>North</td><td>0.0</td></tr>

=={{header|Rust}}==

{{trans|Kotlin}}

let mut out = String::new();

for c in cp.chars() {

);

}

{{out}}

<pre>Index Degrees Compass point

=={{header|Scala}}==

Inspired by Java version

val cardinal = List("north", "east", "south", "west")

val pointDesc = List("1", "1 by 2", "1-C", "C by 1", "C", "C by 2", "2-C", "2 by 1")

(0 to 32).map(i=>Triple(pointDeg(i),deg2ind(pointDeg(i)),pointName(deg2ind(pointDeg(i)))))

.map{t=>(printf("%s\t%18s\t%s°\n",t._2,t._3,t._1))}

Output:

=={{header|Seed7}}==

include "float.s7i";

degrees[index] digits 2 lpad 6);

end for;

Output:

=={{header|Sidef}}==

{{trans|Raku}}

var ix = (index % 32);

if (ix & 1) { "#{point((ix + 1) & 28)} by #{point(((2 - (ix & 2)) * 4) + ix & 24)}" }

var 𝜽 = test_angle(ix);

printf(" %2d %6.2f° %s\n", ix % 32 + 1, 𝜽, point(angle_to_point(𝜽)).tc);

{{out}}

<pre>

=={{header|smart BASIC}}==

GET SCREEN SIZE sw,sh

OPTION BASE 1

DATA "Northwest", "NW", "309.38", "315.00", "320.62", "Northwest by north", "NWbN", "320.63", "326.25", "331.87"

DATA "North-northwest", "NNW", "331.88", "337.50", "343.12", "North by west", "NbW", "343.13", "348.75", "354.37"

Output:

<pre>

=={{header|Tcl}}==

set dirs {

N NbE N-NE NEbN NE NEbE E-NE EbN E EbS E-SE SEbE SE SEbS S-SE SbE

# Pretty-print the results of converting an angle to a compass heading

puts [format "%2i %-18s %7.2f°" $index [angle2compass $heading] $heading]

Output:

<pre>

=={{header|True BASIC}}==

{{trans|QBasic}}

FUNCTION compasspoint$ (h)

PRINT ind, compasspoint$(heading), heading

NEXT i

=={{header|uBasic/4tH}}==

{{trans|C}}

Since uBasic is an integer interpreter, we have to do some scaling to perform this task.

Push 13500, 15187, 15188, 16875, 18562, 18563, 20250, 21937, 21938, 23625

Push 25312, 25313, 27000, 28687, 28688, 30375, 32062, 32063, 33750, 35437

400 Print "North-northwest "; : Return

410 Print "North by west "; : Return

{{out}}

<pre>

Requires the standard POSIX bc(1) command to perform floating-point arithmetic.

compass_points=( N NbE N-NE NEbN NE NEbE E-NE EbN

E EbS E-SE SEbE SE SEbS S-SE SbE

label="$(expand_point $abbr)"

printf "$row_format" $angle "$label" $index

Output: <pre>Degrees | Closest Point | Index

=={{header|VBA}}==

Dim compass_point As Integer

Dim compass_points_all As New Collection

Debug.Print test_points_all(i)

Next i

<pre> 1 North 0

2 North by east 16,87

=={{header|Visual Basic .NET}}==

Dim _points(32) As String

End Function

End Module

Output:

<pre>

{{trans|Go}}

{{libheader|Wren-fmt}}

// 'cpx' returns integer index from 0 to 31 corresponding to compass point.

System.print("%(Fmt.d(4, index)) %(Fmt.s(-19, d)) %(Fmt.f(7, h, 2))°")

i = i + 1

{{out}}

=={{header|Yabasic}}==

{{trans|Liberty BASIC}}

dim point$(32)

70 data "West by south ", "West ", "West by north ", "West-northwest "

80 data "Northwest by west ", "Northwest ", "Northwest by north", "North-northwest "

=={{header|zkl}}==

{{trans|AWK}}

"SEbE SE SEbS SSE SbE S SbW SSW SWbS SW SWbW "

"WSW WbS W WbN WNW NWbW NW NWbN NNW NbW").split(" ");

box:=compassBox(heading);

println("%6.2f\UB0; : %2d\t%s".fmt(heading,box,A[box]));

{{out}}

<pre>

=={{header|ZX Spectrum Basic}}==

{{trans|Liberty BASIC}}

20 DATA "Northeast by north","Northeast","Northeast by east","East-northeast"

30 DATA "East by north","East","East by south","East-southeast"

250 STOP

260 DEF FN m(i,n)=((i/n)-INT (i/n))*n : REM modulus function