[Question]
  [
### Introduction
[![code golf explanation](https://i.stack.imgur.com/5kSwA.png)](https://i.stack.imgur.com/5kSwA.png)
Imagine that line of chars is in fact two rows. **Upper row - dots - represents hours** (24 hour system), while **lower - commas - represents minutes**. One character can represent hour, minute or **both** - whenever it's possible.
At first probably you'd have to convert minutes since midnight to *hours and minutes*.
The result is the string showing current time in "dot format". The dot count (**apostrophe counts here as a dot and will be called so!**) is the hour count since midnight and comma count is minutes count. I'll show a few examples to make it clear.
* (Remark) hh:mm - `result`
* (Only hours) 05:00 - `'''''`
* (Only minutes) 00:08 - `,,,,,,,,`
* (hours < minutes) 03:07 - `;;;,,,,`
* (hours > minutes) 08:02 - `;;''''''`
* (hours = minutes) 07:07 - `;;;;;;;`
* (the start of the day) 00:00 -  (*empty result*)
Notice that *"both" character* can be used max 23 times - for 23:xx, where xx is 23 or more.
### Symbols
If character **have to** (see rule 5.) be escaped in your language, you could changed it to one of alternatives. If said alternatives aren't enough, you may use other symbols - but keep it reasonable. I just don't want escaping to be a barrier.
* `;` (semicolon) - marker for both hours and minutes (alt: `:`)
* `'` (apostrophe) - marker for hours (alt: `'``°`)
* `,` (comma) - marker for minutes (alt: `.`)
### Additional rules
1. The code with the least amount of bytes wins!
2. You have to use *both symbol* whenever it's possible. For 02:04 the result can't be `'',,,,`, nor `;',,,`. It have to be `;;,,`
3. Input - can be script/app parameter, user input (like readline) or variable inside code  
3.1. If the variable inside code is used, then its lenght have to be the longest possible. It's `1439` (23:59), so it would look like `t=1439`
4. The common part which is symbolized by *"both" character* (12 in 12:05, 3 in 03:10) must be placed on the beginning of the string
5. Symbols can be replaced to alternatives only if they would have to be escaped in your code.
6. Input is given in minutes after **00:00**. You can assume that this is a non-negative integer.
### Test cases
```
Input: 300
Output: '''''
Input: 8
Output: ,,,,,,,,
Input: 187
Output: ;;;,,,,
Input: 482
Output: ;;''''''
Input: 427
Output: ;;;;;;;
Input: 0
Output:  (empty)
```
  
[Answer]
# Pyth, 19 bytes
```
:.iF*V.DQ60J"',"J\;
```
[Test suite](https://pyth.herokuapp.com/?code=%3A.iF%2aV.DQ60J%22%27%2C%22J%5C%3B&input=300&test_suite=1&test_suite_input=300%0A8%0A187%0A482%0A427%0A0&debug=0)
```
:.iF*V.DQ60J"',"J\;
      .DQ60            Divmod the input by 60, giving [hours, minutes].
           J"',"       Set J equal to the string "',".
    *V                 Perform vectorized multiplication, giving H "'" and M ','.
 .iF                   Interleave the two lists into a single string.
:               J\;    Perform a substitution, replacing J with ';'.
```
[Answer]
## CJam, ~~22~~ ~~20~~ 19 bytes
Takes input from STDIN:
```
ri60md]',`.*:.{;K+}
```
[Test it here.](http://cjam.aditsu.net/#code=ri60md%5D'%2C%60.*%3A.%7B%3BK%2B%7D&input=252)
### Explanation
```
ri     e# Read input and convert to integer.
60md   e# Divmod 60, pushes hours H and minutes M on the stack.
]      e# Wrap in an array.
',`    e# Push the string representation of the comma character which is "',".
.*     e# Repeat apostrophe H times and comma M times.
:.{    e# Apply this block between every pair of characters. This will only applied to
       e# first N characters where N = min(hours,minutes). The others will remain
       e# untouched. So we want the block to turn that pair into a semicolon...
  ;    e#   Discard the comma.
  K+   e#   Add 20 to the apostrophe to turn it into a semicolon.
}
```
It was really lucky how well things worked together here, in particular the assignment of hours to `'` and minutes to `,` such that the order of hours and minutes on the stack matched up with the string representation of the character.
This is the only 3-byte block I've found so far. There were tons of 4-character solutions though:
```
{;;';}
{';\?}
{^'0+}
{^'F-}
{-'@+}
{-'6-}
...
```
[Answer]
# GNU Sed, 37
Score includes +1 for `-E` option to sed.
I wasn't particularly impressed with the golfiness of my [bash answer](https://codegolf.stackexchange.com/a/67453/11259), so I thought I'd try with sed for the fun.
Input is in unary, as per [this meta-answer](https://codegolf.meta.stackexchange.com/a/5349/11259).
```
y/1/,/          # Convert unary 1's to commas (minutes)
s/,{60}/'/g     # divmod by 60.  "'" are hours
:               # unnamed label
s/(.*)',/;\1/   # replace an apostrophe and comma with a semicolon
t               # jump back to unnamed label until no more replacements
```
[Try it online](https://ideone.com/qzbE3f)
[Answer]
## Python 2, 56 bytes
```
def g(t):d=t%60-t/60;print(t/60*";")[:t%60]+","*d+"'"*-d
```
A function that prints (one char shorter than `t=input();`).
The method is similar to [Loovjo's](https://codegolf.stackexchange.com/a/67462/20260). The number of `,` is the different between minutes and hours, with an implicit minimim of 0. For `'`, it's the negation. For `;`, computes the `min` implicitly by taking as many `;` as hours, then truncating to the number of minutes.
It saves chars to save `d`, but not the number of hours and minutes here. The analogue with lambda was two chars longer (58), so the variable assignments are worth it.
```
lambda t:(t%60*";")[:t/60]+","*(t%60-t/60)+"'"*(t/60-t%60)
```
Processing the input directly didn't save chars either (58):
```
h,m=divmod(input(),60);d=m-h;print(";"*m)[:h]+","*d+"'"*-d
```
Another strategy with slicing, much longer (64):
```
def g(t):m=t%60;h=t/60;return(";"*m)[:h]+(","*m)[h:]+("'"*h)[m:]
```
[Answer]
# [Retina](https://github.com/mbuettner/retina), 24
Trivial port of [my sed answer](https://codegolf.stackexchange.com/a/67455/11259).
Input is in unary, as per [this meta-answer](http://meta.codegolf.stackexchange.com/a/5349/11259).
```
1
,
,{60}
'
+`(.*)',
;$1
```
[Try it online.](http://retina.tryitonline.net/#code=MQosCix7NjB9CicKK2AoLiopJywKOyQx&input=MTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTE)
[Answer]
# Pure Bash (no external utilities), 103
```
p()(printf -vt %$2s;printf "${t// /$1}")
p \; $[h=$1/60,m=$1%60,m>h?c=m-h,h:m]
p , $c
p \' $[m<h?h-m:0]
```
Thanks to @F.Hauri for saving 2 bytes.
[Answer]
# C, 119 bytes
```
#define p(a,b) while(a--)putchar(b);
main(h,m,n){scanf("%d",&m);h=m/60;m%=60;n=h<m?h:m;h-=n;m-=n;p(n,59)p(h,39)p(m,44)}
```
Detailed
```
// macro: print b, a times
#define p(a,b) while(a--)putchar(b)
int main(void)
{
    int h,m,n;
    scanf("%d",&m);  // read input
    h=m/60;m%=60;    // get hours:minutes
    n=h<m?h:m;       // get common count
    h-=n;m-=n;       // get remaining hours:minutes
    p(n,59);        // print common
    p(h,39);        // print remaining hours
    p(m,44);        // print remaining minutes
    return 0;
}
```
[Answer]
# Haskell, ~~68~~ 66 Bytes
```
g(h,m)=id=<<zipWith replicate[min h m,h-m,m-h]";',"
g.(`divMod`60)
```
Usage example:
```
(g.(`divMod`60)) 482
```
The clever bit here is that `replicate` will return the empty string if the length given is negative or zero so I can apply it to both differences and only the positive one will show up. The first part is easy, since the number of semicolons is just the minimum of the two. Then `zipWith` applies the function to the corresponding items.
EDIT: Realized I was using the wrong char for minutes
EDIT 2: Saved 2 bytes thanks to @Laikoni
[Answer]
# JavaScript (ES6) 69
```
m=>";".repeat((h=m/60|0)>(m%=60)?m:h)+",'"[h>m|0].repeat(h>m?h-m:m-h)
```
[Answer]
# Powershell, ~~99~~ 85 bytes
`param($n)";"*(($m=$n%60),($h=$n/60))[($b=$m-gt$h)]+"'"*(($h-$m)*!$b)+","*(($m-$h)*$b)`
Using [Loovjo's](https://codegolf.stackexchange.com/a/67462/20260) method, this is my powershell implementation.
ungolfed
```
param($n) 
# set the number of minutes and hours, and a boolean which one is bigger
# and also output the correct number of ;s
";"*(($m=$n%60),($h=$n/60))[($b=$m-gt$h)]+ 
# add the difference between h and m as 's but only if h > m
"'"*(($h-$m)*!$b)+
# add the difference between m and h as ,s but only if m > h
","*(($m-$h)*$b)
```
Saved 14 bytes thanks to AdmBorkBork
[Answer]
# Python 3, 98 bytes
```
d=int(input());m=d%60;h=int((d-m)/60)
if m>=h:print(";"*h+","*(m-h))
else:print(";"*(m)+"'"*(h-m))
```
Probably not the best answer, but it was a lot of fun!
[Answer]
# Python 2, 61 bytes
```
t=input();m,h=t%60,t/60
print";"*min(h,m)+","*(m-h)+"'"*(h-m)
```
Explaination:
```
t=input();              # Read input
          m,  t%60,     # Do a divmod, h = div, m = mod
            h=     t/60
print";"*min(h,m)+                    # Print the minimum of the h and m, but in ";"s
                  ","*(m-h)+          # Print (m-h) ","s (if m-h is negative, print nothing)
                            "'"*(h-m) # Print (h-m) "'"s (if h-m is negative, print nothing)
```
[Answer]
# PHP, 81 bytes
I went for the variable input as it is shorter than reading from `STDIN` or taking command line arguments.
```
for($_=1439;$i<max($h=0|$_/60,$m=$_%60);++$i)echo$i<$h?$i<min($h,$m)?';':"'":",";
```
[Answer]
# JavaScript (ES6), ~~77~~ 71 bytes
```
x=>';'[r='repeat'](y=Math.min(h=x/60|0,m=x%60))+"'"[r](h-y)+','[r](m-y)
```
[Answer]
# Perl 6, ~~103~~ ~~101~~ ~~98~~ ~~97~~ 69 bytes
```
$_=get;say ";"x min($!=($_-$_%60)/60,$_=$_%60)~"'"x $!-$_~","x $_-$!;
```
~~Outputs several arrays, but fuck it,~~ enjoy.
As usual, any golfing oppertunities are appericated.
Edit: -2 bytes: got brave and removed some casts.
Edit2: -3 bytes by removing the arrays.
Edit3: -1 byte to print in right format, using "lambdas" and removing parantheses.
Edit4: (sorry guys) abusing that hours - minutes should return 0 and the opposite. Removed if statements. Then removing brackets, then realising i didnt need the lambda at all. -28 bytes :)
Woah im getting better at this.
[Answer]
# C, 141 bytes
```
main(h,m){scanf("%d",&m);h=(m/60)%24;m%=60;while(h||m){if(h&&m){printf(";");h--;m--;}else if(h&&!m){printf("'");h--;}else{printf(",");m--;}}}
```
[Answer]
# Gema, 119 characters
```
<D>=@set{h;@div{$0;60}}@set{m;@mod{$0;60}}@repeat{@cmpn{$h;$m;$h;$h;$m};\;}@repeat{@sub{$h;$m};'}@repeat{@sub{$m;$h};,}
```
Sample run:
```
bash-4.3$ gema '<D>=@set{h;@div{$0;60}}@set{m;@mod{$0;60}}@repeat{@cmpn{$h;$m;$h;$h;$m};\;}@repeat{@sub{$h;$m};`}@repeat{@sub{$m;$h};,}' <<< '252'
;;;;,,,,,,,,
```
[Answer]
## Matlab: 89 bytes
```
i=input('');m=mod(i,60);h=(i-m)/60;[repmat(';',1,min(h,m)),repmat(39+5*(m>h),1,abs(h-m))]
```
Test:
```
310
ans =
;;;;;,,,,,
```
[Answer]
# SmileBASIC, 59 bytes
```
INPUT M
H%=M/60M=M-H%*60?";"*MIN(H%,M);",'"[M<H%]*ABS(H%-M)
```
Explained:
```
INPUT MINUTES 'input
HOURS=MINUTES DIV 60 'separate the hours and minutes
MINUTES=MINUTES MOD 60
PRINT ";"*MIN(HOURS,MINUTES); 'print ;s for all positions with both
PRINT ",'"[MINUTES<HOURS]*ABS(HOURS-MINUTES) 'print extra ' or ,
```
It looks pretty terrible, since the bottom part of `;` is not even the same as `,` in [SmileBASIC's font](http://12Me21.github.io/syntax/linkc#;,%27)
[Answer]
# PHP, 81 bytes
some more solutions:
```
echo($r=str_repeat)(";",min($h=$argn/60,$m=$argn%60)),$r(",`"[$h>$m],abs($h-$m));
// or
echo($p=str_pad)($p("",min($h=$argn/60,$m=$argn%60),";"),max($h,$m),",`"[$h>$m]);
```
Run with `echo <time> | php -R '<code>'`.
```
<?=($r=str_repeat)(";",min($h=($_=1439)/60,$m=$_%60)),$r(",`"[$h>$m],abs($h-$m));
// or
<?=($r=str_repeat)(";",min($h=.1/6*$_=1439,$m=$_%60)),$r(",`"[$h>$m],abs($h-$m));
// or
<?=str_pad(str_pad("",min($h=($_=1439)/60,$m=$_%60),";"),max($h,$m),",`"[$h>$m]);
```
Replace `1439` with input, save to file, run.
[Answer]
# Ruby, 50 characters
```
->t{(?;*h=t/60)[0,m=t%60]+",',"[0<=>m-=h]*m.abs}
```
Thanks to:
* [G B](https://codegolf.stackexchange.com/users/18535/g-b) for
	+ reminding me that I can't take more characters from a string than it has (-1 character)
	+ reorganizing my calculation (-1 character)
Waited so long to use `Numeric.divmod`, just to realize that its horribly long.
Sample run:
```
2.1.5 :001 > puts ->t{(?;*h=t/60)[0,m=t%60]+",',"[0<=>m-=h]*m.abs}[252]
;;;;,,,,,,,,
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 25 bytes
```
60‰vy„'.Nè×}‚.BøJ„'.';:ðK
```
[Try it online!](https://tio.run/nexus/05ab1e#@29m8KhhQ1nlo4Z56np@h1ccnl77qGGWntPhHV5gIXVrq8MbvP//NzQxMAQA "05AB1E – TIO Nexus")
`60‰vy„'.Nè×}` can definitely be shortened, I just couldn't figure it out, and doubt I'll be able to shave off 7 bytes to win with this approach unless there's a vectored version of `×`.
---
Example (With input equal to 63):
```
60‰                       # Divmod by 60.
                          # STACK: [[1,3]]
   vy      }              # For each element (probably don't need the loop)...
                          # STACK: []
     „'.Nè×               # Push n apostrophe's for hours, periods for minutes.
                          # STACK: ["'","..."]
            ‚             # Group a and b.
                          # STACK: [["'","..."]]
             .B           # Boxify.
                          # STACK: [["'  ","..."]]
               ø          # Zip it (Transpose).
                          # STACK: [["'."," ."," ."]
                J         # Join stack.
                          # STACK: ["'. . ."]
                 „'.';:   # Replace runs of "'." with ";".
                          # STACK: ["; . ."]
                       ðK # Remove all spaces.
                          # OUTPUT: ;..
```
---
`D60÷''×s60%'.×‚.BøJ„'.';:ðK` was my original version, but that's even MORE costly than divmod.
`60‰WDµ';ˆ¼}-¬0Qi'.ë''}Z×¯ìJ` yet another method I tried...
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), 95 bytes
```
[60~sdsp39sj]sd[60~spsd44sj]se?ddd60~<d60~!<e[59Plp1-spld1-dsd0<y]syld0<y[ljPlp1-dsp0<y]sylp0<y
```
[Try it online!](https://tio.run/nexus/dc#@x9tZlBXnFJcYGxZnBVbnALmFhSnmJiAuKn2KSkpQBEbEKFokxptahmQU2CoW1yQk2Kom1KcYmBTGVtcmQOio3OywHJAs6CiIPr/fxMLo695@brJickZqQA "dc – TIO Nexus")
[Answer]
# Java 8, ~~101~~ ~~99~~ 86 bytes
```
n->{String r="";for(int m=n%60,h=n/60;h>0|m>0;r+=h--*m-->0?";":h<0?",":"'");return r;}
```
**Explanation:**
[Try it here.](https://tio.run/##hZBNTsMwEIX3PcXIUkVM6@D@qIQahxPQDcuKhXFd4hJPIsephErOHtySLcrGI897M9/TnNRZsao2eDp89bpUTQOvyuJlAmAxGH9U2sDu@gV4C97iJ@gkKoBUxGY3iU8TVLAadoAgoUeWXwanl4SIY@VvA07idMPnhcSHDRdFzn9czoWfyYKxe8dYzl@IINviOdY52ZI7QoU3ofUIXnS9uJLq9qOMpAF4ruwBXEyb/PH274oOSb@bYFxatSGtoxJKTDDVyYpzeov9ryMb0RfZ44hjnS3HHMuxHWMpF@vVEx3u3/W/)
```
n->{                      // Method with integer parameter and String return-type
  String r="";            //  Result-String (starting empty)
  for(int m=n%60,h=n/60;  //   Get the minutes and hours from the input integer
      h>0|m>0;            //   Loop as long as either the hours or minutes is above 0
    r+=                   //   Append the result-String with:
       h--*m-->0?         //    If both hours and minutes are above 0
                          //    (and decrease both after this check):
        ";"               //     Use ";"
       :h<0?              //    Else-if only minutes is above 0 (hours is below 0)
        ","               //     Use ","
       :                  //    Else:
        "'"               //     Use "'"
  );                      //  End loop
  return r;               //  Return the result
}                         // End of method
```
[Answer]
# [///](https://esolangs.org/wiki////), 49 bytes
```
/x/1111111111//xxxxxx/o//oo1/o1o//o1/;//o/'//1/,/
```
[Try it online!](https://tio.run/##K85JLM5ILf7/X79C3xAO9PUrwEA/X18/P99QP98QxDDUtwaS@ur6@ob6Ovr//wMA "/// – Try It Online")
The first two substitutions, `/x/1111111111//xxxxxx/o/`, replace sequences of 60 `1`s with an `o`.
`/oo1/o1o/` interweaves the `1`s into the `o`s, which are next to each other.
Ex. `oooooo1111111111 -> o1o1o1o1o1o11111`
This pairs each o, which is one hour, with one 1, which is minute. This also pushes the `1`s to the left, so whichever one is greater is left at the right.
`o1/;/` replaces each pair with a ;
`/o/'/ /1/1/` and this converts the leftovers to `:`s or `'`s
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 13 bytes
```
d60Ø½ẋ"Sị“',;
```
[Try it online!](https://tio.run/##AT4Awf9qZWxsef//ZDYww5jCveG6iyJT4buL4oCcJyw7/@KAnQrDh@KCrFn//1szMDAsOCwxODcsNDgyLDQyNywwXQ "Jelly – Try It Online")
## Explanation
```
d60Ø½ẋ"Sị“',;   Main monadic link
d60             Divmod by 60
      "         Zipmap
   Ø½             [1, 2]
                  with that
     ẋ            using the “repeat n times” operator
       S        Sum
        ị       Index into
         “',;   "',;"
```
]