Convert seconds to hours, minutes, seconds
BashBash Problem Overview
How can I convert seconds to hours, minutes and seconds?
show_time() {
?????
}
show_time 36 # 00:00:36
show_time 1036 # 00:17:26
show_time 91925 # 25:32:05
Bash Solutions
Solution 1 - Bash
Use date, converted to UTC:
$ date -d@36 -u +%H:%M:%S
00:00:36
$ date -d@1036 -u +%H:%M:%S
00:17:16
$ date -d@12345 -u +%H:%M:%S
03:25:45
The limitation is the hours will loop at 23, but that doesn't matter for most use cases where you want a one-liner.
On macOS, run brew install coreutils and replace date with gdate
Solution 2 - Bash
#!/bin/sh
convertsecs() {
((h=${1}/3600))
((m=(${1}%3600)/60))
((s=${1}%60))
printf "%02d:%02d:%02d\n" $h $m $s
}
TIME1="36"
TIME2="1036"
TIME3="91925"
echo $(convertsecs $TIME1)
echo $(convertsecs $TIME2)
echo $(convertsecs $TIME3)
For float seconds:
convertsecs() {
h=$(bc <<< "${1}/3600")
m=$(bc <<< "(${1}%3600)/60")
s=$(bc <<< "${1}%60")
printf "%02d:%02d:%05.2f\n" $h $m $s
}
Solution 3 - Bash
The simplest way I know of:
secs=100000
printf '%dh:%dm:%ds\n' $((secs/3600)) $((secs%3600/60)) $((secs%60))
Note - if you want days then just add other unit and divide by 86400.
Solution 4 - Bash
Simple one-liner
$ secs=236521
$ printf '%dh:%dm:%ds\n' $((secs/3600)) $((secs%3600/60)) $((secs%60))
65h:42m:1s
With leading zeroes
$ secs=236521
$ printf '%02dh:%02dm:%02ds\n' $((secs/3600)) $((secs%3600/60)) $((secs%60))
65h:42m:01s
With days
$ secs=236521
$ printf '%dd:%dh:%dm:%ds\n' $((secs/86400)) $((secs%86400/3600)) $((secs%3600/60)) \
$((secs%60))
2d:17h:42m:1s
With nanoseconds
$ secs=21218.6474912
$ printf '%02dh:%02dm:%02fs\n' $(echo -e "$secs/3600\n$secs%3600/60\n$secs%60"| bc)
05h:53m:38.647491s
Based on https://stackoverflow.com/a/28451379/188159 but edit got rejected.
Solution 5 - Bash
I use the following function myself:
function show_time () {
num=$1
min=0
hour=0
day=0
if((num>59));then
((sec=num%60))
((num=num/60))
if((num>59));then
((min=num%60))
((num=num/60))
if((num>23));then
((hour=num%24))
((day=num/24))
else
((hour=num))
fi
else
((min=num))
fi
else
((sec=num))
fi
echo "$day"d "$hour"h "$min"m "$sec"s
}
Note it counts days as well. Also, it shows a different result for your last number.
Solution 6 - Bash
For us lazy people: ready-made script available at https://github.com/k0smik0/FaCRI/blob/master/fbcmd/bin/displaytime :
#!/bin/bash
function displaytime {
local T=$1
local D=$((T/60/60/24))
local H=$((T/60/60%24))
local M=$((T/60%60))
local S=$((T%60))
[[ $D > 0 ]] && printf '%d days ' $D
[[ $H > 0 ]] && printf '%d hours ' $H
[[ $M > 0 ]] && printf '%d minutes ' $M
[[ $D > 0 || $H > 0 || $M > 0 ]] && printf 'and '
printf '%d seconds\n' $S
}
displaytime $1
Basically just another spin on the other solutions, but has the added bonus of suppressing empty time units (f.e. 10 seconds instead of 0 hours 0 minutes 10 seconds). Couldn't quite track down the original source of the function, occurs in multiple git repos..
Solution 7 - Bash
Using dc:
$ echo '12345.678' | dc -e '?1~r60~r60~r[[0]P]szn[:]ndZ2>zn[:]ndZ2>zn[[.]n]sad0=ap'
3:25:45.678
The expression ?1~r60~r60~rn[:]nn[:]nn[[.]n]sad0=ap does the following:
? read a line from stdin
1 push one
~ pop two values, divide, push the quotient followed by the remainder
r reverse the top two values on the stack
60 push sixty
~ pop two values, divide, push the quotient followed by the remainder
r reverse the top two values on the stack
60 push sixty
~ pop two values, divide, push the quotient followed by the remainder
r reverse the top two values on the stack
[ interpret everything until the closing ] as a string
[0] push the literal string '0' to the stack
n pop the top value from the stack and print it with no newline
] end of string, push the whole thing to the stack
sz pop the top value (the string above) and store it in register z
n pop the top value from the stack and print it with no newline
[:] push the literal string ':' to the stack
n pop the top value from the stack and print it with no newline
d duplicate the top value on the stack
Z pop the top value from the stack and push the number of digits it has
2 push two
>z pop the top two values and executes register z if the original top-of-stack is greater
n pop the top value from the stack and print it with no newline
[:] push the literal string ':' to the stack
n pop the top value from the stack and print it with no newline
d duplicate the top value on the stack
Z pop the top value from the stack and push the number of digits it has
2 push two
>z pop the top two values and executes register z if the original top-of-stack is greater
n pop the top value from the stack and print it with no newline
[ interpret everything until the closing ] as a string
[.] push the literal string '.' to the stack
n pop the top value from the stack and print it with no newline
] end of string, push the whole thing to the stack
sa pop the top value (the string above) and store it in register a
d duplicate the top value on the stack
0 push zero
=a pop two values and execute register a if they are equal
p pop the top value and print it with a newline
An example execution with the stack state after each operation:
: <empty stack>
? : 12345.678
1 : 1, 12345.678
~ : .678, 12345
r : 12345, .678 # stack is now seconds, fractional seconds
60 : 60, 12345, .678
~ : 45, 205, .678
r : 205, 45, .678 # stack is now minutes, seconds, fractional seconds
60 : 60, 205, 45, .678
~ : 25, 3, 45, .678
r : 3, 25, 45, .678 # stack is now hours, minutes, seconds, fractional seconds
[[0]n] : [0]n, 3, 25, 45, .678
sz : 3, 25, 45, .678 # '[0]n' stored in register z
n : 25, 45, .678 # accumulated stdout: '3'
[:] : :, 25, 45, .678
n : 25, 45, .678 # accumulated stdout: '3:'
d : 25, 25, 45, .678
Z : 2, 25, 45, .678
2 : 2, 2, 25, 45, .678
>z : 25, 45, .678 # not greater, so register z is not executed
n : 45, .678 # accumulated stdout: '3:25'
[:] : :, 45, .678
n : 45, .678 # accumulated stdout: '3:25:'
d : 45, 45, .678
Z : 2, 45, 45, .678
2 : 2, 2, 45, .678
>z : 45, .678 # not greater, so register z is not executed
n : .678 # accumulated stdout: '3:25:45'
[[.]n] : [.]n, .678
sa : .678 # '[.]n' stored to register a
d : .678, .678
0 : 0, .678, .678
=a : .678 # not equal, so register a not executed
p : <empty stack> # accumulated stdout: '3:25:45.678\n'
In the case of 0 fractional seconds:
: 3, 25, 45, 0 # starting just before we begin to print
n : 25, 45, .678 # accumulated stdout: '3'
[:] : :, 25, 45, .678
n : 25, 45, .678 # accumulated stdout: '3:'
d : 25, 25, 45, .678
Z : 2, 25, 45, .678
2 : 2, 2, 25, 45, .678
>z : 25, 45, .678 # not greater, so register z is not executed
n : 45, .678 # accumulated stdout: '3:25'
[:] : :, 45, .678
n : 45, .678 # accumulated stdout: '3:25:'
d : 45, 45, .678
Z : 2, 45, 45, .678
2 : 2, 2, 45, .678
>z : 45, .678 # not greater, so register z is not executed
n : .678 # accumulated stdout: '3:25:45'
[[.]n] : [.]n, 0
sa : 0 # '[.]n' stored to register a
d : 0, 0
0 : 0, 0, 0
=a : 0 # equal, so register a executed
[.] : ., 0
n : 0 # accumulated stdout: '3:35:45.'
p : <empty stack> # accumulated stdout: '3:25:45.0\n'
In case of a minutes value less than 10:
: 3, 9, 45, 0 # starting just before we begin to print
n : 9, 45, .678 # accumulated stdout: '3'
[:] : :, 9, 45, .678
n : 9, 45, .678 # accumulated stdout: '3:'
d : 9, 9, 45, .678
Z : 1, 9, 45, .678
2 : 2, 1, 9, 45, .678
>z : 9, 45, .678 # greater, so register z is executed
[0] : 0, 9, 45, .678
n : 9, 45, .678 # accumulated stdout: '3:0'
n : 9, .678 # accumulated stdout: '3:09'
# ...and continues as above
EDIT: this had a bug where strings like 7:7:34.123 could be printed. I have modified it to print a leading zero if necessary.
EDIT 2: I realized that the handling of fractional seconds is redundant, and this simplified dc expression performs almost the same job:
$ echo '12345.678' | dc -e '?60~r60~r[[0]P]szn[:]ndZ2>zn[:]ndZ2>zp'
3:25:45.678
$ echo '12345.0' | dc -e '?60~r60~r[[0]P]szn[:]ndZ2>zn[:]ndZ2>zp'
3:25:45.0
$ echo '12345' | dc -e '?60~r60~r[[0]P]szn[:]ndZ2>zn[:]ndZ2>zp'
3:25:45
The downside of this is that different but equal inputs produce different outputs; any number of zeroes after the decimal point will be echoed verbatim in the output because of the fixed-point nature of dc.
Solution 8 - Bash
All above is for bash, disregarding there "#!/bin/sh" without any bashism will be:
convertsecs() {
h=`expr $1 / 3600`
m=`expr $1 % 3600 / 60`
s=`expr $1 % 60`
printf "%02d:%02d:%02d\n" $h $m $s
}
Solution 9 - Bash
t=12345;printf %02d:%02d:%02d\\n $((t/3600)) $((t%3600/60)) $((t%60)) # POSIX
echo 12345|awk '{printf "%02d:%02d:%02d",$0/3600,$0%3600/60,$0%60}' # POSIX awk
date -d @12345 +%T # GNU date
date -r 12345 +%T # OS X's date
If others were searching for how to do the reverse:
IFS=: read h m s<<<03:25:45;echo $((h*3600+m*60+s)) # POSIX
echo 03:25:45|awk -F: '{print 3600*$1+60*$2+$3}' # POSIX awk
Solution 10 - Bash
A MacOS-specific answer which is using the OOTB /bin/date and does not require the GNU version of date:
# convert 195 seconds to MM:SS format, i.e. 03:15
/bin/date -ju -f "%s" 195 "+%M:%S"
## OUTPUT: 03:15
If you also want to have hours:
/bin/date -ju -f "%s" 3600 "+%H:%M:%S"
# OUTPUT: 01:00:00
> NOTE: If you want to deal with hours then -u is required as it's forcing UTC time and without it you'll get wrong output unless you live in the UTC time zone:
-u Display or set the date in UTC (Coordinated Universal) time.
For an explanation why -u is needed see this.
Solution 11 - Bash
In one line :
show_time () {
if [ $1 -lt 86400 ]; then
date -d@${1} -u '+%Hh:%Mmn:%Ss';
else
echo "$(($1/86400)) days $(date -d@$(($1%86400)) -u '+%Hh:%Mmn:%Ss')" ;
fi
}
Add days if exist.
Solution 12 - Bash
I couldn't get Vaulter's/chepner's code to work correctly. I think that the correct code is:
convertsecs() {
h=$(($1/3600))
m=$((($1/60)%60))
s=$(($1%60))
printf "02d:%02d:%02d\n $h $m $s
}
Solution 13 - Bash
This is old post ovbioius -- but, for those who might are looking for the actual time elapsed but in military format (00:05:15:22 - instead of 0:5:15:22 )
!#/bin/bash
num=$1
min=0
hour=0
day=0
if((num>59));then
((sec=num%60))
((num=num/60))
if((num>59));then
((min=num%60))
((num=num/60))
if((num>23));then
((hour=num%24))
((day=num/24))
else
((hour=num))
fi
else
((min=num))
fi
else
((sec=num))
fi
day=`seq -w 00 $day | tail -n 1`
hour=`seq -w 00 $hour | tail -n 1`
min=`seq -w 00 $min | tail -n 1`
sec=`seq -w 00 $sec | tail -n 1`
printf "$day:$hour:$min:$sec"
exit 0
Solution 14 - Bash
on MacOSX 10.13 Slight edit from @eMPee584 's code to get it all in one GO (put the function in some .bashrc like file and source it, use it as myuptime. For non-Mac OS, replace the T formula by one that gives the seconds since last boot.
myuptime ()
{
local T=$(($(date +%s)-$(sysctl -n kern.boottime | awk '{print $4}' | sed 's/,//g')));
local D=$((T/60/60/24));
local H=$((T/60/60%24));
local M=$((T/60%60));
local S=$((T%60));
printf '%s' "UpTime: ";
[[ $D > 0 ]] && printf '%d days ' $D;
[[ $H > 0 ]] && printf '%d hours ' $H;
[[ $M > 0 ]] && printf '%d minutes ' $M;
[[ $D > 0 || $H > 0 || $M > 0 ]] && printf '%d seconds\n' $S
}
Solution 15 - Bash
Yet another version. Only handles full integers, doesn't pad with 0:
format_seconds() {
local sec tot r
sec="$1"
r="$((sec%60))s"
tot=$((sec%60))
if [[ "$sec" -gt "$tot" ]]; then
r="$((sec%3600/60))m:$r"
let tot+=$((sec%3600))
fi
if [[ "$sec" -gt "$tot" ]]; then
r="$((sec%86400/3600))h:$r"
let tot+=$((sec%86400))
fi
if [[ "$sec" -gt "$tot" ]]; then
r="$((sec/86400))d:$r"
fi
echo "$r"
}
$ format_seconds 59
59s
$ format_seconds 60
1m:0s
$ format_seconds 61
1m:1s
$ format_seconds 3600
1h:0m:0s
$ format_seconds 236521
2d:17h:42m:1s
Solution 16 - Bash
Straight forward through awk:
echo $(seconds) | awk '{printf "%d:%02d:%02d", $1/3600, ($1/60)%60, $1%60}'
Solution 17 - Bash
My pure [tag:bash] SecToString function:
sec2str() {
if [[ $1 == -v ]] ;then
local -n _result=$2
shift 2
else
local _result
fi
local -a _elapsed
TZ=UTC printf -v _elapsed "%(%Y %j %H %M %S)T" $1
read -a _elapsed <<<"$_elapsed"
_elapsed=$((10#$_elapsed-1970)) _elapsed[1]=$((10#${_elapsed[1]}-1))
printf -v _elapsed " %dy %dd %.0fh %.0f' %.0f\"" ${_elapsed[@]}
_result=${_elapsed// 0?}
[[ ${_result@A} == _result=* ]] && echo "$_result"
}
In use:
sec2str 864001
10d 1"
sec2str -v str 864001
echo "$str"
10d 1"
for i in 36 1036 91925 7227;do
sec2str -v str $i
printf "%11d -> %s\n" $i "$str"
done
36 -> 36"
1036 -> 17' 16"
91925 -> 1d 1h 32' 5"
7227 -> 2h 27"
Same but for µsec obtained by ${EPOCHREALTIME/.}
I often use
stepmark1=${EPOCHREALTIME/.}
process strong job
stepmark2=${EPOCHREALTIME/.}
So Elapsed time in *µsec* in integer: $(( stepmark2 - stepmark1 )).
musec2str () {
if [[ $1 == -v ]] ;then
local -n _result=$2
shift 2
else
local _result
fi
local _elapsed=000000$1
printf -v _elapsed "%0.6f" ${_elapsed::-6}.${_elapsed:${#_elapsed}-6}
TZ=UTC printf -v _result "%(%Y %j %H %M %S)T" ${_elapsed%.*}
_elapsed=.${_elapsed#*.}
_elapsed=${_elapsed%%*(0)}
_elapsed=${_elapsed%.}
[ "$_elapsed" ] || unset _elapsed
_result=($_result)
_result=$((10#$_result-1970)) _result[1]=$((10#${_result[1]}-1))
printf -v _result "%dy %dd %.0fh %.0f' %.0fs" ${_result[@]}
_result=($_result)
printf -v _result "%s" ${_result[@]#0?}
[ "${_result#*s}" ] && {
[ "$_elapsed" ] && _result+=0
} || {
[ "$_elapsed" ] || _result=${_result%s}\"
}
_result=(${_result%s}${_elapsed}${_elapsed+\"})
[[ ${_result@A} == _result=* ]] && echo "$_result"
}
Then
musec2str -v str $(( stepmark2 -stepmark1 ))
echo $str
for i in 12345 123456 36123456 1036123456 91925123456 7227123456 ;do
musec2str2 -v str $i
printf "%13d -> %s\n" $i $str
done
12345 -> .012345"
123456 -> .123456"
36123456 -> 36.123456"
1036123456 -> 17'16.123456"
91925123456 -> 1d1h32'5.123456"
7227123456 -> 2h27.123456"