Introducción

Imagine que la línea de caracteres es, de hecho, dos filas. Fila superior - puntos - representa las horas (sistema de 24 horas), mientras que inferior - comas - representa minutos . Un personaje puede representar hora, minuto o ambos , siempre que sea posible.

Al principio, probablemente tendría que convertir minutos desde la medianoche a horas y minutos .

El resultado es la cadena que muestra la hora actual en "formato de punto". El recuento de puntos ( apóstrofe cuenta aquí como un punto y se llamará así ) es el recuento de horas desde la medianoche y el recuento de comas es el recuento de minutos. Mostraré algunos ejemplos para que quede claro.

• (Observación) hh: mm - result
• (Solo horas) 05:00 - '''''
• (Solo minutos) 00:08 - ,,,,,,,,
• (horas <minutos) 03:07 - ;;;,,,,
• (horas> minutos) 08:02 - ;;''''''
• (horas = minutos) 07:07 - ;;;;;;;
• (el comienzo del día) 00:00 - ( resultado vacío )

Observe que el carácter "ambos" se puede usar como máximo 23 veces, para 23: xx, donde xx es 23 o más.

Los símbolos

Si el carácter tiene que (ver la regla 5) escapar en su idioma, puede cambiarlo a una de las alternativas. Si dichas alternativas no son suficientes, puede usar otros símbolos, pero sea razonable. Simplemente no quiero escapar para ser una barrera.

• ; (punto y coma): marcador para horas y minutos (alt: : )
• ' (apóstrofe) - marcador por horas (alt: '``° )
• ,(coma) - marcador de minutos (alt: .)

Reglas adicionales

1. ¡El código con la menor cantidad de bytes gana!
2. Tienes que usar ambos símbolos siempre que sea posible. Para 02:04 el resultado no puede ser '',,,,, ni ;',,,. Tiene que ser;;,,
3. Entrada: puede ser un parámetro de script / aplicación, entrada del usuario (como readline) o variable dentro del código
   3.1. Si se usa la variable dentro del código, entonces su longitud debe ser la más larga posible. Es 1439(23:59), así que se vería comot=1439
4. La parte común que está simbolizada por el carácter "ambos" (12 en 12:05, 3 en 03:10) debe colocarse al comienzo de la cadena
5. Los símbolos pueden reemplazarse por alternativas solo si tendrían que escaparse en su código.
6. La entrada se da en minutos después de las 00:00 . Puede suponer que este es un número entero no negativo.

Casos de prueba

Input: 300
Output: '''''

Input: 8
Output: ,,,,,,,,

Input: 187
Output: ;;;,,,,

Input: 482
Output: ;;''''''

Input: 427
Output: ;;;;;;;

Input: 0
Output:  (empty)

Pyth, 19 bytes

:.iF*V.DQ60J"',"J\;

Banco de pruebas

:.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 ';'.

CJam, 22 20 19 bytes

Toma información de STDIN:

ri60md]',`.*:.{;K+}

Pruébalo aquí.

Explicación

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

Fue realmente afortunado lo bien que las cosas funcionaron juntas aquí, en particular la asignación de horas 'y minutos a ,tal que el orden de horas y minutos en la pila coincidiera con la representación de cadena del personaje.

Este es el único bloque de 3 bytes que he encontrado hasta ahora. Sin embargo, hubo toneladas de soluciones de 4 caracteres:

{;;';}
{';\?}
{^'0+}
{^'F-}
{-'@+}
{-'6-}
...

GNU Sed, 37

La puntuación incluye +1 para la -Eopción de sed.

No estaba particularmente impresionado con el golf de mi respuesta bash , así que pensé en probar con sed por diversión.

La entrada está en unario, según esta meta-respuesta .

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

Pruébalo en línea

Python 2, 56 bytes

def g(t):d=t%60-t/60;print(t/60*";")[:t%60]+","*d+"'"*-d

Una función que imprime (un carácter más corto que t=input(); ).

El método es similar al de Loovjo . El número de ,es diferente entre minutos y horas, con un mínimo implícito de 0. Porque ', es la negación. Para ;, calcula minimplícitamente tomando tantas ;horas como sea, luego truncando a la cantidad de minutos.

Guarda caracteres para guardar d, pero no la cantidad de horas y minutos aquí. El análogo con lambda fue dos caracteres más largo (58), por lo que las asignaciones variables valen la pena.

lambda t:(t%60*";")[:t/60]+","*(t%60-t/60)+"'"*(t/60-t%60)

Procesar la entrada directamente tampoco guardaba caracteres (58):

h,m=divmod(input(),60);d=m-h;print(";"*m)[:h]+","*d+"'"*-d

Otra estrategia con rebanar, mucho más larga (64):

def g(t):m=t%60;h=t/60;return(";"*m)[:h]+(","*m)[h:]+("'"*h)[m:]

Retina , 24

Puerto trivial de mi respuesta sed .

La entrada está en unario, según esta meta-respuesta .

1
,
,{60}
'
+`(.*)',
;$1

Pruébalo en línea.

Pure Bash (sin utilidades externas), 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]

Gracias a @ F.Hauri por guardar 2 bytes.

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

Detallado

// 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;
}

Haskell, 68 66 bytes

g(h,m)=id=<<zipWith replicate[min h m,h-m,m-h]";',"
g.(`divMod`60)

Ejemplo de uso:

(g.(`divMod`60)) 482

El bit inteligente aquí es que replicatedevolverá la cadena vacía si la longitud dada es negativa o cero, por lo que puedo aplicarla a ambas diferencias y solo se mostrará la positiva. La primera parte es fácil, ya que el número de punto y coma es solo el mínimo de los dos. LuegozipWith aplica la función a los elementos correspondientes.

EDITAR: me di cuenta de que estaba usando el personaje equivocado durante minutos

EDIT 2: guardado 2 bytes gracias a @Laikoni

JavaScript (ES6) 69

m=>";".repeat((h=m/60|0)>(m%=60)?m:h)+",'"[h>m|0].repeat(h>m?h-m:m-h)

Powershell, 99 85 bytes

param($n)";"*(($m=$n%60),($h=$n/60))[($b=$m-gt$h)]+"'"*(($h-$m)*!$b)+","*(($m-$h)*$b)

Usando el método de Loovjo , esta es mi implementación de PowerShell.

sin golf

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)

Guardado 14 bytes gracias a AdmBorkBork

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

Probablemente no sea la mejor respuesta, ¡pero fue muy divertido!

Python 2, 61 bytes

t=input();m,h=t%60,t/60
print";"*min(h,m)+","*(m-h)+"'"*(h-m)

Explicación:

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)

PHP, 81 bytes

Fui por la entrada variable ya que es más corta que leer STDINo tomar argumentos de la línea de comandos.

for($_=1439;$i<max($h=0|$_/60,$m=$_%60);++$i)echo$i<$h?$i<min($h,$m)?';':"'":",";

JavaScript (ES6), 77 71 bytes

x=>';'[r='repeat'](y=Math.min(h=x/60|0,m=x%60))+"'"[r](h-y)+','[r](m-y)

Perl 6, 103 101 98 97 69 bytes

$_=get;say ";"x min($!=($_-$_%60)/60,$_=$_%60)~"'"x $!-$_~","x $_-$!;

Emite varias matrices, pero a la mierda, disfruta. Como de costumbre, todas las oportunidades de golf son apropiadas.

Editar: -2 bytes: se valiente y eliminó algunos lanzamientos.

Edit2: -3 bytes eliminando las matrices.

Edit3: -1 byte para imprimir en el formato correcto, usando "lambdas" y eliminando las paréntesis.

Edit4: (lo siento chicos) abusando de esas horas, los minutos deberían devolver 0 y todo lo contrario. Eliminado si las declaraciones. Luego quité los corchetes y me di cuenta de que no necesitaba la lambda. -28 bytes :)

Woah estoy mejorando en esto.

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--;}}}

Gema, 119 caracteres

<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};,}

Ejecución de muestra:

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'
;;;;,,,,,,,,

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

Prueba:

310
ans =
;;;;;,,,,,

SmileBASIC, 59 bytes

INPUT M
H%=M/60M=M-H%*60?";"*MIN(H%,M);",'"[M<H%]*ABS(H%-M)

Explicado:

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 ,

Se ve bastante terrible, ya que la parte inferior de ;ni siquiera es la misma que ,en la fuente de SmileBASIC

PHP, 81 bytes

algunas soluciones más:

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]);

Corre con 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]);

Reemplazar 1439con entrada, guardar en archivo, ejecutar.

Ruby, 50 caracteres.

->t{(?;*h=t/60)[0,m=t%60]+",',"[0<=>m-=h]*m.abs}

Gracias a:

• GB para
  • recordándome que no puedo tomar más caracteres de una cadena de los que tiene (-1 carácter)
  • reorganizando mi cálculo (-1 carácter)

Esperé tanto tiempo para usar Numeric.divmod , solo para darme cuenta de que es horriblemente largo.

Ejecución de muestra:

2.1.5 :001 > puts ->t{(?;*h=t/60)[0,m=t%60]+",',"[0<=>m-=h]*m.abs}[252]
;;;;,,,,,,,,

05AB1E , 25 bytes

60‰vy„'.Nè×}‚.BøJ„'.';:ðK

Pruébalo en línea!

60‰vy„'.Nè×}definitivamente se puede acortar, simplemente no pude resolverlo, y dudo que pueda reducir 7 bytes para ganar con este enfoque a menos que haya una versión vectorial de ×.

Ejemplo (con una entrada igual a 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 era mi versión original, pero eso es incluso MÁS costoso que divmod.

60‰WDµ';ˆ¼}-¬0Qi'.ë''}ZׯìJ otro método que probé ...

cc , 95 bytes

[60~sdsp39sj]sd[60~spsd44sj]se?ddd60~<d60~!<e[59Plp1-spld1-dsd0<y]syld0<y[ljPlp1-dsp0<y]sylp0<y

Pruébalo en línea!

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;}

Explicación:

Pruébalo aquí

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