Enumere todas las horas del día a una tasa de media hora

31

La respuesta más corta gana.

Debe ser ordenado, y en 24 horas. La línea final no tiene una coma.

La salida debe ser la siguiente:

'00:00',
'00:30',
'01:00',
'01:30',
'02:00',
'02:30',
'03:00',
'03:30',
'04:00',
'04:30',
'05:00',
'05:30',
'06:00',
'06:30',
'07:00',
'07:30',
'08:00',
'08:30',
'09:00',
'09:30',
'10:00',
'10:30',
'11:00',
'11:30',
'12:00',
'12:30',
'13:00',
'13:30',
'14:00',
'14:30',
'15:00',
'15:30',
'16:00',
'16:30',
'17:00',
'17:30',
'18:00',
'18:30',
'19:00',
'19:30',
'20:00',
'20:30',
'21:00',
'21:30',
'22:00',
'22:30',
'23:00',
'23:30'
code-golf  kolmogorov-complexity  sequence 
— Espen Schulstad
fuente
66
¿Es este tiempo de 24 horas? ¿Podría por favor proporcionar la salida completa?
— xnor
1
¿Se debe ordenar la salida?
— orlp
44
¿Qué sucede si mi programa tarda 23.5 horas en ejecutarse?
— tfitzger
99
No puedo ver por qué eso sería negativo.
— Espen Schulstad,
66
Solo una pequeña sugerencia sobre votos a favor. Trato de votar cada respuesta válida a un desafío que creo como una pequeña recompensa por tomar el esfuerzo. Tengo un montón de representantes y realmente no necesito un voto positivo aquí, pero considere otras respuestas que pueden dejar de responder si sus respuestas son ignoradas después de mucho pensar y depurar.
— Logic Knight

Respuestas:

17

Pyth, 26 bytes

Pjbm%"'%02d:%s0',"d*U24"03

Demostración.

Comenzamos con el producto cartesiano de range(24)( U24) con la cadena "03".

Luego, asignamos estos valores a la sustitución de formateo de cadena apropiada ( m%"'%02d:%s0',"d).

Luego, las cadenas resultantes se unen en el carácter de nueva línea ( jb).

Finalmente, eliminamos la coma final ( P) e imprimimos.

— isaacg
fuente
1
Parece que tenemos un nuevo contendiente para el premio. Autor de pyth, eso es casi trampa;)
— Espen Schulstad
15

Befunge-93, 63 bytes

0>"'",:2/:55+/.55+%.":",:2%3*v
 ^,+55,","<_@#-*86:+1,"'".0. <

 

animación (animación realizada con BefunExec )

— Mikescher
fuente
14

Bash: 58 47 46 caracteres

h=`echo \'{00..23}:{0,3}0\'`
echo "${h// /,
}"
— hombre trabajando
fuente
Me gusta esta solución :)
— Espen Schulstad
1
Usuario anónimo sugerido echo \'{00..23}:{0,3}0\'|sed 's/ /,\n/g'de 40 caracteres. Agradable. Gracias. Pero prefiero hacer uso de bashla propia fuerza.
— manatwork
1
printf "'%s',\n" {00..23}:{0,3}0
— izabera
@manatwork oh no he leído la pregunta así, lo siento ...
— izabera
printf "'%s'\n" {00..23}:{0,3}0|sed $\!s/$/,/ es de 45 bytes
— izabera
10

CJam, 31 30 29 bytes

24,[U3]m*"'%02d:%d0',
"fe%~7<

Esto es bastante sencillo con el formato printf:

24,                              e# get the array 0..23
   [U3]                          e# put array [0 3] on stack
       m*                        e# do a cartesian product between 0..23 and [0 3] array
                                 e# now we have tuples like [[0 0], [0 3] ... ] etc
         "'%02d:%d0',
"fe%                             e# this is standard printf formatting. What we do here is
                                 e# is that we format each tuple on this string
    ~7<                          e# unwrap and remove comma and new line from last line
                                 e# by taking only first 7 characters

Pruébalo en línea aquí

— Optimizador
fuente
Parece que esto va a tomar el oro. Lo daremos hasta mañana;)
— Espen Schulstad
@EspenSchulstad Ojalá me diera algo de oro. suspiro
— Optimizer
3
Recuerde, no es solo oro espiritual, sino también honor. Lo que hacemos en esta vida se refleja en la eternidad.
— Espen Schulstad,
10

Python 2, 58 56 bytes

for i in range(48):print"'%02d:%s0',"[:57-i]%(i/2,i%2*3)

Como la respuesta de sentiao pero usando un forbucle, con cortes para eliminar la coma Gracias a @grc por eliminar dos bytes.

— Sp3000
fuente
Que este trabajo:"'%02d:%s0',"[:57-i]
— GRC
@grc Ahaha, por supuesto, eso es mucho mejor
— Sp3000
¡Mejor de lo que podría hacer!
— Tim
6

Java - 119 bytes

Comencé con StringJoiner de Java 8, pero eso significa incluir una declaración de importación, así que decidí hacerlo a la antigua usanza:

void f(){String s="";for(int i=0;i<24;)s+=s.format(",\n'%02d:00',\n'%02d:30'",i,i++);System.out.print(s.substring(2));}

Quizás esto pueda mejorarse al deshacerse de las múltiples palabras clave Stringy de ocurrencia System.

— Lijadora
fuente
una versión en groovy quizás :)
— Espen Schulstad
Puede acortar esto a 159: elimine el espacio anterior a, mueva el iincremento, pierda las forllaves y mueva la coma / nueva línea al principio (lo que le permite usar el más corto substringy deshacerse de él length()). Dado que las funciones están permitidas de manera predeterminada, puede hacerlo aún más corto eliminando la repetitiva: void f(){String s="";for(int i=0;i<24;)s+=String.format(",\n'%02d:00',\n'%02d:30'",i,i++);System.out.print(s.substring(2));}incluso un poco más si hace que devuelva la cadena en lugar de imprimirla, pero eso parece ir en contra del espíritu, si no la letra.
— Geobits
Maldición, eso es genial! Tengo que tener en cuenta esos trucos, ¡gracias!
— Sander
Oh, otros pocos: cambiar String.formata s.format. Su compilador / IDE puede quejarse de ello, pero funciona;)
— Geobits
1
¡Buena esa! el formato es un método estático, por lo que su clase debería acceder a él, pero de hecho, ¡usarlo de esta manera también funciona!
— Sander
5

Rubí, 94 61 56 51

$><<(0..47).map{|i|"'%02d:%02d'"%[i/2,i%2*30]}*",
"

¡Gracias a @blutorange (nuevamente) por su ayuda en el golf!

— rorlork
fuente
Puede reducir eso a 61 bytes: puts (0..47).to_a.map{|h|"'%02d:%02d'"%[h/2,h%2*30]}.join","(hay una nueva línea después de la última coma)
— blutorange
¡Gracias de nuevo! Realmente no lo intenté mucho ...
— rorlork
Ruby necesita un poco de amor. 58 bytes;)puts Array.new(48){|i|"'%02d:%02d'"%[i/2,i%2*30]}.join','
— blutorange
@blutorange @rcrmn puede reducir 4 bytes más (y obtener mi solución a continuación :))) reemplazando .joincon *:)
— Tomáš Dundáček
5

Perl, 52 50 48 45B

$,=",
";say map<\\'$_:{0,3}0\\'>,"00".."23"

Con la ayuda de ThisSuitIsBlackNot :)

— alexander-brett
fuente
4

JAVA 95 94 bytes

Me encanta el hecho de que printf existe en Java:

void p(){for(int i=0;i<24;)System.out.printf("'%02d:00',\n'%02d:30'%c\n", i,i++,(i<24)?44:0);}

Sin golf

void p(){
    for(int i=0;i<24;)
        System.out.printf("'%02d:00',\n'%02d:30'%c\n", i,i++,(i<24)?44:0);
}

EDITAR Reemplazó el ','con44

— tfitzger
fuente
24. veces {printf ("'% 02d: 00', \ n '% 02d: 30'% c \ n", it, it, (it <24)? 44: 0)} in groovy :) misma solución , solo que ha bajado a 65 chr
— Espen Schulstad
@EspenSchulstad ¿Eso se consideraría una función independiente, o hay otra plantilla que sería necesaria para que funcione?
— tfitzger
1
Si tiene groovy, puede ejecutarlo en groovysh o simplemente como un script groovy en un archivo .groovy. entonces no necesitas ninguna función.
— Espen Schulstad,
— Espen Schulstad
@EspenSchulstad Interesante. Solo he hecho un trabajo mínimo con Groovy.
— tfitzger
4

Pyth, 32 31 bytes

Jugué al golf en Python, pero resultó ser exactamente lo mismo que la respuesta de Sp3000. Así que decidí probar Pyth:

V48<%"'%02d:%d0',",/N2*3%N2-54N

Es una traducción exacta de la respuesta de Sp3000:

for i in range(48):print"'%02d:%d0',"[:57-i]%(i/2,i%2*3)

Es mi primera visita a Pyth, así que por favor, ilumíneme sobre ese ahorro de 1 byte.

— Def
fuente
Bien hecho, y bienvenido a Pyth.
— isaacg
3

PHP, 109 bytes

foreach(new DatePeriod("R47/2015-05-07T00:00:00Z/PT30M")as$d)$a[]=$d->format("'H:i'");echo implode(",\n",$a);
— nickb
fuente
3

Ruby, 54 51 bytes

puts (0..23).map{|h|"'#{h}:00',
'#{h}:30'"}.join",
"
— golgappa
fuente
1
Puede reducir 3 bytes cambiando \na nuevas líneas reales y eliminando el espacio entre joiny ". Por otro lado, tenga en cuenta que la salida especificada tiene ceros a la izquierda para las horas.
— rorlork
Además, algunos bytes más cambiando puts a $><<(sin espacio) y .joincon *. Sin embargo, todavía tiene el principal problema de cero por horas.
— rorlork
3

C, 116 , 115 , 101 , 100 , 95 , 74 , 73 , 71

Es posible que pueda eliminar algunos bytes más de esto ...

main(a){for(;++a<50;)printf("'%02d:%d0'%s",a/2-1,a%2*3,a<49?",\n":"");}
— Joshpbarron
fuente
Puede guardar 3 bytes creando una función en lugar de un programa completo. Simplemente reemplace "principal" con "f", o sea cual sea su letra favorita.
— Bijan
Oh, esa es una muy buena sugerencia ... ¡una que siempre olvido!
— Joshpbarron
3

T-SQL, 319 307 305 bytes

WITH t AS(SELECT t.f FROM(VALUES(0),(1),(2),(3),(4))t(f)),i AS(SELECT i=row_number()OVER(ORDER BY u.f,v.f)-1FROM t u CROSS APPLY t v),h AS(SELECT i,h=right('0'+cast(i AS VARCHAR(2)),2)FROM i WHERE i<24)SELECT''''+h+':'+m+CASE WHEN i=23AND m='30'THEN''ELSE','END FROM(VALUES('00'),('30'))m(m) CROSS APPLY h

Versión sin golf:

WITH
t AS(
    SELECT
        t.f
    FROM(VALUES
         (0),(1),(2),(3),(4)
    )t(f)
),
i AS(
    SELECT
        i = row_number() OVER(ORDER BY u.f,v.f) - 1
    FROM t u 
    CROSS APPLY t v
),
h AS(
    SELECT
        i,
        h = right('0'+cast(i AS VARCHAR(2)),2)
    FROM i
    WHERE i<24
)
SELECT
    '''' + h + ':' + m + CASE WHEN i=23 AND m='30' 
                              THEN '' 
                              ELSE ',' 
                         END
FROM(
    VALUES('00'),('30')
)m(m)
CROSS APPLY h
— Pieter Geerkens
fuente
2

Pyth, 34 bytes

j+\,bmjk[\'?kgd20Z/d2\:*3%d2Z\')48

Esto definitivamente se puede mejorar.

Pruébelo en línea: Pyth Compiler / Executor

Explicación:

     m                          48   map each d in [0, 1, ..., 47] to:
        [                      )       create a list with the elements:
         \'                              "'"
           ?kgd20Z                       "" if d >= 20 else 0
                  /d2                    d / 2
                     \:                  ":"
                       *3%d2             3 * (d%2)
                            Z            0
                             \'          "'"
      jk                               join by "", the list gets converted into a string
j+\,b                                join all times by "," + "\n"
— Jakube
fuente
Siempre impresionante con estos idiomas de golf :) De alguna manera lo aprecio más cuando se hace en un idioma que no es de golf. ¿Alguien sabe si hay un golf-jar-lib para Java, por ejemplo?
— Espen Schulstad,
El puerto obligatorio de sentiao da 31: j+\,bm%"'%02d:%s0'",/d2*3%d2 48con formato de cadena
— Sp3000
2

Python 2, 69 bytes

print',\n'.join(["'%02d:%s0'"%(h,m)for h in range(24)for m in'03'])

Muy obvio, pero aquí hay una explicación:

  • utilizando doble for-loop
  • alternar entre '0'y '3'en formato de cadena es más corto que una lista
  • %02d hace el relleno para h
  • mno necesita relleno ya que el carácter alternativo está en una posición fija
  • '\n'.join() resuelve los requisitos de la línea final

No tengo idea si se puede hacer más corto (en Python 2).

por Sp3000, 61 bytes: print',\n'.join("'%02d:%s0'"%(h/2,h%2*3)for h in range(48))

— sentiao
fuente
1
Qué tal:print',\n'.join("'%02d:%s0'"%(h/2,h%2*3)for h in range(48))
— Sp3000
¡Brillante, Sp3000! (deberías publicarlo)
— sentiao
1
No, no es lo suficientemente diferente como para publicar en mi libro. Todo lo que hice fue quitar los corchetes (que son innecesarios incluso en el tuyo) y soltar m. (También son 59 bytes, no 61)
— Sp3000
2

Haskell, 85 bytes

putStr$init$init$unlines$take 48['\'':w:x:':':y:"0',"|w<-"012",x<-['0'..'9'],y<-"03"]

Lamentablemente printfrequiere un byte de 19 import, por lo que no puedo usarlo.

— nimi
fuente
2

Julia: 65 64 61 caracteres

[@printf("'%02d:%d0'%s
",i/2.01,i%2*3,i<47?",":"")for i=0:47]

Julia: 64 caracteres

(Seguí aquí para mostrar la buena forsintaxis de Julia ).

print(join([@sprintf("'%02d:%d0'",h,m*3)for m=0:1,h=0:23],",
"))
— hombre trabajando
fuente
2

Fortran 96

do i=0,46;print'(a1,i2.2,a,i2.2,a2)',"'",i/2,":",mod(i,2)*30,"',";enddo;print'(a)',"'23:30'";end

Abuso estándar de tipos y requisitos solo para el final endpara la compilación. Lamentablemente, debido al formato implícito, se requiere la declaración '(a)'final print. Aún así, mejor que las respuestas C y C ++;)

— Kyle Kanos
fuente
2

JavaScript (ES6), 77 86 + 1 bytes

No me di cuenta de que tenía que haber comillas en cada línea (+1 es para el -pindicador con nodo):

"'"+Array.from(Array(48),(d,i)=>(i>19?"":"0")+~~(i/2)+":"+3*(i&1)+0).join("',\n'")+"'"

vieja solución:

Array.from(Array(48),(d,i)=>~~(i/2).toFixed(2)+":"+3*(i&1)+"0").join(",\n")

versión sin golf (usando un bucle for en lugar de Array.from):

var a = [];
// there are 48 different times (00:00 to 23:30)
for (var i = 0; i < 48; i++) {
    a[i] =
        (i > 19 ? "" : "0") +
            // just a ternary to decide whether to pad
            // with a zero (19/2 is 9.5, so it's the last padded number)
        ~~(i/2) +
            // we want 0 to 24, not 0 to 48
        ":" +  // they all then have a colon
        3*(i&1) +
            // if i is odd, it should print 30; otherwise, print 0
        "0" // followed by the last 0
}
console.log(a.join(",\n"));
— Royhowie
fuente
72: Array.from(Array(48),(d,i)=>`'${i>19?"":0}${0|i/2}:${i%2*3}0'`).join`,\n`. Reemplace \ n con una nueva línea real.
— Mama Fun Roll
2

golflua 52 51 caracteres

~@n=0,47w(S.q("'%02d:%d0'%c",n/2,n%2*3,n<47&44|0))$

Usando ascii 44 = ,y 0 un espacio ahorra un personaje.

Una versión de Lua sin golf sería

for h=0,47 do
   print(string.format("'%02d:%d0'%c",h/2,h%2*3, if h<47 and 44 or 0))
end

La ifdeclaración es muy parecida al operador ternario a > b ? 44 : 0.

— Kyle Kanos
fuente
2

C # - 120 bytes

class P{static void Main(){for(var i=0;i<24;i++)System.Console.Write("'{0:00}:00',\n'{0:00}:30'{1}\n",i,i==23?"":",");}}
— Berend
fuente
2

Python, 60 58 64 bytes

for i in range(24):print("'%02d:00,\n%02d:30'"%(i,i)+', '[i>22])

Sin golf:

for i in range(24):
    if i <23:
        print( ('0'+str(i))[-2:] + ':00,\n' + str(i) + ':30,')
    else:
        print( ('0'+str(i))[-2:] + ':00,\n' + str(i) + ':30')

Pruébelo en línea aquí .

— Tim
fuente
1
¿Por qué no ponerlo en 1 línea y guardar otros 2 bytes?
— isaacg
No creo que esto funcione, no hay cero a la hora.
— isaacg
1
@isaacg arregló eso!
— Tim
El resultado no es el mismo que en la pregunta original.
— sentiao
@sentiao, ¿qué es diferente?
— Tim
2

PHP, 69 70 62 bytes

for($x=-1;++$x<47;)printf("'%02d:%d0',
",$x/2,$x%2*3)?>'23:30'

Pruébalo en línea

Dar salida '23:30'al final es un poco escaso, y por lo tanto se está cerrando el contexto PHP usando ?>sin abrir o volver a abrirlo. Una alternativa más limpia (pero 65 bytes) sería:

for($x=-1;++$x<48;)printf("%s'%02d:%d0'",$x?",
":'',$x/2,$x%2*3);

Pruébalo en línea

Gracias @ Dennis por los consejos. Alternativa inspirada en el aporte de @ ismael-miguel.

— mk8374876
fuente
1
¡Bienvenido a Programming Puzzles & Code Golf! Su código imprime un byte nulo al final. No estoy seguro si eso está permitido.
— Dennis
@ Dennis Gracias, tienes razón ... Supuse que PHP lo vería como el final de la cadena. Publicado una nueva versión.
— mk8374876
<?...?>'23:30'Guarda tres bytes. Además, puede reemplazar \ncon una nueva línea real.
— Dennis
2

Rápido, 74 bytes

Actualizado para Swift 2/3 ... y con una nueva interpolación de cadenas ...

for x in 0...47{print("'\(x<20 ?"0":"")\(x/2):\(x%2*3)0'\(x<47 ?",":"")")}
— GoatInTheMachine
fuente
La línea final se especifica para no tener una coma y su código la imprime.
— Kyle Kanos
1

Javascript, 89 bytes

for(i=a=[];i<24;)a.push((x="'"+("0"+i++).slice(-2))+":00'",x+":30'");alert(a.join(",\n"))
— SuperJedi224
fuente
1
Pregunta rápida: ¿cuántos argumentos Array.push()soporta? ;)
— manatwork
Tienes razón. Eso es una poliada. Gracias, haré ese cambio después de que termine de probar mi entrada para otro desafío.
— SuperJedi224
Se pueden eliminar algunos caracteres más con algunas reorganizaciones elementales:for(i=a=[];i<24;)a.push((x=("0"+i++).slice(-2))+":00",x+":30");alert(a.join(",\n"))
— manatwork
Ahí lo arreglé.
— SuperJedi224
Esa reutilización de la variable x es un hábito de codificación bastante feo. Si cambia la variable de control de bucle a otra cosa (como en mi sugerencia en 2015-05-07 15: 28: 25Z), entonces puede agregar las comillas simples de apertura al valor de x para reducir las dos "'"+piezas a una:for(i=a=[];i<24;)a.push((x="'"+("0"+i++).slice(-2))+":00'",x+":30'");alert(a.join(",\n"))
— manatwork
1

Python 2: 64 bytes

print ',\n'.join(['%02d:00,\n%02d:30'%(h,h) for h in range(24)])
— Alan Hoover
fuente
El resultado no es el mismo que en la pregunta original.
— sentiao
No sé qué pasó con la edición que hice. Aquí está la versión correcta también 64 caracteres:print',\n'.join("'%02d:00',\n'%02d:30'"%(h,h)for h in range(24))
— Alan Hoover
1

Ruby - 52 bytes

puts (0..47).map{|i|"'%02d:%02d'"%[i/2,i%2*30]}*",
"
— Tomáš Dundáček
fuente
Esta parece ser mi solución con solo el cambio de .joinpara *... Es una cortesía común en lugar de simplemente publicar una nueva respuesta con una mejora menor, para sugerir la mejora del póster original. Ver meta.codegolf.stackexchange.com/questions/75/…
— rorlork
@rcrmn Estoy de acuerdo en que cometí un error y me disculpo por ello, debería haber buscado otras respuestas de rubí primero. Gran trabajo, sin embargo, en su respuesta con $><<!
— Tomáš Dundáček
No te preocupes por eso, eres nuevo aquí: te estaba aconsejando para que pudieras evitar esto en el futuro.
— rorlork
1

Python 2, 74 65 bytes

Generamos una cadena de 2 líneas por cada hora, usando el formato de texto:

print',\n'.join("'%02u:00',\n'%02u:30'"%(h,h)for h in range(24))

Este código es bastante claro, pero la indexación inteligente y las matemáticas enteras en la respuesta de Sp3000 ofrecen una solución más corta.

— Caballero Lógico
fuente
1
no hay razón para usar el formato para 00 y 30, guarde 9 bytes con"'%02u:00',\n'%02u:30'"%(h,h)
— DenDenDo
podría guardar algunos bytes teniendo también bucles: print',\n'.join("'%02u:%02u'"%(h,i)for h in range(24)for i in[0,30])
— dieter
Gracias DenDenDo Usé esto para guardar algunos bytes. Dieter, puedo ver dónde puede ayudar tu idea, pero podría guardar más bytes con esa idea de DenDenDo.
— Logic Knight
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.