Convert seconds to compound duration: Difference between revisions
Convert seconds to compound duration (view source)
Revision as of 22:55, 12 April 2024
, 2 months ago→{{header|langur}}
m (→{{header|Haskell}}: foldl -> foldr, and dropped a few (++)) |
Langurmonkey (talk | contribs) |
||
| (107 intermediate revisions by 41 users not shown) | |||
Line 4:
;Task:
Write a function or program which:
* takes a positive integer representing a duration in seconds as input (e.g., <code>100</code>), and
* returns a string which shows the same duration decomposed into
:::* weeks,
:::* days,
:::* hours,
:::* minutes, and
:::* seconds.
This is detailed below (e.g., "<code>2 hr, 59 sec</code>").
Demonstrate that it passes the following three test-cases:
<p style="font-size:115%; margin:1em 0 0.5em 0">'''''Test Cases'''''</p>
:::::{| class="wikitable"
|-
! input number
Line 29 ⟶ 36:
<p style="font-size:115%; margin:1em 0 0.5em 0">'''''Details'''''</p>
The following five units should be used:
:::::{| class="wikitable"
|-
! unit
Line 51 ⟶ 57:
| minute
| <code style="background:#eee">min</code>
| 1
|-
| second
Line 57 ⟶ 63:
|
|}
Mimic the formatting shown in the test-cases (quantities sorted from largest unit to smallest and separated by comma+space; value and unit of each quantity separated by space).
<hr style="margin:1em 0;"/>
<br><br>
=={{header|11l}}==
{{trans|Julia}}
<syntaxhighlight lang="11l">F duration(=sec)
[Int] t
L(dm) [60, 60, 24, 7]
Int m
(sec, m) = (sec I/ dm, sec % dm)
t.insert(0, m)
t.insert(0, sec)
R zip(t, [‘wk’, ‘d’, ‘hr’, ‘min’, ‘sec’]).filter(num_unit -> num_unit[0] > 0).map(num_unit -> num_unit[0]‘ ’num_unit[1]).join(‘, ’)
print(duration(7259))
print(duration(86400))
print(duration(6000000))</syntaxhighlight>
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
{{libheader|Action! Real Math}}
<syntaxhighlight lang="action!">INCLUDE "H6:REALMATH.ACT"
DEFINE PTR="CARD"
TYPE Time=[BYTE s,m,h,d,w]
CARD ARRAY units(5)
PROC Convert(REAL POINTER seconds Time POINTER t)
BYTE ARRAY b,duration=[60 60 24 7]
BYTE i
REAL r,n
b=t
FOR i=0 TO 3
DO
IntToReal(duration(i),n)
RealMod(seconds,n,r)
b(i)=RealToInt(r)
RealDivInt(seconds,n,r)
RealAssign(r,seconds)
OD
b(4)=RealToInt(seconds)
RETURN
PROC PrintTime(Time POINTER t)
INT i
BYTE first,n
BYTE ARRAY b
b=t i=4 first=1
WHILE i>=0
DO
n=b(i)
IF n>0 THEN
IF first=0 THEN
Print(", ")
ELSE
first=0
FI
PrintF("%B %S",n,units(i))
FI
i==-1
OD
RETURN
PROC Test(CHAR ARRAY s)
REAL seconds
Time t
ValR(s,seconds)
PrintR(seconds) Print(" -> ")
Convert(seconds,t)
PrintTime(t) PutE()
RETURN
PROC Main()
Put(125) PutE() ;clear the screen
MathInit()
units(0)="sec" units(1)="min"
units(2)="hr" units(3)="d"
units(4)="wk"
Test("7259")
Test("86400")
Test("6000000")
RETURN
</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Convert_seconds_to_compound_duration.png Screenshot from Atari 8-bit computer]
<pre>
259 -> 2 hr, 59 sec
86400 -> 1 d
6000000 -> 9 wk, 6 d, 10 hr, 40 min
</pre>
=={{header|Ada}}==
<
procedure Convert is
Line 113 ⟶ 207:
IO.New_Line;
end loop;
end Convert;</
{{out}}
Line 126 ⟶ 220:
6001230 SECONDS = 9 WK, 6 D, 11 HR, 30 SEC
600000000 SECONDS = 992 WK, 10 HR, 40 MIN</pre>
=={{header|ALGOL 68}}==
<
MODE DURATION = STRUCT( INT weeks, days, hours, minutes, seconds );
Line 171 ⟶ 264:
print( ( TOSTRING TODURATION 7259, newline ) );
print( ( TOSTRING TODURATION 86400, newline ) );
print( ( TOSTRING TODURATION 6000000, newline ) )</
{{out}}
<pre>
Line 181 ⟶ 274:
=={{header|ALGOL W}}==
Based on Algol 68 but Algol W does not have dynamic string handling which makes this more complex.
<
% record structure to hold a compound duration %
record Duration ( integer weeks, days, hours, minutes, seconds );
Line 267 ⟶ 360:
write( durationToString( toDuration( 86400 ) ) );
write( durationToString( toDuration( 6000000 ) ) )
end.</
{{out}}
<pre>
Line 274 ⟶ 367:
9 wk, 6 d, 10 hr, 40 min
</pre>
=={{header|APL}}==
{{works with|Dyalog APL}}
<syntaxhighlight lang="apl">duration←{
names←'wk' 'd' 'hr' 'min' 'sec'
parts←0 7 24 60 60⊤⍵
fmt←⍕¨(parts≠0)/parts,¨names
¯2↓∊fmt,¨⊂', '
}</syntaxhighlight>
{{out}}
<pre> duration 7259
2 hr, 59 sec
duration 86400
1 d
duration 6000000
9 wk, 6 d, 10 hr, 40 min</pre>
=={{header|AppleScript}}==
===Functional===
<syntaxhighlight lang="applescript">
-------------------- COMPOUND DURATIONS ------------------
-- weekParts Int -> [Int]
on weekParts(intSeconds)
unitParts(intSeconds, [missing value, 7, 24, 60, 60])
end weekParts
-- localCompoundDuration :: Int -> String
on localCompoundDuration(localNames, intSeconds)
-- [String] -> (Int, String) -> [String]
script formatted
on
set q to item 1 of lstPair
if q > 0 then
Line 314 ⟶ 407:
a
end if
end
end script
intercalate(", ", ¬
foldr(formatted, [], ¬
zip(weekParts(intSeconds)
end localCompoundDuration
------------------ INTEGER DECOMPOSITION -----------------
-- unitParts :: Int -> [maybe Int] -> [Int]
Line 330 ⟶ 421:
-- partList :: Record -> Int -> Record
script partList
on
set intRest to remaining of a
Line 342 ⟶ 433:
{remaining:(intRest - intMod) div d, parts:{intMod} & parts of a}
end
end script
Line 349 ⟶ 440:
end unitParts
--------------------------- TEST -------------------------
on run
script angloNames
on |λ|(n)
(n as string) & " -> " & ¬
localCompoundDuration(["wk", "d", "hr", "min", "sec"], n)
end |λ|
end script
unlines(map(angloNames, [7259, 86400, 6000000]))
end run
-------------------- GENERIC FUNCTIONS -------------------
-- foldr :: (a -> b ->
on foldr(f, startValue, xs)
tell mReturn(f)
Line 360 ⟶ 461:
set lng to length of xs
repeat with i from lng to 1 by -1
set v to
end repeat
return v
end tell
end foldr
-- intercalate :: String -> [String] -> String
on intercalate(delim, xs)
set {dlm, my text item delimiters} to ¬
{my text item delimiters, delim}
set s to xs as text
set my text item delimiters to dlm
s
end intercalate
-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
-- The list obtained by applying f
-- to each element of xs.
tell mReturn(f)
set lng to length of xs
set lst to {}
repeat with i from 1 to lng
set end of lst to
end repeat
return lst
Line 378 ⟶ 492:
end map
-- min :: Ord a => a -> a -> a
on min(x, y)
if y <
else
end if
end
--
on mReturn(f)
if script is class of f then
f
else
script
property
end script
end if
end mReturn
-- unlines :: [String] -> String
on unlines(xs)
-- A single string formed by the intercalation
-- of a list of strings with the newline character.
set {dlm, my text item delimiters} to ¬
{my text item delimiters, linefeed}
set s to xs as text
set my text item delimiters to dlm
s
end unlines
-- zip :: [a] -> [b] -> [(a, b)]
on zip(xs, ys)
-- A list of step-wise pairs drawn from xs and ys
-- up to the length of the shorter of those lists.
set lng to min(length of xs, length of ys)
set zs to {}
repeat with i from 1 to lng
set end of zs to {item i of xs, item i of ys}
end repeat
return zs
end zip</syntaxhighlight>
{{Out}}
<pre>7259 -> 2 hr, 59 sec
86400 -> 1 d
6000000 -> 9 wk, 6 d, 10 hr, 40 min</pre>
----
===Straightforward===
<syntaxhighlight lang="applescript">on secondsToCompoundDuration(sec)
if ((sec's class is not integer) or (sec < 0)) then ¬
error "secondsToCompoundDuration() handler only accepts positive integers."
-- The task description notwithstanding, return "0 sec" if the input is 0.
if (sec = 0) then return "0 sec"
-- Otherwise perform the described task.
set units to {weeks, days, hours, minutes, 1}
set suffixes to {" wk, ", " d, ", " hr, ", " min, ", " sec, "}
set output to ""
repeat with i from 1 to 5
set unit to units's item i
set unitValue to sec div unit
if (unitValue > 0) then set output to output & unitValue & suffixes's item i
set sec to sec mod unit
if (sec = 0) then exit repeat
end repeat
return output's text 1 thru -3
end secondsToCompoundDuration
return secondsToCompoundDuration(7259) & linefeed & ¬
secondsToCompoundDuration(86400) & linefeed & ¬
secondsToCompoundDuration(6000000)</syntaxhighlight>
{{output}}
<syntaxhighlight lang="applescript">"2 hr, 59 sec
1 d
9 wk, 6 d, 10 hr, 40 min"</syntaxhighlight>
=={{header|Applesoft BASIC}}==
<
110 FOR I = 0 TO 4
120 READ M(I), U$(I)
Line 439 ⟶ 597:
270 END
</syntaxhighlight>
=={{header|Arturo}}==
{{trans|Nim}}
<syntaxhighlight lang="rebol">Units: [" wk", " d", " hr", " min", " sec"]
Quantities: @[7 * 24 * 60 * 60, 24 * 60 * 60, 60 * 60, 60, 1]
durationString: function [d][
dur: d
idx: 0
result: new []
while [not? zero? dur][
q: dur / Quantities\[idx]
if not? zero? q [
dur: dur % Quantities\[idx]
'result ++ ~{|q||Units\[idx]|}
]
idx: idx +1
]
return join.with:", " result
]
loop [7259 86400 6000000] 't [
print [t "s => " durationString t]
]</syntaxhighlight>
{{out}}
<pre>7259 s => 2 hr, 59 sec
86400 s => 1 d
6000000 s => 9 wk, 6 d, 10 hr, 40 min</pre>
=={{header|AutoHotkey}}==
<
sec:=1, min:=60*sec, hr:=60*min, day:=24*hr, wk:=7*day
w :=n//wk , n:=Mod(n,wk)
Line 450 ⟶ 638:
s :=n
return trim((w?w " wk, ":"") (d?d " d, ":"") (h?h " hr, ":"") (m?m " min, ":"") (s?s " sec":""),", ")
}</
Examples:<
(
7259
Line 461 ⟶ 649:
res .= A_LoopField "`t: " duration(A_LoopField) "`n"
MsgBox % res
return</
Outputs:<pre>7259 : 2 hr, 59 sec
86400 : 1 d
Line 467 ⟶ 655:
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f CONVERT_SECONDS_TO_COMPOUND_DURATION.AWK
BEGIN {
Line 502 ⟶ 690:
return(str)
}
</syntaxhighlight>
<p>Output:</p>
<pre>
Line 515 ⟶ 703:
604800 1 wk
694861 1 wk, 1 d, 1 hr, 1 min, 1 sec
</pre>
Line 554 ⟶ 708:
==={{header|Commodore BASIC}}===
<
20 REM ADAPTED FROM RUN BASIC VERSION
30 REM ===============================================================
Line 588 ⟶ 742:
1190 PRINT SC;"SEC"
1200 PRINT
1210 RETURN</
{{out}}
7259 sec
Line 599 ⟶ 753:
= 9 wk, 6 dy, 10 hr, 40 min
==={{header|
<syntaxhighlight lang="freebasic">
'--- SAY_TIME Convert seconds to compound duration
'--- Weeks, days hours, minutes ,seconds
SUB SAY_TIME(int sec)
LOCAL week,day,hour,minute,second TYPE int
week = sec / 604800
day = MOD(sec /86400,7)
hour = MOD(sec / 3600 ,24)
minute = MOD(sec / 60 ,60)
second = MOD(sec,60)
IF week > 0 THEN
PRINT STR$(week) & " wk, " TO p1$ SIZE 100
END IF
IF day > 0 THEN
PRINT STR$(day) & " d, " TO p2$ SIZE 100
END IF
IF hour > 0 THEN
PRINT STR$(hour) & " h, " TO p3$ SIZE 100
END IF
IF minute > 0 THEN
PRINT STR$(minute) & " min, " TO p4$ SIZE 100
END IF
IF second > 0 THEN
PRINT STR$(second) & " sec " TO p5$ SIZE 100
END IF
PRINT p1$ ,p2$, p3$, p4$, p5$
END SUB
'---result 9 wk, 6 d, 10 h, 40 min, 7 sec
SAY_TIME(6000007)
</syntaxhighlight>
==={{header|BBC BASIC}}===
<syntaxhighlight lang="bbcbasic">REM >compduration
PRINT FN_convert(7259)
PRINT FN_convert(86400)
Line 621 ⟶ 817:
ENDIF
NEXT
= compound$</
{{out}}
<pre>2 hr, 59 sec
1 d
9 wk, 6 d, 10 hr, 40 min</pre>
==={{header|IS-BASIC}}===
<syntaxhighlight lang="is-basic">100 PROGRAM "Seconds.bas"
110 NUMERIC UN(1 TO 5),SEC,UNIT
120 STRING T$(1 TO 5)*3
130 LET UN(1)=604800:LET UN(2)=86400:LET UN(3)=3600:LET UN(4)=60:LET UN(5)=1
140 LET T$(1)="wk":LET T$(2)="d":LET T$(3)="hr":LET T$(4)="min":LET T$(5)="sec"
150 INPUT PROMPT "Duration in seconds: ":SEC
160 PRINT SEC;"sec =";
170 FOR I=1 TO 5
180 IF SEC>=UN(I) THEN
190 LET UNIT=INT(SEC/UN(I)):LET SEC=MOD(SEC,UN(I))
200 PRINT UNIT;T$(I);
210 IF I<4 AND SEC>0 THEN PRINT ",";
220 END IF
230 NEXT
240 PRINT</syntaxhighlight>
=={{header|Batch File}}==
<syntaxhighlight lang="dos">@echo off
::The Main Thing...
for %%d in (7259 86400 6000000) do call :duration %%d
exit/b 0
::/The Main Thing.
::The Function...
:duration
set output=
set /a "wk=%1/604800,rem=%1%%604800"
if %wk% neq 0 set "output= %wk% wk,"
set /a "d=%rem%/86400,rem=%rem%%%86400"
if %d% neq 0 set "output=%output% %d% d,"
set /a "hr=%rem%/3600,rem=%rem%%%3600"
if %hr% neq 0 set "output=%output% %hr% hr,"
set /a "min=%rem%/60,rem=%rem%%%60"
if %min% neq 0 set "output=%output% %min% min,"
if %rem% neq 0 set "output=%output% %rem% sec,"
if %1 gtr 0 echo %1 sec = %output:~1,-1%
goto :EOF
::/The Function.</syntaxhighlight>
{{Out}}
<pre>
7259 sec = 2 hr, 59 sec
86400 sec = 1 d
6000000 sec = 9 wk, 6 d, 10 hr, 40 min
</pre>
=={{header|beeswax}}==
<
pq":X~7~ :X@~++8~8@:X:X@~-~4~.+~8@T_
## ## #### #`K0[`}`D2[`}BF3< <
>{` wk, `>g?"p{` d, `>g?"p{` hr, `>g?"p{` min, `>g"b{` sec, `b
> d > d > d > d</
{{Out}}
Line 656 ⟶ 903:
The value to convert is read from stdin, and the corresponding compound duration is written to stdout.
<
v-7*"l~"/7\"d"\%7:/*83\+*:"xD"\%*83:/"<"<
> \:! #v_v#-#<",",#$48*#<,#<.#<>#_:"~"%,v
^_@#:$$< > .02g92p ^ ^!:/"~"<</
{{out}}
Line 672 ⟶ 919:
===C: Version written in C89. Average skill level.===
<syntaxhighlight lang="c">/*
* Program seconds2string, C89 version.
*
Line 735 ⟶ 981:
return EXIT_FAILURE;
}</syntaxhighlight>
===C: Version written in C99. Low skill level.===
<syntaxhighlight lang="c">
#include <inttypes.h> /* requires c99 */
#include <stdbool.h> /* requires c99 */
Line 880 ⟶ 1,125:
return minutes*60;
}
</syntaxhighlight>
{{out}}
Line 894 ⟶ 1,139:
</pre>
=={{header|C sharp|C#}}==
===C#: Standard method===
<
using System.Collections.Generic;
using System.Linq;
Line 948 ⟶ 1,193:
}
}</
{{out}}
Line 964 ⟶ 1,209:
{{libheader|System.Linq}}
{{works with|C sharp|6}}
<
{
if (seconds < 0) throw new ArgumentOutOfRangeException(nameof(seconds));
Line 977 ⟶ 1,222:
where parts[index] > 0
select parts[index] + units[index]);
}</
=={{header|C++}}==
{{works with|C++11}}
<
#include <iostream>
#include <vector>
Line 1,017 ⟶ 1,262:
std::cout << " 86400 sec is "; print(convert( 86400));
std::cout << "6000000 sec is "; print(convert(6000000));
}</
{{out}}
<pre>
Line 1,024 ⟶ 1,269:
6000000 sec is 9 wk, 6 d, 10 hr, 40 min
</pre>
=={{header|Clojure}}==
<syntaxhighlight lang="clojure">(require '[clojure.string :as string])
(def seconds-in-minute 60)
(def seconds-in-hour (* 60 seconds-in-minute))
(def seconds-in-day (* 24 seconds-in-hour))
(def seconds-in-week (* 7 seconds-in-day))
(defn seconds->duration [seconds]
(let [weeks ((juxt quot rem) seconds seconds-in-week)
wk (first weeks)
days ((juxt quot rem) (last weeks) seconds-in-day)
d (first days)
hours ((juxt quot rem) (last days) seconds-in-hour)
hr (first hours)
min (quot (last hours) seconds-in-minute)
sec (rem (last hours) seconds-in-minute)]
(string/join ", "
(filter #(not (string/blank? %))
(conj []
(when (> wk 0) (str wk " wk"))
(when (> d 0) (str d " d"))
(when (> hr 0) (str hr " hr"))
(when (> min 0) (str min " min"))
(when (> sec 0) (str sec " sec")))))))
(seconds->duration 7259)
(seconds->duration 86400)
(seconds->duration 6000000)</syntaxhighlight>
{{out}}
<pre>
"2 hr, 59 sec"
"1 d"
"9 wk, 6 d, 10 hr, 40 min"
</pre>
=={{header|CLU}}==
<syntaxhighlight lang="clu">duration = proc (s: int) returns (string)
own units: array[string] := array[string]$["wk","d","hr","min","sec"]
own sizes: array[int] := array[int]$[2:7,24,60,60]
d: string := ""
r: int
for i: int in int$from_to_by(5,1,-1) do
begin
r := s // sizes[i]
s := s / sizes[i]
end except when bounds:
r := s
end
if r ~= 0 then
d := ", " || int$unparse(r) || " " || units[i] || d
end
end
return(string$rest(d,3))
end duration
start_up = proc ()
po: stream := stream$primary_output()
tests: array[int] := array[int]$[7259,86400,6000000]
for test: int in array[int]$elements(tests) do
stream$putl(po, int$unparse(test) || " => " || duration(test))
end
end start_up</syntaxhighlight>
{{out}}
<pre>7259 => 2 hr, 59 sec
86400 => 1 d
6000000 => 9 wk, 6 d, 10 hr, 40 min</pre>
=={{header|COBOL}}==
<
program-id. fmt-dura.
data division.
Line 1,099 ⟶ 1,415:
.
end program fmt.
end program fmt-dura.</
<pre>Enter duration (seconds): 7259
2 hr, 59 sec
Line 1,108 ⟶ 1,424:
=={{header|Common Lisp}}==
<
(defconstant +seconds-in-hour* (* 60 +seconds-in-minute*))
(defconstant +seconds-in-day* (* 24 +seconds-in-hour*))
Line 1,129 ⟶ 1,445:
(seconds->duration 86400)
(seconds->duration 6000000)
</syntaxhighlight>
{{out}}
<pre>
Line 1,138 ⟶ 1,454:
=={{header|D}}==
<syntaxhighlight lang="d">
import std.stdio, std.conv, std.algorithm;
Line 1,178 ⟶ 1,494:
6_000_000.ConvertSeconds.writeln;
}
</syntaxhighlight>
{{out}}
<pre>
2 hr, 59 sec
1 d
9 wk, 6 d, 10 hr, 40 min
</pre>
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls,DateUtils}}
<syntaxhighlight lang="Delphi">
const TestData: array [0..2] of integer = (7259,86400,6000000);
function SecondsToFormatDate(Sec: integer): string;
var DT: TDateTime;
var Weeks: integer;
var AYear, AMonth, ADay, AHour, AMinute, ASecond, AMilliSecond: Word;
const SecPerDay = 60 * 60 * 24;
begin
{Convert seconds to Delphi TDateTime}
{which is floating point days}
DT:=Sec / SecPerDay;
{Get weeks and subtract them off}
Weeks:=Trunc(DT/7);
DT:=DT - Weeks * 7;
{Decode date}
DecodeDateTime(DT,AYear, AMonth, ADay, AHour, AMinute, ASecond, AMilliSecond);
{Compensate because TDateTime starts on Dec 30th 1899}
if aDay<30 then aDay:=aDay + 1 else aDay:=aDay - 30;
Result:='';
if Weeks<>0 then Result:=Result+IntToStr(Weeks)+' wk, ';
if ADay<>0 then Result:=Result+IntToStr(ADay)+' d, ';
if AHour<>0 then Result:=Result+IntToStr(AHour)+' hr, ';
if AMinute<>0 then Result:=Result+IntToStr(AMinute)+' min, ';
if ASecond<>0 then Result:=Result+IntToStr(ASecond)+' sec, ';
end;
procedure ShowFormatedDataTime(Memo: TMemo);
var I: integer;
begin
for I:=0 to High(TestData) do
Memo.Lines.Add(IntToStr(TestData[I])+' = '+SecondsToFormatDate(TestData[I]));
end;
</syntaxhighlight>
{{out}}
<pre>
7259 = 2 hr, 59 sec,
86400 = 1 d,
6000000 = 9 wk, 6 d, 10 hr, 40 min,
Elapsed Time: 2.900 ms.
</pre>
=={{header|EasyLang}}==
<syntaxhighlight lang="text">
func$ split sec .
divs[] = [ 60 60 24 7 ]
n$[] = [ "sec" "min" "hr" "d" "wk" ]
len r[] 5
for i = 1 to 4
r[i] = sec mod divs[i]
sec = sec div divs[i]
.
r[5] = sec
for i = 5 downto 1
if r[i] <> 0
if s$ <> ""
s$ &= ", "
.
s$ &= r[i] & " " & n$[i]
.
.
return s$
.
print split 7259
print split 86400
print split 6000000
</syntaxhighlight>
{{out}}
<pre>
Line 1,187 ⟶ 1,587:
=={{header|Elixir}}==
<
@minute 60
@hour @minute*60
Line 1,207 ⟶ 1,607:
Enum.each([7259, 86400, 6000000], fn sec ->
:io.fwrite "~10w sec : ~s~n", [sec, Convert.sec_to_str(sec)]
end)</
{{out}}
Line 1,223 ⟶ 1,623:
Function ''intercalate/2'' is copied from [https://github.com/tim/erlang-oauth/blob/master/src/oauth.erl a Tim Fletcher's GitHub repository].
<
-module(convert_seconds).
Line 1,313 ⟶ 1,713:
% **************************************************
</syntaxhighlight>
Output:
Line 1,323 ⟶ 1,723:
=={{header|F_Sharp|F#}}==
<
let convert seconds =
Line 1,343 ⟶ 1,743:
|> Seq.map (fun str -> let sec = UInt32.Parse str in (sec, convert sec))
|> Seq.iter (fun (s, v) -> printfn "%10i = %s" s v)
0</
{{out}}
<pre>>RosettaCode 7259 86400 6000000
Line 1,349 ⟶ 1,749:
86400 = 1 day
6000000 = 9 wk, 6 day, 10 hr, 40 min</pre>
=={{header|Factor}}==
<syntaxhighlight lang="factor">USING: assocs io kernel math math.parser qw sequences
sequences.generalizations ;
: mod/ ( x y -- w z ) /mod swap ;
: convert ( n -- seq )
60 mod/ 60 mod/ 24 mod/ 7 mod/ 5 narray reverse ;
: .time ( n -- )
convert [ number>string ] map qw{ wk d hr min sec } zip
[ first "0" = ] reject [ " " join ] map ", " join print ;
7259 86400 6000000 [ .time ] tri@</syntaxhighlight>
{{out}}
<pre>
2 hr, 59 sec
1 d
9 wk, 6 d, 10 hr, 40 min
</pre>
=={{header|Forth}}==
{{works with|Gforth|0.7.3}}
<syntaxhighlight lang="forth">CREATE C 0 ,
: ., C @ IF ." , " THEN 1 C ! ;
: .TIME ( n --)
[ 60 60 24 7 * * * ]L /MOD ?DUP-IF ., . ." wk" THEN
[ 60 60 24 * * ]L /MOD ?DUP-IF ., . ." d" THEN
[ 60 60 * ]L /MOD ?DUP-IF ., . ." hr" THEN
[ 60 ]L /MOD ?DUP-IF ., . ." min" THEN
?DUP-IF ., . ." sec" THEN 0 C ! ;</syntaxhighlight>
{{out}}
<pre>2 hr, 59 sec
1 d
9 wk, 6 d, 10 hr, 40 min</pre>
=={{header|Fortran}}==
Line 1,354 ⟶ 1,790:
If the time to describe was not an integer but a floating-point value with fractional parts, then there is a complication. The number of seconds can be less than sixty, but, on output, 60 seconds can appear. If the number of seconds was to be written with one decimal digit (say) and the output format was F4.1 for that, then if the value was 59·95 or more, it will be rounded up for output, in this example to 60·0. Various systems make this mistake, as also with latitude and longitude, and it is a general problem. A fixup pass is necessary before generating the output: maintain an array with the integer values of the various units, then (for one decimal digit usage) check that the seconds part is less than 59·95. If not, set it to zero and augment the minutes count. If this is 60 or more, set it to zero and augment the hours count, and so on. Thus the array.
<syntaxhighlight lang="fortran">
SUBROUTINE PROUST(T) !Remembrance of time passed.
INTEGER T !The time, in seconds. Positive only, please.
Line 1,392 ⟶ 1,828:
CALL PROUST(-666)
END
</syntaxhighlight>
Output:
<pre>
Line 1,404 ⟶ 1,840:
=={{header|FreeBASIC}}==
<
Sub Show(m As Long)
Line 1,440 ⟶ 1,876:
Show 86400 seconds
Show 6000000 seconds
sleep</
Output:
<pre>
Line 1,446 ⟶ 1,882:
86400 seconds = 1 d
6000000 seconds = 9 Wk, 6 d, 10 hr and 40 min
</pre>
=={{header|Frink}}==
Frink's <CODE>-></CODE> operator can break a unit of measure into its constituent parts. However, it does not suppress zero-valued elements unless they are at the beginning or the end, so we have to do that manually.
<syntaxhighlight lang="frink">
wk := week
n = eval[input["Enter duration in seconds: "]]
res = n s -> [0, "wk", "d", "hr", "min", "sec", 0]
res =~ %s/, 0[^,]+//g
println[res]
</syntaxhighlight>
=={{header|FutureBasic}}==
{{trans|C}}
<syntaxhighlight lang="futurebasic">
include "NSLog.incl"
local fn CompoundDurationString( seconds as long ) as CFStringRef
long s = 1, m = s * 60, h = m * 60, d = h * 24, w = d * 7
long v(4) : v(0) = w : v(1) = d : v(2) = h : v(3) = m : v(4) = s
long i, value
CFArrayRef abbr = @[@"wk",@"d",@"hr",@"min",@"sec"]
CFMutableStringRef string = fn MutableStringWithCapacity(0)
for i = 0 to 4
value = seconds / v(i)
seconds = seconds mod v(i)
if ( value )
if ( len(string) ) then MutableStringAppendString( string, @", " )
MutableStringAppendFormat( string, @"%ld %@", value, abbr[i] )
end if
next
end fn = string
NSLog(@"%@",fn CompoundDurationString(7259))
NSLog(@"%@",fn CompoundDurationString(86400))
NSLog(@"%@",fn CompoundDurationString(6000000))
HandleEvents
</syntaxhighlight>
{{out}}
<pre>
2 hr, 59 sec
1 d
9 wk, 6 d, 10 hr, 40 min
</pre>
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=d7f00b8a96a6f792f0164f622f0686df Click this link to run this code]'''
<syntaxhighlight lang="gambas">Public Sub Main()
Dim iInput As Integer[] = [7259, 86400, 6000000] 'Input details
Dim iChecks As Integer[] = [604800, 86400, 3600, 60] 'Weeks, days, hours, mins in seconds
Dim iTime As New Integer[5] 'To store wk, d, hr, min & sec
Dim iOriginal, iSec, iLoop As Integer 'Various integers
Dim sOrd As String[] = [" wk", " d", " hr", " min", " sec"] 'To add to the output string
Dim sOutput As String 'Output string
For Each iSec In iInput 'For each iInput
iOriginal = iSec 'Store orginal value in seconds
iTime[4] = iSec 'Store seconds in iTime[4]
For iLoop = 0 To 3 'Loop through wk, d, hr, min & sec
If iTime[4] >= iChecks[iLoop] Then 'Check if value is = to wk, d, hr, min
iTime[iLoop] = Int(iTime[4] / iChecks[iLoop]) 'Put the correct value for wk, d, hr, min in iTime
iTime[4] = iTime[4] - (iTime[iLoop] * iChecks[iLoop]) 'Remove the amount of seconds for wk, d, hr, min from iTime[4]
Endif
Next
For iLoop = 0 To 4 'Loop through wk, d, hr, min & secs
If iTime[iLoop] > 0 Then sOutput &= ", " & Str(iTime[iLoop]) & sOrd[iLoop] 'Add comma and ordinal as needed
Next
If Left(sOutput, 2) = ", " Then sOutput = Mid(sOutput, 3) 'Remove unnecessary ", "
sOutput = Format(Str(iOriginal), "#######") & " Seconds = " & sOutput 'Add original seconds to the output string
Print sOutput 'Print sOutput string
sOutput = "" 'Clear the sOutput string
iTime = New Integer[5] 'Reset iTime[]
Next
End</syntaxhighlight>
Output:
<pre>
7259 Seconds = 2 hr, 59 sec
86400 Seconds = 1 d
6000000 Seconds = 9 wk, 6 d, 10 hr, 40 min
</pre>
=={{header|Go}}==
<
import "fmt"
Line 1,498 ⟶ 2,021:
return
}
</syntaxhighlight>
{{Out}}
<pre>
Line 1,505 ⟶ 2,028:
9 wk, 6 d, 10 hr, 40 min
</pre>
=={{header|Haskell}}==
<
import Data.List (intercalate, mapAccumR)
import System.Environment (getArgs)
Line 1,533 ⟶ 2,057:
forM_ args $ \arg -> case readMaybe arg of
Just n -> printf "%7d seconds = %s\n" n (compoundDuration n)
Nothing -> putStrLn $ "Invalid number of seconds: " ++ arg</
{{out}}
Line 1,543 ⟶ 2,067:
Or, parameterising both the local names for these durations, and also the working assumptions about hours per day, and days per week:
<
---------------- COMPOUND DURATION STRINGS ---------------
durationString ::
String ->
Int ->
Int ->
[String] ->
Int ->
String
durationString
componentGap
numberLabelGap
daysPerWeek
hoursPerDay
xs
n =
intercalate
componentGap
( foldr
(timeTags numberLabelGap)
[]
(zip (weekParts daysPerWeek hoursPerDay n) xs)
)
timeTags :: String -> (Int, String) -> [String] -> [String]
timeTags numberLabelGap (n, s) xs
| 0 < n = intercalate numberLabelGap [show n, s] : xs
| otherwise = xs
weekParts :: Int -> Int -> Int -> [Int]
weekParts daysPerWeek hoursPerDay =
snd
. flip
(mapAccumR byUnits)
[0, daysPerWeek, hoursPerDay, 60, 60]
byUnits rest x = (quot (rest - m) u, m)
where
(u, m)
translation
translation local daysPerWeek hoursPerDay n =
intercalate " -> " $
[ show,
durationString
", "
" "
daysPerWeek
hoursPerDay
(words local)
]
<*> [n]
main :: IO ()
main = do
let names = "wk d hr min sec"
let tests = [7259, 86400, 6000000]
putStrLn "Assuming 24 hrs per day:"
mapM_ (putStrLn . translation names 7 24) tests
putStrLn "\nor, at 8 hours per day, 5 days per week:"
mapM_ (putStrLn . translation names 5 8) tests</syntaxhighlight>
{{Out}}
<pre>Assuming 24/7:
7259 -> 2 hr, 59 sec
86400 -> 1 d
6000000 -> 9 wk, 6 d, 10 hr, 40 min
or, at 8 working hours per day, 5 days per week:
7259 -> 2 hr, 59 sec
86400 -> 3 d
6000000 -> 41 wk, 3 d, 2 hr, 40 min</pre>
=={{header|J}}==
Line 1,584 ⟶ 2,155:
Implementation:
<
seq=. 0 7 24 60 60 #: y
}: ;:inv ,(0 ~: seq) # (8!:0 seq) ,. <;.2'wk,d,hr,min,sec,'
)</
The first line uses integer division with remainder to break the value in seconds into its components (weeks, days, hours, minutes, seconds).
The second line gives each value a label and a trailing comma, drops the parts which have a zero, combines the rest and then removes the trailing comma from the end of the resulting line.
Task examples:
<
2 hr, 59 sec
fmtsecs 86400
1 d
fmtsecs 6000000
9 wk, 6 d, 10 hr, 40 min</
=={{header|Jakt}}==
<syntaxhighlight lang="jakt">
fn main() {
for seconds in [
7259
86400
6000000
] {
println("{}", time_string(seconds))
}
}
fn time_string(mut seconds: i64) throws -> String {
mut result = ""
mut minutes = seconds / 60
seconds %= 60
if seconds > 0 {
result = format("{} sec", seconds, result)
}
mut hours = minutes / 60
minutes %= 60
if minutes > 0 {
result = format(match result {
"" => "{} min"
else => "{} min, {}"
}, minutes, result)
}
mut days = hours / 24
hours %= 24
if hours > 0 {
result = format(match result {
"" => "{} hr"
else => "{} hr, {}"
}, hours, result)
}
mut weeks = days / 7
days %= 7
if days > 0 {
result = format(match result {
"" => "{} d"
else => "{} d, {}"
}, days, result)
}
if weeks > 0 {
result = format(match result {
"" => "{} wk"
else => "{} wk, {}"
}, weeks, result)
}
return result
}
</syntaxhighlight>
=={{header|Java}}==
This is a relatively simple task in Java, using the modulus-remainder operator.
<syntaxhighlight lang="java">
String duration(int seconds) {
StringBuilder string = new StringBuilder();
if (seconds >= 604_800 /* 1 wk */) {
string.append("%,d wk".formatted(seconds / 604_800));
seconds %= 604_800;
}
if (seconds >= 86_400 /* 1 d */) {
if (!string.isEmpty()) string.append(", ");
string.append("%d d".formatted(seconds / 86_400));
seconds %= 86_400;
}
if (seconds >= 3600 /* 1 hr */) {
if (!string.isEmpty()) string.append(", ");
string.append("%d hr".formatted(seconds / 3600));
seconds %= 3600;
}
if (seconds >= 60 /* 1 min */) {
if (!string.isEmpty()) string.append(", ");
string.append("%d min".formatted(seconds / 60));
seconds %= 60;
}
if (seconds > 0) {
if (!string.isEmpty()) string.append(", ");
string.append("%d sec".formatted(seconds));
}
return string.toString();
}
</syntaxhighlight>
<pre>
2 hr, 59 sec
1 d
9 wk, 6 d, 10 hr, 40 min
</pre>
<br />
An alternate demonstration
<syntaxhighlight lang="java">public class CompoundDuration {
public static void main(String[] args) {
Line 1,629 ⟶ 2,299:
return sec;
}
}</
<pre>2 hr, 59 sec
1 d
9 wk, 6 d, 10 hr, 40 min</pre>
=={{header|JavaScript}}==
Line 1,642 ⟶ 2,311:
====ES5====
<
'use strict';
Line 1,701 ⟶ 2,370:
})();
</syntaxhighlight>
{{Out}}
Line 1,710 ⟶ 2,379:
====ES6====
<syntaxhighlight lang="javascript">(() => {
"use strict";
// ---------------- COMPOUND DURATION ----------------
// compoundDuration :: [String] -> Int -> String
const compoundDuration =
nSeconds => weekParts(
.map((v, i) => [v, labels[i]])
.reduce((a, x) =>
a.concat(
x[0] ? [
`${x[0]} ${x[1] || "?"}`
] : []
), []
)
.join(
const weekParts = nSeconds => [0, 7, 24, 60, 60]
.reduceRight((a, x) => {
r = a[0],
mod = x !== 0 ? r % x : r;
return
},
// ---------------------- TEST -----------------------
const main =
const localNames = ["wk", "d", "hr", "min", "sec"];
return [7259, 86400, 6E6]
.map(nSeconds =>
`${nSeconds} -> ${
compoundDuration(localNames)(nSeconds)
}`).join("\n");
};
// MAIN ---
return main();
})();</syntaxhighlight>
{{Out}}
<pre>7259 -> 2 hr, 59 sec
Line 1,755 ⟶ 2,434:
=={{header|jq}}==
{{works with|jq|1.4}}
'''Also works with gojq, the Go implementation'''
<syntaxhighlight lang="jq">def seconds_to_time_string:
def nonzero(text): floor | if . > 0 then "\(.) \(text)" else empty end;
if . == 0 then "0 sec"
Line 1,765 ⟶ 2,445:
(. % 60 | nonzero("sec"))]
| join(", ")
end;</
''Examples''':
<
{{out}}
<
0: 0 sec
7259: 2 hr, 59 sec
86400: 1 d
6000000: 9 wk, 6 d, 10 hr, 40 min</
=={{header|
<syntaxhighlight lang="julia"># 1.x
function duration(sec::Integer)::String
t = Array{Int}([])
for dm in (60, 60, 24, 7)
sec, m = divrem(sec, dm)
pushfirst!(t, m)
end
pushfirst!(t, sec)
return join(["$num$unit" for (num, unit) in zip(t, ["w", "d", "h", "m", "s"]) if num > 0], ", ")
end
@show duration(7259)
@show duration(86400)
@show duration(6000000)
</syntaxhighlight>
{{out}}
<pre>
duration(7259) = "2h, 59s"
duration(86400) = "1d"
duration(6000000) = "9w, 6d, 10h, 40m"
</pre>
=={{header|K}}==
{{works with|ngn/k}}<syntaxhighlight lang=K>F:{", "/" "/'+($x[s]),s:,&0<x}(" "\"wk d hr min sec")!0 7 24 60 60\</syntaxhighlight>
Examples:
<syntaxhighlight lang=K>F 100
"1 min, 40 sec"
F 7259
"2 hr, 59 sec"
F 86400
"1 d"
F 6000000
"9 wk, 6 d, 10 hr, 40 min"</syntaxhighlight>
tested in ngn/k
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">fun compoundDuration(n: Int): String {
if (n < 0) return "" // task doesn't ask for negative integers to be converted
if (n == 0) return "0 sec"
Line 1,789 ⟶ 2,507:
var divisor: Int = 7 * 24 * 60 * 60
var rem : Int
var result
weeks = n / divisor
Line 1,817 ⟶ 2,535:
val durations = intArrayOf(0, 7, 84, 7259, 86400, 6000000)
durations.forEach { println("$it\t-> ${compoundDuration(it)}") }
}</
{{out}}
Line 1,827 ⟶ 2,545:
86400 -> 1 d
6000000 -> 9 wk, 6 d, 10 hr, 40 min
</pre>
=={{header|langur}}==
<syntaxhighlight lang="langur">val .duration = fn(var .sec) {
[
fw/wk d hr min sec/,
for[=[]] .dm in [7 * 24 * 60 * 60, 24 * 60 * 60, 60 * 60, 60] {
_for ~= [.sec \ .dm]
.sec rem= .dm
} ~ [.sec],
]
}
for .seconds in [7259, 86400, 6000000] {
val .dur = .duration(.seconds)
write $"\.seconds:7; sec = "
writeln join ", ", for[=[]] .k of .dur[1] {
if .dur[2][.k] != 0: _for ~= [$"\.dur[2][.k]; \.dur[1][.k];"]
}
}
</syntaxhighlight>
{{out}}
<pre> 7259 sec = 2 hr, 59 sec
86400 sec = 1 d
6000000 sec = 9 wk, 6 d, 10 hr, 40 min
</pre>
=={{header|Liberty BASIC}}==
I got a bit carried away and added 'years'...
<syntaxhighlight lang="lb">
[start]
input "Enter SECONDS: "; seconds
Line 1,920 ⟶ 2,664:
print
goto [start]
</syntaxhighlight>
{{out}}
<pre>
Line 1,936 ⟶ 2,680:
=={{header|Lua}}==
<
local units, dur = {"wk", "d", "hr", "min"}, ""
for i, v in ipairs({604800, 86400, 3600, 60}) do
Line 1,953 ⟶ 2,697:
print(duration(7259))
print(duration(86400))
print(duration(6000000))</
=={{header|
<syntaxhighlight lang="maple">
tim := proc (s) local weeks, days, hours, minutes, seconds;
weeks := trunc((1/604800)*s);
days := trunc((1/86400)*s)-7*weeks;
hours := trunc((1/3600)*s)-24*days-168*weeks;
minutes := trunc((1/60)*s)-60*hours-1440*days-10080*weeks;
seconds := s-60*minutes-3600*hours-86400*days-604800*weeks;
printf("%s", cat(`if`(0 < weeks, cat(weeks, "wk, "), NULL), `if`(0 < days, cat(days, "d, "), NULL), `if`(0 < hours, cat(hours, "hr, "), NULL), `if`(0 < minutes, cat(minutes, "min, "), NULL), `if`(0 < seconds, cat(seconds, "sec"), NULL)))
end proc;
</syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">compoundDuration[x_Integer] :=
StringJoin @@ (Riffle[
ToString /@ ((({Floor[x/604800],
Line 1,968 ⟶ 2,723:
Grid[Table[{n, "secs =",
compoundDuration[n]}, {n, {7259, 86400, 6000000}}],
Alignment -> {Left, Baseline}]</syntaxhighlight>
{{out}}
<pre>7259 secs = 2 hr, 59 sec
86400 secs = 1 d,
6000000 secs = 9 wk, 6 d, 10 hr, 40 min,
=={{header|Nim}}==
<syntaxhighlight lang="nim">from strutils import addSep
const
Units = [" wk", " d", " hr", " min", " sec"]
Quantities = [7 * 24 * 60 * 60, 24 * 60 * 60, 60 * 60, 60, 1]
#---------------------------------------------------------------------------------------------------
proc `$$`*(sec: int): string =
## Convert a duration in seconds to a friendly string.
doAssert(sec > 0)
var duration = sec
var idx = 0
while duration != 0:
let q = duration div Quantities[idx]
if q != 0:
duration = duration mod Quantities[idx]
result.addSep(", ", 0)
result.add($q & Units[idx])
inc idx
#———————————————————————————————————————————————————————————————————————————————————————————————————
when isMainModule:
for sec in [7259, 86400, 6000000]:
echo sec, "s = ", $$sec</syntaxhighlight>
{{out}}
<pre>7259s = 2 hr, 59 sec
86400s = 1 d
6000000s = 9 wk, 6 d, 10 hr, 40 min</pre>
===Using the “times” module===
It is also possible to use the Duration type in the “times” module and the procedure “toParts” which decomposes a duration in units of time (nanoseconds, microseconds, milliseconds, seconds, minutes, hours, days and weeks).
<syntaxhighlight lang="nim">import times
from algorithm import reversed
from strutils import addSep
const Units = [" wk", " d", " hr", " min", " sec"]
#---------------------------------------------------------------------------------------------------
proc `$$`*(sec: int): string =
## Convert a duration in seconds to a friendly string.
## Similar to `$` but with other conventions.
doAssert(sec > 0)
var duration = initDuration(seconds = sec)
let parts = reversed(duration.toParts[Seconds..Weeks])
for idx, part in parts:
if part != 0:
result.addSep(", ", 0)
result.add($part & Units[idx])
#———————————————————————————————————————————————————————————————————————————————————————————————————
when isMainModule:
for sec in [7259, 86400, 6000000]:
echo sec, "s = ", $$sec</syntaxhighlight>
{{out}}
Output is the same.
=={{header|OCaml}}==
{{works with|OCaml|4.03+}}
<
(max_int, "wk"); (* many wk = many wk *)
(7, "d"); (* 7 d = 1 wk *)
Line 2,052 ⟶ 2,874:
n calc s
in
List.iter testit test_cases</
{{out}}
[PASS] 7259 seconds -> 2 hr, 59 sec; expected: 2 hr, 59 sec
Line 2,067 ⟶ 2,889:
{{Works with|PARI/GP|2.7.4 and above}}
<
\\ Convert seconds to compound duration
\\ 4/11/16 aev
Line 2,084 ⟶ 2,906:
print(secs2compdur(6000000));
}
</
{{Output}}
Line 2,093 ⟶ 2,915:
9 wk, 6 d, 10 hr, 40 min
</pre>
=={{header|Pascal}}==
{{works with|Extended Pascal}}
<syntaxhighlight lang="pascal">program convertSecondsToCompoundDuration(output);
const
suffixUnitWeek = 'wk';
suffixUnitDay = 'd';
suffixUnitHour = 'hr'; { Use `'h'` to be SI-compatible. }
suffixUnitMinute = 'min';
suffixUnitSecond = 'sec'; { NB: Only `'s'` is SI-approved. }
suffixSeparator = ' '; { A non-breaking space would be appropriate. }
quantitySeparator = ', ';
{ Maximum expected length of `string` “12345 wk, 6 d, 7 hr, 8 min, 9 sec” }
timeSpanPrintedMaximumLength = 4 * length(quantitySeparator) +
20 + length(suffixUnitWeek) + 1 + length(suffixUnitDay) +
2 + length(suffixUnitHour) + 2 + length(suffixUnitMinute) +
2 + length(suffixUnitSecond) + 5 * length(suffixSeparator);
{ Units of time expressed in seconds. }
minute = 60;
hour = 60 * minute;
day = 24 * hour;
week = 7 * day;
type
wholeNumber = 0..maxInt;
naturalNumber = 1..maxInt;
canonicalTimeSpan = record
weeks: wholeNumber;
days: 0..6;
hours: 0..23;
minutes: 0..59;
seconds: 0..59;
end;
stringFitForTimeSpan = string(timeSpanPrintedMaximumLength);
{
\brief turns a time span expressed in seconds into a `canonicalTimeSpan`
\param duration the non-negative duration expressed in seconds
\return a `canonicalTimeSpan` representing \param duration seconds
}
function getCanonicalTimeSpan(duration: wholeNumber): canonicalTimeSpan;
{ Perform `div`ision and update `duration`. }
function split(protected unit: naturalNumber): wholeNumber;
begin
split := duration div unit;
duration := duration mod unit
end;
var
result: canonicalTimeSpan;
begin
with result do
begin
weeks := split(week);
days := split(day);
hours := split(hour);
minutes := split(minute);
seconds := duration
end;
{ In Pascal there needs to be _exactly_ one assignment to the }
{ result variable bearing the same name as of the `function`. }
getCanonicalTimeSpan := result
end;
{
\brief turns a non-trivial duration into a string
\param n a positive duration expressed in seconds
\return \param n expressed in some human-readable form
}
function timeSpanString(protected n: naturalNumber): stringFitForTimeSpan;
const
qs = quantitySeparator;
var
result: stringFitForTimeSpan;
begin
with getCanonicalTimeSpan(n) do
begin
{ `:1` specifies the minimum-width. Omitting it would cause }
{ the compiler to insert a vendor-defined default, e. g. 20. }
writeStr(result, weeks:1, suffixSeparator, suffixUnitWeek);
{ For strings, `:n` specifies the _exact_ width (padded with spaces). }
writeStr(result, result:ord(weeks > 0) * length(result));
if days > 0 then
begin
writeStr(result, result, qs:ord(length(result) > 0) * length(qs),
days:1, suffixSeparator, suffixUnitDay);
end;
if hours > 0 then
begin
writeStr(result, result, qs:ord(length(result) > 0) * length(qs),
hours:1, suffixSeparator, suffixUnitHour);
end;
if minutes > 0 then
begin
writeStr(result, result, qs:ord(length(result) > 0) * length(qs),
minutes:1, suffixSeparator, suffixUnitMinute);
end;
if seconds > 0 then
begin
writeStr(result, result, qs:ord(length(result) > 0) * length(qs),
seconds:1, suffixSeparator, suffixUnitSecond);
end
end;
timeSpanString := result
end;
{ === MAIN ============================================================= }
begin
writeLn( 7259, ' seconds are “', timeSpanString(7259), '”');
writeLn( 86400, ' seconds are “', timeSpanString(86400), '”');
writeLn(6000000, ' seconds are “', timeSpanString(6000000), '”')
end.</syntaxhighlight>
{{out}}
7259 seconds are “2 hr, 59 sec”
86400 seconds are “1 d”
6000000 seconds are “9 wk, 6 d, 10 hr, 40 min”
=={{header|Perl}}==
===Direct calculation===
<syntaxhighlight lang="perl">use strict;
use warnings;
sub compound_duration {
my $sec = shift;
no warnings 'numeric';
Line 2,106 ⟶ 3,054:
int($sec/60) % 60 . " min",
int($sec) % 60 . " sec";
}
for (7259, 86400, 6000000) {
printf "%7d sec = %s\n", $_, compound_duration($_)
}</
{{out}}
<pre> 7259 sec = 2 hr, 59 sec
86400 sec = 1 d
6000000 sec = 9 wk, 6 d, 10 hr, 40 min</pre>
===Using polymod===
More general approach for mixed-radix conversions.
<syntaxhighlight lang="perl">use strict;
use warnings;
use Math::AnyNum 'polymod';
sub compound_duration {
my $seconds = shift;
my @terms;
my @durations = reverse polymod($seconds, 60, 60, 24, 7);
while (my $d = shift @durations, my $t = shift @timespans) {
push @terms, "$d $t" if $d
}
join ', ', @terms
}
for (<7259 86400 6000000 3380521>) {
printf "%7d sec = %s\n", $_, compound_duration($_)
}</syntaxhighlight>
{{out}}
<pre> 7259 sec = 2 hr, 59 sec
86400 sec = 1 d
6000000 sec = 9 wk, 6 d, 10 hr, 40 min
3380521 sec = 5 wk, 4 d, 3 hr, 2 min, 1 sec</pre>
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #000000;">7259</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #000000;">86400</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #000000;">6000000</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
"2 hours and 59s"
"1 day
"
</pre>
You may also be interested in the timedelta() function, which converts durations to seconds, eg:
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">include</span> <span style="color: #004080;">timedate</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #000000;">6000000</span><span style="color: #0000FF;">-</span><span style="color: #7060A8;">timedelta</span><span style="color: #0000FF;">(</span><span style="color: #000000;">days</span><span style="color: #0000FF;">:=</span><span style="color: #000000;">6</span><span style="color: #0000FF;">,</span><span style="color: #000000;">hours</span><span style="color: #0000FF;">:=</span><span style="color: #000000;">10</span><span style="color: #0000FF;">))</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
"9 weeks, 40 minutes"
</pre>
=={{header|PicoLisp}}==
<
(tab (-10 -30)
Sec
Line 2,205 ⟶ 3,127:
(pack @ " " Str) ) )
(604800 86400 3600 60 1)
'("wk" "d" "hr" "min" "sec") ) ) ) )</
Output:
<pre>7259 2 hr, 59 sec
Line 2,212 ⟶ 3,134:
=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">
/* Convert seconds to Compound Duration (weeks, days, hours, minutes, seconds). */
Line 2,240 ⟶ 3,162:
end;
end cvt;
</syntaxhighlight>
Results:
<pre>
Line 2,256 ⟶ 3,178:
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">
function Get-Time
{
Line 2,373 ⟶ 3,295:
}
}
</syntaxhighlight>
{{Out}}
Line 2,403 ⟶ 3,325:
TotalSeconds : 6000000
TotalMilliseconds : 6000000000
</pre>
=={{header|Prolog}}==
Works with Swi-Prolog.
Use Contraints for this task so the that functionality can be reversed (eg: find the number of seconds for a split date).
See below for examples.
<syntaxhighlight lang="prolog">:- use_module(library(clpfd)).
% helper to perform the operation with just a number.
compound_time(N) :-
times(N, R),
format('~p: ', N),
write_times(R).
% write out the results in the 'special' format.
write_times([[Tt, Val]|T]) :-
dif(T, []),
format('~w ~w, ', [Val, Tt]),
write_times(T).
write_times([[Tt, Val]|[]]) :-
format('~w ~w~n', [Val, Tt]).
% this predicate is the main predicate, it takes either N
% or a list of split values to get N, or both.
times(N, R) :-
findall(T, time_type(T,_), TTs),
times(TTs, N, R).
% do the split, if there is a 1 or greater add to a list of results.
times([], _, []).
times([Tt|T], N, Rest) :-
time_type(Tt, Div),
Val #= N // Div,
Val #< 1,
times(T, N, Rest).
times([Tt|T], N, [[Tt,Val]|Rest]) :-
time_type(Tt, Div),
Val #= N // Div,
Val #>= 1,
Rem #= N mod Div,
times(T, Rem, Rest).
% specifify the different time split types
time_type(wk, 60 * 60 * 24 * 7).
time_type(d, 60 * 60 * 24).
time_type(hr, 60 * 60).
time_type(min, 60).
time_type(sec, 1).</syntaxhighlight>
{{out}}
<pre>
?- maplist(compound_time, [7259,86400,6000000]), !.
7259: 2 hr, 59 sec
86400: 1 d
6000000: 9 wk, 6 d, 10 hr, 40 min
true.
?- times(N, [[wk, 9],[d, 6],[hr,10],[min,40]]), !.
N = 6000000.
</pre>
=={{header|PureBasic}}==
<syntaxhighlight lang="purebasic">
EnableExplicit
Line 2,462 ⟶ 3,447:
CloseConsole()
EndIf
</syntaxhighlight>
{{out}}
Line 2,474 ⟶ 3,459:
===Python: Procedural===
<
t= []
for dm in (60, 60, 24, 7):
Line 2,491 ⟶ 3,476:
86400 sec = 1 d
6000000 sec = 9 wk, 6 d, 10 hr, 40 min
>>> </
===Python: Functional===
<
return ', '.join('%d %s' % (num, unit)
for num, unit in zip([(seconds // d) % m
Line 2,510 ⟶ 3,495:
86400 sec = 1 d
6000000 sec = 9 wk, 6 d, 10 hr, 40 min
>>> </
Or, composing a solution from pure curried functions, including the '''mapAccumR''' abstraction (a combination of of '''map''' and '''reduce''', implemented in a variety of languages and functional libraries, in which a new list is derived by repeated application of the same function, as an accumulator (here, a remainder) passes from right to left):
<syntaxhighlight lang="python">'''Compound duration'''
from functools import reduce
from itertools import chain
# compoundDurationFromUnits :: [Num] -> [String] -> Num -> [(Num, String)]
def compoundDurationFromUnits(qs):
'''A list of compound string representions of a number n of time units,
in terms of the multiples given in qs, and the labels given in ks.
'''
return lambda ks: lambda n: list(
chain.from_iterable(map(
lambda v, k: [(v, k)] if 0 < v else [],
mapAccumR(
lambda a, x: divmod(a, x) if 0 < x else (1, a)
)(n)(qs)[1],
ks
))
)
# --------------------------TEST---------------------------
# main :: IO ()
def main():
'''Tests of various durations, with a
particular set of units and labels.
'''
print(
fTable('Compound durations from numbers of seconds:\n')(str)(
quoted("'")
)(
lambda n: ', '.join([
str(v) + ' ' + k for v, k in
compoundDurationFromUnits([0, 7, 24, 60, 60])(
['wk', 'd', 'hr', 'min', 'sec']
)(n)
])
)([7259, 86400, 6000000])
)
# -------------------------GENERIC-------------------------
# fTable :: String -> (a -> String) ->
# (b -> String) -> (a -> b) -> [a] -> String
def fTable(s):
'''Heading -> x display function -> fx display function ->
f -> xs -> tabular string.
'''
def go(xShow, fxShow, f, xs):
ys = [xShow(x) for x in xs]
w = max(map(len, ys))
return s + '\n' + '\n'.join(map(
lambda x, y: y.rjust(w, ' ') + ' -> ' + fxShow(f(x)),
xs, ys
))
return lambda xShow: lambda fxShow: lambda f: lambda xs: go(
xShow, fxShow, f, xs
)
# mapAccumR :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])
def mapAccumR(f):
'''A tuple of an accumulation and a list derived by a combined
map and fold, with accumulation from right to left.
'''
def go(a, x):
acc, y = f(a[0], x)
return (acc, [y] + a[1])
return lambda acc: lambda xs: (
reduce(go, reversed(xs), (acc, []))
)
# quoted :: Char -> String -> String
def quoted(c):
'''A string flanked on both sides
by a specified quote character.
'''
return lambda s: c + s + c
# MAIN ---
if __name__ == '__main__':
main()</syntaxhighlight>
{{Out}}
<pre>Compound durations from numbers of seconds:
7259 -> '2 hr, 59 sec'
86400 -> '1 d'
6000000 -> '9 wk, 6 d, 10 hr, 40 min'</pre>
=={{header|Quackery}}==
<syntaxhighlight lang="quackery"> [ ' [ 60 60 24 7 ]
witheach [ /mod swap ]
$ ""
' [ $ " wk, " $ " d, "
$ " hr, " $ " min, "
$ " sec, " ]
witheach
[ do rot dup iff
[ number$
swap join join ]
else 2drop ]
-2 split drop ] is duration$ ( n--> $ )
' [ 7259 86400 6000000 ]
witheach
[ dup echo
say " seconds is "
duration$ echo$
say "." cr ]</syntaxhighlight>
{{Out}}
<pre>7259 seconds is 2 hr, 59 sec.
86400 seconds is 1 d.
6000000 seconds is 9 wk, 6 d, 10 hr, 40 min.
</pre>
=={{header|Racket}}==
<
(require racket/string
racket/list)
Line 2,545 ⟶ 3,656:
(check-equal? (seconds->compound-duration-string 6000000) "9 wk, 6 d, 10 hr, 40 min"))
;; Tim Brown 2015-07-21</
{{out}}
All tests pass... there is no output.
=={{header|Raku}}==
(formerly Perl 6)
The built-in <code>polymod</code> method (which is a generalization of the <code>divmod</code> function known from other languages), is a perfect match for a task like this:
<syntaxhighlight lang="raku" line>sub compound-duration ($seconds) {
($seconds.polymod(60, 60, 24, 7) Z <sec min hr d wk>)
.grep(*[0]).reverse.join(", ")
}
# Demonstration:
for 7259, 86400, 6000000 {
say "{.fmt: '%7d'} sec = {compound-duration $_}";
}</syntaxhighlight>
{{out}}
<pre>
7259 sec = 2 hr, 59 sec
86400 sec = 1 d
6000000 sec = 9 wk, 6 d, 10 hr, 40 min
</pre>
=={{header|REXX}}==
===version 1===
<
* Format seconds into a time string
*--------------------------------------------------------------------*/
Line 2,597 ⟶ 3,731:
a=what%how
b=what//how
Return a b</
{{out}}
<pre>2 hr, 59 sec
Line 2,608 ⟶ 3,742:
===version 2===
This REXX version can also handle fractional (seconds) as well as values of zero (time units).
<
parse arg @; if @='' then @=7259 86400 6000000 /*Not specified? Then use the default.*/
do j=1 for words(@);
say right(z, 25) 'seconds: ' convSec(z) /*convert a number to bigger time units*/
end /*j*/
Line 2,617 ⟶ 3,751:
/*──────────────────────────────────────────────────────────────────────────────────────*/
convSec: parse arg x /*obtain a number from the argument. */
w= timeU( 60*60*24*7, 'wk' )
d= timeU( 60*60*24 , 'd' )
h= timeU( 60*60 , 'hr' )
m= timeU( 60 , 'min' )
s= timeU( 1 , 'sec' )
if x\==0 then s=word(s 0, 1) + x 'sec' /*handle fractional (residual) seconds.*/
$=strip(space(w d h m s),,","); if $=='' then z= 0 "sec"
return $
/*──────────────────────────────────────────────────────────────────────────────────────*/
timeU: parse arg u,$;
<pre>
7259 seconds: 2 hr, 59 sec
Line 2,633 ⟶ 3,767:
6000000 seconds: 9 wk, 6 d, 10 hr, 40 min
</pre>
<pre>
1800.7 seconds: 30 min, 0.7 sec
Line 2,642 ⟶ 3,776:
=={{header|Ring}}==
<
sec = 6000005
week = floor(sec/60/60/24/7)
Line 2,659 ⟶ 3,793:
if second > 0 see second
see " seconds" + nl ok
</syntaxhighlight>
=={{header|RPL}}==
≪ MOD LAST / FLOOR ≫ '<span style="color:blue">'''DIVMOD'''</span>' STO
≪ {" wk" " d" " hr" " min" " sec" } → unit
≪ 60 <span style="color:blue">'''DIVMOD'''</span> 60 <span style="color:blue">'''DIVMOD'''</span> 24 <span style="color:blue">'''DIVMOD'''</span> 7 <span style="color:blue">'''DIVMOD'''</span>
1 SF ""
1 unit SIZE '''FOR''' j
'''IF''' SWAP '''THEN'''
LAST →STR unit j GET +
'''IF''' 1 FC?C '''THEN''' ", " SWAP + '''END'''
+ '''END'''
'''NEXT'''
≫ ≫ '<span style="color:blue">'''→CDUR'''</span>' STO
Users of HP-48G and newer models can replace the <code>60 <span style="color:blue">'''DIVMOD'''</span> 60 <span style="color:blue">'''DIVMOD'''</span> 24 <span style="color:blue">'''DIVMOD'''</span> 7 <span style="color:blue">'''DIVMOD'''</span></code> line by:
{ 60 60 24 7 } 1 ≪ MOD LAST / FLOOR ≫ DOSUBS OBJ→ DROP
7259 <span style="color:blue">'''→CDUR'''</span>
86400 <span style="color:blue">'''→CDUR'''</span>
6000000 <span style="color:blue">'''→CDUR'''</span>
10! <span style="color:blue">'''→CDUR'''</span>
{{out}}
<pre>
4: "2 hr, 59 sec"
3: "1 d"
2: "9 wk, 6 d, 10 hr, 40 min"
1: "6 wk"
</pre>
=={{header|Ruby}}==
<
HOUR = MINUTE*60
DAY = HOUR*24
Line 2,676 ⟶ 3,838:
end
[7259, 86400, 6000000].each{|t| puts "#{t}\t: #{sec_to_str(t)}"}</
Output:
<pre>
Line 2,685 ⟶ 3,847:
=={{header|Run BASIC}}==
<
week = int(sec/60/60/24/7)
day = int(sec/60/60/24) mod 7
Line 2,697 ⟶ 3,859:
if hour > 0 then print hour;" hours ";
if minute > 0 then print minute;" minutes ";
if second > 0 then print second;" seconds"</
=={{header|Rust}}==
This solution deviates from the prompt a bit in order to make it more general. The benefit of doing it this way is that any values can be filled in for days, hours, minutes and seconds and the `balance` method will do the balancing accordingly. Also, rather than converting the value into a String, it simply implements the `Display` trait.
<
Line 2,746 ⟶ 3,908:
ct.balance();
println!("After: {}", ct);
}</
=={{header|Scala}}==
<
object seconds{
Line 2,777 ⟶ 3,939:
println("Second = " + sec)
}
}</
=={{header|Scheme}}==
Line 2,785 ⟶ 3,947:
This version uses delete from SRFI 1 and string-join from SRFI 13:
<
(import (scheme base)
(scheme write)
Line 2,814 ⟶ 3,976:
(display (seconds->duration 86400)) (newline)
(display (seconds->duration 6000000)) (newline)
</syntaxhighlight>
{{out}}
Line 2,824 ⟶ 3,986:
=={{header|Sidef}}==
{{trans|
<
gather {
divs.each { |i|
Line 2,843 ⟶ 4,005:
[7259, 86400, 6000000].each { |s|
say "#{'%7d' % s} sec = #{compound_duration(s)}"
}</
{{out}}
Line 2,851 ⟶ 4,013:
6000000 sec = 9 wk, 6 d, 10 hr, 40 min
</pre>
=={{header|Standard ML}}==
<syntaxhighlight lang="sml">local
fun fmtNonZero (0, _, list) = list
| fmtNonZero (n, s, list) = Int.toString n ^ " " ^ s :: list
fun divModHead (_, []) = []
| divModHead (d, head :: tail) = head div d :: head mod d :: tail
in
fun compoundDuration seconds =
let
val digits = foldl divModHead [seconds] [60, 60, 24, 7]
and units = ["wk", "d", "hr", "min", "sec"]
in
String.concatWith ", " (ListPair.foldr fmtNonZero [] (digits, units))
end
end
val () = app (fn s => print (compoundDuration s ^ "\n")) [7259, 86400, 6000000]</syntaxhighlight>
=={{header|Swift}}==
<syntaxhighlight lang="swift">func duration (_ secs:Int) -> String {
if secs <= 0 { return "" }
let units = [(604800,"wk"), (86400,"d"), (3600,"hr"), (60,"min")]
var secs = secs
var result = ""
for (period, unit) in units {
if secs >= period {
result += "\(secs/period) \(unit), "
secs = secs % period
}
}
if secs == 0 {
result.removeLast(2) // remove ", "
} else {
result += "\(secs) sec"
}
return result
}
print(duration(7259))
print(duration(86400))
print(duration(6000000))</syntaxhighlight>
=={{header|Tcl}}==
Line 2,856 ⟶ 4,060:
The data-driven procedure below can be customised to use different breakpoints, simply by editing the dictionary.
<
set factors {
sec 60
Line 2,893 ⟶ 4,097:
check {sec2str 7259} {2 hr, 59 sec}
check {sec2str 86400} {1 d}
check {sec2str 6000000} {9 wk, 6 d, 10 hr, 40 min}</
{{Out}}
Line 2,902 ⟶ 4,106:
=={{header|uBasic/4tH}}==
Since uBasic/4tH is integer-only, it is hard to return a string. However, it is capable to transform an integer value as required.
<syntaxhighlight lang="text">Proc _CompoundDuration(7259)
Proc _CompoundDuration(86400)
Proc _CompoundDuration(6000000)
Line 2,940 ⟶ 4,144:
_d Print " d"; : Return
_hr Print " hr"; : Return
_min Print " min"; : Return</
{{out}}
<pre>2 hr, 59 sec
Line 2,947 ⟶ 4,151:
0 OK, 0:94</pre>
=={{header|Vale}}==
{{works with|Vale|0.2.0}}
<syntaxhighlight lang="vale">
import stdlib.*;
import stdlib.stdin.*;
import stdlib.math.*;
exported func main() {
foreach testCase in [#][
7259,
86400,
6000000,
] {
testCase.timeString().println();
}
}
func timeString(seconds int) str {
result = "";
minutes = seconds / 60;
set seconds = seconds.mod(60);
if seconds > 0 {
set result = seconds.str() + " sec";
}
hours = minutes / 60;
set minutes = minutes.mod(60);
if minutes > 0 {
set result = minutes.str() + if result != "" {
" min, " + result
} else {
" min"
};
}
days = hours / 24;
set hours = hours.mod(24);
if hours > 0 {
set result = hours.str() + if result != "" {
" hr, " + result
} else {
" hr"
};
}
weeks = days / 7;
set days = days.mod(7);
if days > 0 {
set result = days.str() + if result != "" {
" d, " + result
} else {
" d"
};
}
if weeks > 0 {
set result = weeks.str() + if result != "" {
" wk, " + result
} else {
" wk"
};
}
return result;
}
</syntaxhighlight>
=={{header|VBA}}==
<syntaxhighlight lang="vb">Private Function compound_duration(ByVal seconds As Long) As String
minutes = 60
hours = 60 * minutes
days_ = 24 * hours
weeks = 7 * days_
Dim out As String
w = seconds \ weeks
seconds = seconds - w * weeks
d = seconds \ days_
seconds = seconds - d * days_
h = seconds \ hours
seconds = seconds - h * hours
m = seconds \ minutes
s = seconds Mod minutes
out = IIf(w > 0, w & " wk, ", "") & _
IIf(d > 0, d & " d, ", "") & _
IIf(h > 0, h & " hr, ", "") & _
IIf(m > 0, m & " min, ", "") & _
IIf(s > 0, s & " sec", "")
If Right(out, 2) = ", " Then
compound_duration = Left(out, Len(out) - 2)
Else
compound_duration = out
End If
End Function
Public Sub cstcd()
Debug.Print compound_duration(7259)
Debug.Print compound_duration(86400)
Debug.Print compound_duration(6000000)
End Sub</syntaxhighlight>{{out}}
<pre>2 hr, 59 sec
1 d
9 wk, 6 d, 10 hr, 40 min</pre>
=={{header|VBScript}}==
<syntaxhighlight lang="vb">
Function compound_duration(n)
Do Until n = 0
Line 2,987 ⟶ 4,294:
WScript.StdOut.WriteLine compound_duration(86400)
WScript.StdOut.WriteLine compound_duration(6000000)
</syntaxhighlight>
{{Out}}
<pre>
2 hr, 59 sec
1 d
9 wk, 6 d, 10 hr, 40 min
</pre>
=={{header|Wren}}==
<syntaxhighlight lang="wren">var duration = Fn.new { |s|
if (s < 1) return "0 sec"
var dur = ""
var divs = [7, 24, 60, 60, 1]
var units = ["wk", "d", "hr", "min", "sec"]
var t = divs.reduce { |prod, div| prod * div }
for (i in 0...divs.count) {
var u = (s/t).floor
if (u > 0) {
dur = dur + "%(u) %(units[i]), "
s = s % t
}
t = t / divs[i]
}
if (dur.endsWith(", ")) dur = dur[0..-3]
return dur
}
for (s in [7259, 86400, 6000000]) System.print(duration.call(s))</syntaxhighlight>
{{out}}
<pre>
2 hr, 59 sec
1 d
9 wk, 6 d, 10 hr, 40 min
</pre>
=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">char Str(80);
func Duration(Sec); \Convert seconds to compound duration
int Sec, Amt, Unit, DoComma, I, Quot;
[Amt:= [7*24*60*60, 24*60*60, 60*60, 60, 1];
Unit:= [" wk", " d", " hr", " min", " sec"];
DoComma:= false;
for I:= 0 to 4 do
[Quot:= Sec/Amt(I);
Sec:= rem(0);
if Quot # 0 then
[if DoComma then Text(8, ", ");
DoComma:= true;
IntOut(8, Quot);
Text(8, Unit(I));
];
];
ChOut(8, $0D); ChOut(8, $8A); \terminating CR+LF
I:= 0;
loop [Str(I):= ChIn(8);
if Str(I) >= $80 then return Str;
I:= I+1;
];
];
[Text(0, Duration(7259));
Text(0, Duration(86400));
Text(0, Duration(6_000_000));
]</syntaxhighlight>
{{out}}
<pre>
2 hr, 59 sec
Line 2,997 ⟶ 4,369:
=={{header|zkl}}==
<
r,b:=List(),0;
foreach u in (T(60,60,24,7)){
Line 3,004 ⟶ 4,376:
}
r.append(sec).reverse()
}</
Or, if you like to be concise:
<
T(60,60,24,7).reduce(fcn(n,u,r){ n,u=n.divr(u); r.append(u); n },
sec,r:=List()):r.append(_).reverse();
}</
were the ":" op takes the left result and stuffs it into the "_" position.
<
foreach s in (T(7259,86400,6000000)){
toWDHMS(s).zip(units).pump(List,fcn([(t,u)]){ t and String(t,u) or "" })
.filter().concat(", ").println();
}</
{{out}}
<pre>
Line 3,025 ⟶ 4,397:
=={{header|ZX Spectrum Basic}}==
{{trans|AWK}}
<
20 DATA 10,7259,86400,6000000,0,1,60,3600,604799,604800,694861
30 READ n
Line 3,046 ⟶ 4,418:
200 NEXT i
210 STOP
220 DEF FN m(a,b)=a-INT (a/b)*b</
| |||