Convert seconds to compound duration: Difference between revisions
→{{header|langur}}
No edit summary |
Langurmonkey (talk | contribs) |
||
(95 intermediate revisions by 35 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]
Line 294 ⟶ 393:
unitParts(intSeconds, [missing value, 7, 24, 60, 60])
end weekParts
-- localCompoundDuration :: Int -> String
Line 315 ⟶ 415:
end localCompoundDuration
-- unitParts :: Int -> [maybe Int] -> [Int]
Line 339 ⟶ 439:
{remaining:intTotal, parts:[]}, unitList)
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
-- foldr :: (
on foldr(f, startValue, xs)
tell mReturn(f)
Line 355 ⟶ 467:
end foldr
on intercalate(delim, xs)
set
{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
Line 374 ⟶ 491:
end tell
end map
-- min :: Ord a => a -> a -> a
Line 384 ⟶ 502:
end min
-- mReturn ::
on mReturn(f)
if script is class of f then
f
else
Line 395 ⟶ 514:
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
repeat with i from 1 to lng
set end of
end repeat
return
end zip</
{{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 436 ⟶ 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 447 ⟶ 638:
s :=n
return trim((w?w " wk, ":"") (d?d " d, ":"") (h?h " hr, ":"") (m?m " min, ":"") (s?s " sec":""),", ")
}</
Examples:<
(
7259
Line 458 ⟶ 649:
res .= A_LoopField "`t: " duration(A_LoopField) "`n"
MsgBox % res
return</
Outputs:<pre>7259 : 2 hr, 59 sec
86400 : 1 d
Line 464 ⟶ 655:
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f CONVERT_SECONDS_TO_COMPOUND_DURATION.AWK
BEGIN {
Line 499 ⟶ 690:
return(str)
}
</syntaxhighlight>
<p>Output:</p>
<pre>
Line 512 ⟶ 703:
604800 1 wk
694861 1 wk, 1 d, 1 hr, 1 min, 1 sec
</pre>
Line 551 ⟶ 708:
==={{header|Commodore BASIC}}===
<
20 REM ADAPTED FROM RUN BASIC VERSION
30 REM ===============================================================
Line 585 ⟶ 742:
1190 PRINT SC;"SEC"
1200 PRINT
1210 RETURN</
{{out}}
7259 sec
Line 596 ⟶ 753:
= 9 wk, 6 dy, 10 hr, 40 min
==={{header|BaCon}}===
<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}}===
<
PRINT FN_convert(7259)
PRINT FN_convert(86400)
Line 618 ⟶ 817:
ENDIF
NEXT
= compound$</
{{out}}
<pre>2 hr, 59 sec
Line 625 ⟶ 824:
==={{header|IS-BASIC}}===
<
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
Line 639 ⟶ 838:
220 END IF
230 NEXT
240 PRINT</
=={{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 670 ⟶ 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 686 ⟶ 919:
===C: Version written in C89. Average skill level.===
<
* Program seconds2string, C89 version.
*
Line 748 ⟶ 981:
return EXIT_FAILURE;
}</
===C: Version written in C99. Low skill level.===
<syntaxhighlight lang="c">
#include <inttypes.h> /* requires c99 */
#include <stdbool.h> /* requires c99 */
Line 892 ⟶ 1,125:
return minutes*60;
}
</syntaxhighlight>
{{out}}
Line 906 ⟶ 1,139:
</pre>
=={{header|C sharp|C#}}==
===C#: Standard method===
<
using System.Collections.Generic;
using System.Linq;
Line 960 ⟶ 1,193:
}
}</
{{out}}
Line 976 ⟶ 1,209:
{{libheader|System.Linq}}
{{works with|C sharp|6}}
<
{
if (seconds < 0) throw new ArgumentOutOfRangeException(nameof(seconds));
Line 989 ⟶ 1,222:
where parts[index] > 0
select parts[index] + units[index]);
}</
=={{header|C++}}==
{{works with|C++11}}
<
#include <iostream>
#include <vector>
Line 1,029 ⟶ 1,262:
std::cout << " 86400 sec is "; print(convert( 86400));
std::cout << "6000000 sec is "; print(convert(6000000));
}</
{{out}}
<pre>
Line 1,038 ⟶ 1,271:
=={{header|Clojure}}==
<
(def seconds-in-minute 60)
Line 1,065 ⟶ 1,298:
(seconds->duration 7259)
(seconds->duration 86400)
(seconds->duration 6000000)</
{{out}}
Line 1,073 ⟶ 1,306:
"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,148 ⟶ 1,415:
.
end program fmt.
end program fmt-dura.</
<pre>Enter duration (seconds): 7259
2 hr, 59 sec
Line 1,157 ⟶ 1,424:
=={{header|Common Lisp}}==
<
(defconstant +seconds-in-hour* (* 60 +seconds-in-minute*))
(defconstant +seconds-in-day* (* 24 +seconds-in-hour*))
Line 1,178 ⟶ 1,445:
(seconds->duration 86400)
(seconds->duration 6000000)
</syntaxhighlight>
{{out}}
<pre>
Line 1,187 ⟶ 1,454:
=={{header|D}}==
<syntaxhighlight lang="d">
import std.stdio, std.conv, std.algorithm;
Line 1,227 ⟶ 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,236 ⟶ 1,587:
=={{header|Elixir}}==
<
@minute 60
@hour @minute*60
Line 1,256 ⟶ 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,272 ⟶ 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,362 ⟶ 1,713:
% **************************************************
</syntaxhighlight>
Output:
Line 1,372 ⟶ 1,723:
=={{header|F_Sharp|F#}}==
<
let convert seconds =
Line 1,392 ⟶ 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,400 ⟶ 1,751:
=={{header|Factor}}==
<
sequences.generalizations ;
: mod/ ( x y -- w z ) /mod swap ;
: convert (
60
: .time ( n -- )
convert [ number>string ] map qw{ wk d hr min sec } zip
[ first "0" = ] reject [ " " join ] map ", " join print ;
{{out}}
<pre>
Line 1,423 ⟶ 1,773:
=={{header|Forth}}==
{{works with|Gforth|0.7.3}}
<
: ., C @ IF ." , " THEN 1 C ! ;
: .TIME ( n --)
Line 1,430 ⟶ 1,780:
[ 60 60 * ]L /MOD ?DUP-IF ., . ." hr" THEN
[ 60 ]L /MOD ?DUP-IF ., . ." min" THEN
?DUP-IF ., . ." sec" THEN 0 C ! ;</
{{out}}
<pre>2 hr, 59 sec
Line 1,440 ⟶ 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,478 ⟶ 1,828:
CALL PROUST(-666)
END
</syntaxhighlight>
Output:
<pre>
Line 1,490 ⟶ 1,840:
=={{header|FreeBASIC}}==
<
Sub Show(m As Long)
Line 1,526 ⟶ 1,876:
Show 86400 seconds
Show 6000000 seconds
sleep</
Output:
<pre>
Line 1,532 ⟶ 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]'''
<
Dim iInput As Integer[] = [7259, 86400, 6000000] 'Input details
Dim iChecks As Integer[] = [604800, 86400, 3600, 60] 'Weeks, days, hours, mins in seconds
Line 1,566 ⟶ 1,963:
Next
End</
Output:
<pre>
Line 1,575 ⟶ 1,972:
=={{header|Go}}==
<
import "fmt"
Line 1,624 ⟶ 2,021:
return
}
</syntaxhighlight>
{{Out}}
<pre>
Line 1,631 ⟶ 2,028:
9 wk, 6 d, 10 hr, 40 min
</pre>
=={{header|Haskell}}==
<
import Data.List (intercalate, mapAccumR)
import System.Environment (getArgs)
Line 1,659 ⟶ 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,669 ⟶ 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 ->
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
|
| otherwise = xs
weekParts :: Int -> Int -> Int -> [Int]
weekParts daysPerWeek hoursPerDay =
snd
. flip
(mapAccumR byUnits)
[0, daysPerWeek, hoursPerDay, 60, 60]
byUnits :: Int -> Int -> (Int, Int)
byUnits rest x = (quot (rest - m) u, m)
where
| 0
--------------------------- TEST -------------------------
translation :: String -> Int -> Int -> Int -> String
translation local daysPerWeek hoursPerDay n =
intercalate " -> " $
[ show,
durationString
", "
" "
daysPerWeek
hoursPerDay
(words local)
]
<*> [n]
main :: IO ()
main = do
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,708 ⟶ 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,753 ⟶ 2,299:
return sec;
}
}</
<pre>2 hr, 59 sec
1 d
9 wk, 6 d, 10 hr, 40 min</pre>
=={{header|JavaScript}}==
Line 1,766 ⟶ 2,311:
====ES5====
<
'use strict';
Line 1,825 ⟶ 2,370:
})();
</syntaxhighlight>
{{Out}}
Line 1,834 ⟶ 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,879 ⟶ 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,889 ⟶ 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|Julia}}==
<syntaxhighlight lang
function duration(sec::Integer)::String
t = Array{Int}([])
for dm in (60, 60, 24, 7)
sec, m = divrem(sec, dm)
end
return join(["$num$unit" for (num, unit) in zip(t, ["w", "d", "h", "m", "s"]) if num > 0], ", ")
end
Line 1,915 ⟶ 2,471:
@show duration(86400)
@show duration(6000000)
</syntaxhighlight>
{{out}}
Line 1,923 ⟶ 2,479:
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}}==
<
if (n < 0) return "" // task doesn't ask for negative integers to be converted
if (n == 0) return "0 sec"
Line 1,963 ⟶ 2,535:
val durations = intArrayOf(0, 7, 84, 7259, 86400, 6000000)
durations.forEach { println("$it\t-> ${compoundDuration(it)}") }
}</
{{out}}
Line 1,974 ⟶ 2,546:
6000000 -> 9 wk, 6 d, 10 hr, 40 min
</pre>
=={{header|langur}}==
<syntaxhighlight lang="langur">val d = 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 = d(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>
You could also convert nanoseconds to a langur duration. Langur durations use a separate count for years, months, days, hours, minutes, seconds, and nanoseconds. A "month" and a "year" are difficult to define in terms of seconds, which is one of the reasons langur has a duration type.
=={{header|Liberty BASIC}}==
I got a bit carried away and added 'years'...
<syntaxhighlight lang="lb">
[start]
input "Enter SECONDS: "; seconds
Line 2,066 ⟶ 2,666:
print
goto [start]
</syntaxhighlight>
{{out}}
<pre>
Line 2,082 ⟶ 2,682:
=={{header|Lua}}==
<
local units, dur = {"wk", "d", "hr", "min"}, ""
for i, v in ipairs({604800, 86400, 3600, 60}) do
Line 2,099 ⟶ 2,699:
print(duration(7259))
print(duration(86400))
print(duration(6000000))</
=={{header|Maple}}==
<syntaxhighlight lang="maple">
tim := proc (s) local weeks, days, hours, minutes, seconds;
weeks := trunc((1/604800)*s);
Line 2,111 ⟶ 2,711:
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 2,126 ⟶ 2,725:
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,210 ⟶ 2,876:
n calc s
in
List.iter testit test_cases</
{{out}}
[PASS] 7259 seconds -> 2 hr, 59 sec; expected: 2 hr, 59 sec
Line 2,225 ⟶ 2,891:
{{Works with|PARI/GP|2.7.4 and above}}
<
\\ Convert seconds to compound duration
\\ 4/11/16 aev
Line 2,242 ⟶ 2,908:
print(secs2compdur(6000000));
}
</
{{Output}}
Line 2,251 ⟶ 2,917:
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,264 ⟶ 3,056:
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,364 ⟶ 3,129:
(pack @ " " Str) ) )
(604800 86400 3600 60 1)
'("wk" "d" "hr" "min" "sec") ) ) ) )</
Output:
<pre>7259 2 hr, 59 sec
Line 2,371 ⟶ 3,136:
=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">
/* Convert seconds to Compound Duration (weeks, days, hours, minutes, seconds). */
Line 2,399 ⟶ 3,164:
end;
end cvt;
</syntaxhighlight>
Results:
<pre>
Line 2,415 ⟶ 3,180:
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">
function Get-Time
{
Line 2,532 ⟶ 3,297:
}
}
</syntaxhighlight>
{{Out}}
Line 2,562 ⟶ 3,327:
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,621 ⟶ 3,449:
CloseConsole()
EndIf
</syntaxhighlight>
{{out}}
Line 2,633 ⟶ 3,461:
===Python: Procedural===
<
t= []
for dm in (60, 60, 24, 7):
Line 2,650 ⟶ 3,478:
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,669 ⟶ 3,497:
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,704 ⟶ 3,658:
(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,756 ⟶ 3,733:
a=what%how
b=what//how
Return a b</
{{out}}
<pre>2 hr, 59 sec
Line 2,767 ⟶ 3,744:
===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,776 ⟶ 3,753:
/*──────────────────────────────────────────────────────────────────────────────────────*/
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,792 ⟶ 3,769:
6000000 seconds: 9 wk, 6 d, 10 hr, 40 min
</pre>
<pre>
1800.7 seconds: 30 min, 0.7 sec
Line 2,801 ⟶ 3,778:
=={{header|Ring}}==
<
sec = 6000005
week = floor(sec/60/60/24/7)
Line 2,818 ⟶ 3,795:
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,835 ⟶ 3,840:
end
[7259, 86400, 6000000].each{|t| puts "#{t}\t: #{sec_to_str(t)}"}</
Output:
<pre>
Line 2,844 ⟶ 3,849:
=={{header|Run BASIC}}==
<
week = int(sec/60/60/24/7)
day = int(sec/60/60/24) mod 7
Line 2,856 ⟶ 3,861:
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,905 ⟶ 3,910:
ct.balance();
println!("After: {}", ct);
}</
=={{header|Scala}}==
<
object seconds{
Line 2,936 ⟶ 3,941:
println("Second = " + sec)
}
}</
=={{header|Scheme}}==
Line 2,944 ⟶ 3,949:
This version uses delete from SRFI 1 and string-join from SRFI 13:
<
(import (scheme base)
(scheme write)
Line 2,973 ⟶ 3,978:
(display (seconds->duration 86400)) (newline)
(display (seconds->duration 6000000)) (newline)
</syntaxhighlight>
{{out}}
Line 2,983 ⟶ 3,988:
=={{header|Sidef}}==
{{trans|
<
gather {
divs.each { |i|
Line 3,002 ⟶ 4,007:
[7259, 86400, 6000000].each { |s|
say "#{'%7d' % s} sec = #{compound_duration(s)}"
}</
{{out}}
Line 3,010 ⟶ 4,015:
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 3,015 ⟶ 4,062:
The data-driven procedure below can be customised to use different breakpoints, simply by editing the dictionary.
<
set factors {
sec 60
Line 3,052 ⟶ 4,099:
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 3,061 ⟶ 4,108:
=={{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 3,099 ⟶ 4,146:
_d Print " d"; : Return
_hr Print " hr"; : Return
_min Print " min"; : Return</
{{out}}
<pre>2 hr, 59 sec
Line 3,106 ⟶ 4,153:
0 OK, 0:94</pre>
=={{header|Uiua}}==
{{Works with|Uiua|0.12.0-dev.1}}
[https://www.uiua.org/pad?src=0_12_0-dev_1__IyBCdWlsZHMgYSBzdHJpbmcgcmVwcmVzZW50YXRpb24gb2YgYSB0aW1lIHBlcmlvZAoKVW5pdHMg4oaQIHsic2Vjb25kIiAibWludXRlIiAiaG91ciIgImRheSIgIndlZWsifQpEdXJhdGlvbnMg4oaQIFs2MCA2MCAyNCA3IDk5OTldCgojIG51bWJlci1vZi1zZWNvbmRzIC0-IFtTIE0gSCBEIFddClBhcnRzIOKGkCDih4wo4peM4oinKOKKmeKKguKKgyjijIrDt3zil78pKSBEdXJhdGlvbnPiiplbXSkKIyBTdHJpbmdpZnkgYSB1bml0OiB7IlgiICJ1bml0In0gLT4gYm94IlggdW5pdHMiICAgICAgIApTdW5pdCDihpAgL-KNmijiioLiioIpIiAi4o2l4o2cKOKKoTF84o2a4oqC4oqZQHMp4omg4pahIjEi4oqiLgojIFBhcnNlIHNlY29uZHMgYXMgYSBzdHJpbmcgcGVyaW9kOiBOIC0-ICJ4eHgiICAgIApTdHJpbmcg4oaQIMKw4pah4oqiL-KNmiQiXywgXyLih4ziiaFTdW5pdOKWveKKgyjCsXzijYnih4ziip9Vbml0c8Kw4ouVKSBQYXJ0cwriiLUoW-KWoVN0cmluZ10pWzcyNTkgODY0MDAgNjAwMDAwMCAxNDAwMDAwMCAzMTQ0OTU5OSAzMTQ0OTYwMV0K Run it in Uiua Pad!]
<syntaxhighlight lang="uiua">
# Builds a string representation of a time period
Units ← {"second" "minute" "hour" "day" "week"}
Durations ← [60 60 24 7 9999]
# number-of-seconds -> [S M H D W]
Parts ← ⇌(◌∧(⊙⊂⊃(⌊÷|◿)) Durations⊙[])
# Stringify a unit: {"X" "unit"} -> box"X units"
Sunit ← /⍚(⊂⊂)" "⍥⍜(⊡1|⍚⊂⊙@s)≠□"1"⊢.
# Parse seconds as a string period: N -> "xxx"
String ← °□⊢/⍚$"_, _"⇌≡Sunit▽⊃(±|⍉⇌⊟Units°⋕) Parts
∵([□String])[7259 86400 6000000 14000000 31449599 31449601]
</syntaxhighlight>
{{out}}
<pre>
╭─
╷ ⌜2 hours, 59 seconds⌟
⌜1 day⌟
⌜9 weeks, 6 days, 10 hours, 40 minutes⌟
⌜23 weeks, 1 day, 53 minutes, 20 seconds⌟
⌜51 weeks, 6 days, 23 hours, 59 minutes, 59 seconds⌟
⌜52 weeks, 1 second⌟
╯
</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 3,146 ⟶ 4,325:
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 3,156 ⟶ 4,400:
=={{header|zkl}}==
<
r,b:=List(),0;
foreach u in (T(60,60,24,7)){
Line 3,163 ⟶ 4,407:
}
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,184 ⟶ 4,428:
=={{header|ZX Spectrum Basic}}==
{{trans|AWK}}
<
20 DATA 10,7259,86400,6000000,0,1,60,3600,604799,604800,694861
30 READ n
Line 3,205 ⟶ 4,449:
200 NEXT i
210 STOP
220 DEF FN m(a,b)=a-INT (a/b)*b</
|