Convert seconds to compound duration: Difference between revisions

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

{{trans|Julia}}

[Int] t

L(dm) [60, 60, 24, 7]

print(duration(7259))

print(duration(86400))

 

=={{header|Ada}}==

 

procedure Convert is

IO.New_Line;

end loop;

 

{{out}}

 

=={{header|ALGOL 68}}==

MODE DURATION = STRUCT( INT weeks, days, hours, minutes, seconds );

 

print( ( TOSTRING TODURATION 7259, newline ) );

print( ( TOSTRING TODURATION 86400, newline ) );

{{out}}

<pre>

=={{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 );

write( durationToString( toDuration( 86400 ) ) );

write( durationToString( toDuration( 6000000 ) ) )

{{out}}

<pre>

9 wk, 6 d, 10 hr, 40 min

</pre>

 

=={{header|AppleScript}}==

 

-- weekParts Int -> [Int]

unitParts(intSeconds, [missing value, 7, 24, 60, 60])

end weekParts

 

-- localCompoundDuration :: Int -> String

end localCompoundDuration

 

 

-- unitParts :: Int -> [maybe Int] -> [Int]

{remaining:intTotal, parts:[]}, unitList)

end unitParts

 

 

 

on foldr(f, startValue, xs)

tell mReturn(f)

end foldr

 

set my text item delimiters to dlm

end intercalate

 

-- map :: (a -> b) -> [a] -> [b]

on map(f, xs)

tell mReturn(f)

set lng to length of xs

end tell

end map

 

-- min :: Ord a => a -> a -> a

end min

 

on mReturn(f)

f

else

end if

end mReturn

 

-- unlines :: [String] -> String

on unlines(xs)

end unlines

 

-- zip :: [a] -> [b] -> [(a, b)]

on zip(xs, ys)

set lng to min(length of xs, length of ys)

repeat with i from 1 to lng

end repeat

{{Out}}

<pre>7259 -> 2 hr, 59 sec

 

----

error "secondsToCompoundDuration() handler only accepts positive integers."

end secondsToCompoundDuration

 

return secondsToCompoundDuration(7259) & linefeed & ¬

secondsToCompoundDuration(86400) & linefeed & ¬

 

{{output}}

1 d

 

=={{header|Applesoft BASIC}}==

110 FOR I = 0 TO 4

120 READ M(I), U$(I)

 

270 END

 

=={{header|AutoHotkey}}==

sec:=1, min:=60*sec, hr:=60*min, day:=24*hr, wk:=7*day

w :=n//wk , n:=Mod(n,wk)

s :=n

return trim((w?w " wk, ":"") (d?d " d, ":"") (h?h " hr, ":"") (m?m " min, ":"") (s?s " sec":""),", ")

(

7259

res .= A_LoopField "`t: " duration(A_LoopField) "`n"

MsgBox % res

Outputs:<pre>7259 : 2 hr, 59 sec

86400 : 1 d

 

=={{header|AWK}}==

# syntax: GAWK -f CONVERT_SECONDS_TO_COMPOUND_DURATION.AWK

BEGIN {

return(str)

}

<p>Output:</p>

<pre>

 

==={{header|Commodore BASIC}}===

20 REM ADAPTED FROM RUN BASIC VERSION

30 REM ===============================================================

1190 PRINT SC;"SEC"

1200 PRINT

{{out}}

7259 sec

= 9 wk, 6 dy, 10 hr, 40 min

 

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

PRINT FN_convert(7259)

PRINT FN_convert(86400)

ENDIF

NEXT

{{out}}

<pre>2 hr, 59 sec

 

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

110 NUMERIC UN(1 TO 5),SEC,UNIT

120 STRING T$(1 TO 5)*3

220 END IF

230 NEXT

 

=={{header|Batch File}}==

::The Main Thing...

for %%d in (7259 86400 6000000) do call :duration %%d

if %1 gtr 0 echo %1 sec = %output:~1,-1%

goto :EOF

{{Out}}

<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

 

{{Out}}

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

 

{{out}}

 

===C: Version written in C89. Average skill level.===

* Program seconds2string, C89 version.

*

 

return EXIT_FAILURE;

 

===C: Version written in C99. Low skill level.===

#include <inttypes.h> /* requires c99 */

#include <stdbool.h> /* requires c99 */

return minutes*60;

}

 

{{out}}

</pre>

 

 

===C#: Standard method===

using System.Collections.Generic;

using System.Linq;

}

 

{{out}}

{{libheader|System.Linq}}

{{works with|C sharp|6}}

{

if (seconds < 0) throw new ArgumentOutOfRangeException(nameof(seconds));

where parts[index] > 0

select parts[index] + units[index]);

 

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

{{works with|C++11}}

#include <iostream>

#include <vector>

std::cout << " 86400 sec is "; print(convert( 86400));

std::cout << "6000000 sec is "; print(convert(6000000));

{{out}}

<pre>

 

=={{header|Clojure}}==

 

(def seconds-in-minute 60)

(seconds->duration 7259)

(seconds->duration 86400)

 

{{out}}

"9 wk, 6 d, 10 hr, 40 min"

</pre>

 

=={{header|COBOL}}==

program-id. fmt-dura.

data division.

.

end program fmt.

<pre>Enter duration (seconds): 7259

2 hr, 59 sec

 

=={{header|Common Lisp}}==

(defconstant +seconds-in-hour* (* 60 +seconds-in-minute*))

(defconstant +seconds-in-day* (* 24 +seconds-in-hour*))

(seconds->duration 86400)

(seconds->duration 6000000)

{{out}}

<pre>

 

=={{header|D}}==

import std.stdio, std.conv, std.algorithm;

 

6_000_000.ConvertSeconds.writeln;

}

{{out}}

<pre>

9 wk, 6 d, 10 hr, 40 min

</pre>

 

=={{header|EasyLang}}==

.

.

 

{{out}}

 

=={{header|Elixir}}==

@minute 60

@hour @minute*60

Enum.each([7259, 86400, 6000000], fn sec ->

:io.fwrite "~10w sec : ~s~n", [sec, Convert.sec_to_str(sec)]

 

{{out}}

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).

 

 

% **************************************************

 

Output:

 

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

 

let convert seconds =

|> Seq.map (fun str -> let sec = UInt32.Parse str in (sec, convert sec))

|> Seq.iter (fun (s, v) -> printfn "%10i = %s" s v)

{{out}}

<pre>>RosettaCode 7259 86400 6000000

 

=={{header|Factor}}==

sequences.generalizations ;

 

[ first "0" = ] reject [ " " join ] map ", " join print ;

{{out}}

<pre>

=={{header|Forth}}==

{{works with|Gforth|0.7.3}}

: ., C @ IF ." , " THEN 1 C ! ;

: .TIME ( n --)

[ 60 60 * ]L /MOD ?DUP-IF ., . ." hr" THEN

[ 60 ]L /MOD ?DUP-IF ., . ." min" THEN

{{out}}

<pre>2 hr, 59 sec

 

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.

SUBROUTINE PROUST(T) !Remembrance of time passed.

INTEGER T !The time, in seconds. Positive only, please.

CALL PROUST(-666)

END

Output:

<pre>

 

=={{header|FreeBASIC}}==

 

Sub Show(m As Long)

Show 86400 seconds

Show 6000000 seconds

Output:

<pre>

Frink's <CODE>-&gt;</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.

 

wk := week

n = eval[input["Enter duration in seconds: "]]

res =~ %s/, 0[^,]+//g

println[res]

 

=={{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

Next

 

Output:

<pre>

 

=={{header|Go}}==

 

import "fmt"

return

}

{{Out}}

<pre>

 

=={{header|Haskell}}==

import Data.List (intercalate, mapAccumR)

import System.Environment (getArgs)

forM_ args $ \arg -> case readMaybe arg of

Just n -> printf "%7d seconds = %s\n" n (compoundDuration n)

 

{{out}}

Or, parameterising both the local names for these durations, and also the working assumptions about hours per day, and days per week:

 

 

 

 

timeTags :: String -> (Int, String) -> [String] -> [String]

weekParts :: Int -> Int -> Int -> [Int]

weekParts daysPerWeek hoursPerDay =

 

byUnits :: Int -> Int -> (Int, Int)

| otherwise = (1, rest)

 

 

translation :: String -> Int -> Int -> Int -> String

translation local daysPerWeek hoursPerDay n =

intercalate " -> " $

 

main :: IO ()

 

putStrLn "\nor, at 8 hours per day, 5 days per week:"

{{Out}}

<pre>Assuming 24/7:

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).

Task examples:

 

2 hr, 59 sec

fmtsecs 86400

1 d

fmtsecs 6000000

 

=={{header|Java}}==

 

public static void main(String[] args) {

return sec;

}

 

<pre>2 hr, 59 sec

====ES5====

 

'use strict';

 

 

})();

 

{{Out}}

 

====ES6====

 

// compoundDuration :: [String] -> Int -> String

const compoundDuration = labels =>

.map((v, i) => [v, labels[i]])

.reduce((a, x) =>

)

 

.reduceRight((a, x) => {

const

r = a[0],

mod = x !== 0 ? r % x : r;

 

 

 

return main();

{{Out}}

<pre>7259 -> 2 hr, 59 sec

=={{header|jq}}==

{{works with|jq|1.4}}

def nonzero(text): floor | if . > 0 then "\(.) \(text)" else empty end;

if . == 0 then "0 sec"

(. % 60 | nonzero("sec"))]

| join(", ")

 

''Examples''':

{{out}}

0: 0 sec

7259: 2 hr, 59 sec

86400: 1 d

 

=={{header|Julia}}==

function duration(sec::Integer)::String

t = Array{Int}([])

@show duration(86400)

@show duration(6000000)

 

{{out}}

duration(6000000) = "9w, 6d, 10h, 40m"

</pre>

 

=={{header|Kotlin}}==

if (n < 0) return "" // task doesn't ask for negative integers to be converted

if (n == 0) return "0 sec"

val durations = intArrayOf(0, 7, 84, 7259, 86400, 6000000)

durations.forEach { println("$it\t-> ${compoundDuration(it)}") }

 

{{out}}

86400 -> 1 d

6000000 -> 9 wk, 6 d, 10 hr, 40 min

</pre>

 

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

I got a bit carried away and added 'years'...

[start]

input "Enter SECONDS: "; seconds

print

goto [start]

{{out}}

<pre>

 

=={{header|Lua}}==

local units, dur = {"wk", "d", "hr", "min"}, ""

for i, v in ipairs({604800, 86400, 3600, 60}) do

print(duration(7259))

print(duration(86400))

 

=={{header|Maple}}==

tim := proc (s) local weeks, days, hours, minutes, seconds;

weeks := trunc((1/604800)*s);

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;

 

StringJoin @@ (Riffle[

ToString /@ ((({Floor[x/604800],

Grid[Table[{n, "secs =",

compoundDuration[n]}, {n, {7259, 86400, 6000000}}],

 

{{out}}

86400 secs = 1 d,

 

=={{header|OCaml}}==

{{works with|OCaml|4.03+}}

(max_int, "wk"); (* many wk = many wk *)

(7, "d"); (* 7 d = 1 wk *)

n calc s

in

{{out}}

[PASS] 7259 seconds -> 2 hr, 59 sec; expected: 2 hr, 59 sec

{{Works with|PARI/GP|2.7.4 and above}}

 

\\ Convert seconds to compound duration

\\ 4/11/16 aev

print(secs2compdur(6000000));

}

 

{{Output}}

9 wk, 6 d, 10 hr, 40 min

</pre>

 

=={{header|Perl}}==

 

===Direct calculation===

use warnings;

 

for (7259, 86400, 6000000) {

printf "%7d sec = %s\n", $_, compound_duration($_)

{{out}}

<pre> 7259 sec = 2 hr, 59 sec

===Using polymod===

More general approach for mixed-radix conversions.

use warnings;

use Math::AnyNum 'polymod';

for (<7259 86400 6000000 3380521>) {

printf "%7d sec = %s\n", $_, compound_duration($_)

{{out}}

<pre> 7259 sec = 2 hr, 59 sec

=={{header|Phix}}==

There is a standard function for this, for more details see builtins/pelapsed.e (which will be kept up to date, unlike having a copy here)

{{out}}

<pre>

</pre>

You may also be interested in the timedelta() function, which converts durations to seconds, eg:

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(tab (-10 -30)

Sec

(pack @ " " Str) ) )

(604800 86400 3600 60 1)

Output:

<pre>7259 2 hr, 59 sec

 

=={{header|PL/I}}==

/* Convert seconds to Compound Duration (weeks, days, hours, minutes, seconds). */

 

end;

end cvt;

Results:

<pre>

 

=={{header|PowerShell}}==

function Get-Time

{

}

}

 

{{Out}}

See below for examples.

 

 

% helper to perform the operation with just a number.

time_type(hr, 60 * 60).

time_type(min, 60).

 

{{out}}

 

=={{header|PureBasic}}==

EnableExplicit

 

CloseConsole()

EndIf

 

{{out}}

 

===Python: Procedural===

t= []

for dm in (60, 60, 24, 7):

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

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):

 

 

from functools import reduce

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Compound durations from numbers of seconds:

86400 -> '1 d'

6000000 -> '9 wk, 6 d, 10 hr, 40 min'</pre>

 

=={{header|Racket}}==

 

(require racket/string

racket/list)

(check-equal? (seconds->compound-duration-string 6000000) "9 wk, 6 d, 10 hr, 40 min"))

 

 

{{out}}

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:

 

($seconds.polymod(60, 60, 24, 7) Z <sec min hr d wk>)

.grep(*[0]).reverse.join(", ")

for 7259, 86400, 6000000 {

say "{.fmt: '%7d'} sec = {compound-duration $_}";

 

{{out}}

=={{header|REXX}}==

===version 1===

* Format seconds into a time string

*--------------------------------------------------------------------*/

a=what%how

b=what//how

{{out}}

<pre>2 hr, 59 sec

===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.*/

 

return $

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; when using the default (internal) inputs:}}

<pre>

 

=={{header|Ring}}==

sec = 6000005

week = floor(sec/60/60/24/7)

if second > 0 see second

see " seconds" + nl ok

 

=={{header|Ruby}}==

HOUR = MINUTE*60

DAY = HOUR*24

end

 

Output:

<pre>

 

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

week = int(sec/60/60/24/7)

day = int(sec/60/60/24) mod 7

if hour > 0 then print hour;" hours ";

if minute > 0 then print minute;" minutes ";

 

=={{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.

 

 

ct.balance();

println!("After: {}", ct);

 

=={{header|Scala}}==

 

object seconds{

println("Second = " + sec)

}

 

=={{header|Scheme}}==

This version uses delete from SRFI 1 and string-join from SRFI 13:

 

(import (scheme base)

(scheme write)

(display (seconds->duration 86400)) (newline)

(display (seconds->duration 6000000)) (newline)

 

{{out}}

=={{header|Sidef}}==

{{trans|Raku}}

gather {

divs.each { |i|

[7259, 86400, 6000000].each { |s|

say "#{'%7d' % s} sec = #{compound_duration(s)}"

 

{{out}}

6000000 sec = 9 wk, 6 d, 10 hr, 40 min

</pre>

 

=={{header|Tcl}}==

The data-driven procedure below can be customised to use different breakpoints, simply by editing the dictionary.

 

set factors {

sec 60

check {sec2str 7259} {2 hr, 59 sec}

check {sec2str 86400} {1 d}

 

{{Out}}

=={{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.

Proc _CompoundDuration(86400)

Proc _CompoundDuration(6000000)

_d Print " d"; : Return

_hr Print " hr"; : Return

{{out}}

<pre>2 hr, 59 sec

 

0 OK, 0:94</pre>

 

=={{header|VBA}}==

minutes = 60

hours = 60 * minutes

Debug.Print compound_duration(86400)

Debug.Print compound_duration(6000000)

<pre>2 hr, 59 sec

1 d

 

=={{header|VBScript}}==

Function compound_duration(n)

Do Until n = 0

WScript.StdOut.WriteLine compound_duration(86400)

WScript.StdOut.WriteLine compound_duration(6000000)

 

{{Out}}

 

=={{header|Wren}}==

if (s < 1) return "0 sec"

var dur = ""

}

 

 

{{out}}

 

=={{header|zkl}}==

r,b:=List(),0;

foreach u in (T(60,60,24,7)){

}

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>

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

{{trans|AWK}}

20 DATA 10,7259,86400,6000000,0,1,60,3600,604799,604800,694861

30 READ n

200 NEXT i

210 STOP