¿Cuántas veces sonará un campanario?

24

Introducción

Un campanario hará sonar sus campanas cada hora, nveces, nsiendo la hora actual en un reloj de 12 horas.

Por ejemplo, una campana sonará 5 veces a las 5 p.m. y 10 veces a las 10 a.m.

Tarea

Dado dos veces en un formato adecuado, emite el número de veces que sonará la campana, incluidas las horas de inicio y finalización

Ejemplos

"10am-12pm"
10+11+12= 33

[01:00, 05:00]
1+2+3+4+5 = 15

[11, 15]
11+12+1+2+3 = 29

[10:00pm, 10:00am]
10+11+12+1+2+3+4+5+6+7+8+9+10 = 88

Si el inicio es el mismo que el final, entonces simplemente superas el número de campanas para esa hora:

[5pm, 5pm]
5 = 5

Como puede ver, puede elegir un método de entrada, pero la salida debe ser un entero por sí mismo (o una alternativa aceptable).

Nota:

  • Las entradas pueden abarcar desde la tarde de un día hasta la mañana del siguiente.
  • La diferencia entre las dos veces nunca será más de 24 horas.
  • la entrada es flexible siempre que indique claramente qué formato tiene su entrada.
  • su entrada debe tener una clara distinción entre AM y PM.
Shaun Wild
fuente
2
¿Elegimos nuestro propio método de entrada o tiene que admitir todo lo mencionado?
anonymous2
1
Puede elegir el método de entrada
Shaun Wild
1
Debe dejar más claro que las entradas pueden ir de pma am, cruzando así a un segundo día.
mbomb007
3
¿Se dará la medianoche como 0 o 24?
xnor
44
Alentamos el uso del Sandbox para resolver cualquier problema con desafíos antes de que se publiquen en el sitio principal.
Mego

Respuestas:

12

JavaScript (ES6), 38 35 bytes

f=(x,y)=>~-x%12-~(x-y&&f(x%24+1,y))

Agrega recursivamente el número actual de timbres al total. Llamado como f(11,15); la medianoche se representa como 24. Obtuve parte del ~-truco de la respuesta Python de @ xnor .

Fragmento de prueba

Versión no recursiva (Firefox 30+), 56 bytes

(x,y,t=0)=>[for(_ of Array((y-x+25)%24))t+=x++%12||12]|t

Equivalente a la siguiente función ES6:

(x,y,t=0)=>[...Array((y-x+25)%24))].map(_=>t+=x++%12||12)|t
ETHproducciones
fuente
7

Python 2, 46 bytes

f=lambda x,y:(x%12or 12)+(x-y and f(-~x%24,y))

Basado en mi respuesta JS. La fórmula recursiva f para la solución se define así:

  1. Comience con dos enteros x e y .
  2. Toma x mod 12 ; Si esto es 0, tome 12 en su lugar.
  3. Si x! = Y , suma el resultado de f (x + 1 mod 24, y) .
ETHproducciones
fuente
6

Python 2, 59 54 bytes

a=lambda x,y:sum(1+i%12for i in range(x-1,y+24*(x>y)))
Equivalente a
summ=0
if start > end:
    end+=24
for hour in range(start-1,end):
    summ +=1+hour%12
print summ
Barra
fuente
3
Creo que no necesitas la a=parte.
acrolith el
@daHugLenny debe ser una función completa (utilizable)
Rod
(y + 24)% 24 es solo y
Vladimir Cravero
1
@ Rod No lo necesitas a=. Está permitido ser una lambda pura.
Yytsi
1
@VladimirCravero Por supuesto que no. Es lo mismo que y%24.
Erik the Outgolfer
3

Python, 42 bytes

f=lambda a,b:~-a%12-~(b-a and f(-~a%24,b))

Una función recursiva que toma dos números del 0 al 23. Expandir los ~x's para -x-1dar

f=lambda a,b:(a-1)%12+1+(b-a and f((a+1)%24,b))

La expresión (a+1)%12+1convierte un tiempo en el número de anillos 1a 12. Luego, el límite inferior se incrementa en el módulo 24 y se agrega la función para el resultado recursivo. Es decir, a menos que la hora actual sea la hora final, en cuyo caso nos detendremos.

En cambio, he estado tratando de escribir una solución puramente aritmética, pero hasta ahora solo he encontrado expresiones largas y desordenadas.

xnor
fuente
Ah, lo entiendo: es básicamente la misma técnica que mi respuesta de Python, pero con una forma muy inteligente de evitarlo or. ¡Buena esa!
ETHproductions
3

Haskell, 48 43 bytes

s%e=sum[mod x 12+1|x<-[s-1..e+23],x<e||s>e]

El uso es startHour % endHour, con ambas entradas en formato de 24 horas.

editar: se agregó la mejora de @ xnor, ahorrando 5 bytes

Nick Hansen
fuente
En lugar de cambiar ecuándo e<s, puede filtrar el rango s%e=sum[mod(x-1)12+1|x<-[s..e+24],x<=e||s>e]. A continuación, guarda un byte en desplazamiento x por 1: s%e=sum[mod x 12+1|x<-[s-1..e+23],x<e||s>e].
xnor
3

C #, 73 bytes

a=>b=>{int x=0;for(;;){x+=(a%=24)>12?a-12:a<1?12:a;if(a++==b)return x;}};

Entrada aceptable: enteros en el rango [0,23].

Esta solución no usa LINQ.


Programa completo con casos de prueba:

using System;

namespace HowManyTimesABellTowerRings
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<int,Func<int,int>>f= a=>b=>{int x=0;for(;;){x+=(a%=24)>12?a-12:a<1?12:a;if(a++==b)return x;}};

            Console.WriteLine(f(10)(12));   //33
            Console.WriteLine(f(1)(5));     //15
            Console.WriteLine(f(11)(15));   //29
            Console.WriteLine(f(22)(10));   //88
            Console.WriteLine(f(10)(10));   //10
            Console.WriteLine(f(11)(10));   //156
            Console.WriteLine(f(0)(23));    //156
            Console.WriteLine(f(22)(1));    //34
        }
    }
}
adrianmp
fuente
3

Jalea , 17 16 15 14 bytes

>×24+⁹⁸r’%12‘S

TryItOnline

¿Cómo?

>×24+⁹⁸r’%12‘S - Main link: a, b (24 hr integers, midnight may be 0 or 24)
>              - a>b? (1 if true, 0 if false)
 ×24           - times 24 (24 if a>b, else 0)
    +⁹         - add to b (b+24 if a>b, else b)
      ⁸        - a
       r       - range(a, b+24 or b) ([a,a+1,...,b+24 or b])
        ’      - decrement (vectorises) ([a-1,a,...,b+23 or b-1])
         %12   - mod 12 (vectorises) (number of tolls at each occurrence - 1)
            ‘  - increment (vectorises) (number of tolls at each occurrence)
             S - sum
Jonathan Allan
fuente
2

MATL , 14 bytes

yy>24*+&:12X\s

El formato de entrada es como en el tercer ejemplo en el desafío, es decir, dos números en formato de 24 horas.

Pruébalo en línea!

Explicación

Tomar entradas 22, 10como un ejemplo.

yy      % Take two inputs implicitly. Duplicate both
        %   STACK: 22, 10, 22, 10
>       % Is the first greater than the second?
        %   STACK: 22, 10, 1
24*     % Multiply by 24
        %   STACK: 22, 10, 24
+       % Add
        %   STACK: 22, 34
&:      % Binary range
        %   STACK: [22 23 24 25 26 27 28 29 30 31 32 33 34]
12X\    % Modulo 12, 1-based
        %   STACK: [10 11 12 1 2 3 4 5 6 7 8 9 10]
s       % Sum of array
        %   STACK: 88
        % Implicitly display
Luis Mendo
fuente
2

PHP, 90 bytes

Formato de entrada '[1,24]' entre 1 y 24

En este desafío, odio por qué PHP se suelta contra otros lenguajes. Prefiero mostrar todas mis ideas. Quizás otro PHP Crack encuentre una solución más corta.

<?list($f,$g)=$_GET[b];for($i=$f;$i-1!=$g|$f>$g&!$c;$s+=$i++%12?:12)$i<25?:$c=$i=1;echo$s;

99 bytes

<?for($i=($b=$_GET[b])[0],$c=($d=$b[1]-$b[0])<0?25+$d:$d+1;$c--;$s+=$i++%12?:12)$i<25?:$i=1;echo$s;

113 Bytes por camino con min y max

<?for($i=min($b=$_GET[b]);$i<=$m=max($b);)$s+=$i++%12?:12;echo($b[0]>$b[1])?156-$s+($m%12?:12)+($b[1]%12?:12):$s;

bien esta idea loca trabaja con una matriz 149 Bytes llena la matriz $y[0]y $y[1]si $_GET["b"][0]<=$_GET["b"][1] , si $y[1]es nullque podemos resumir esta matrizarray_diff_key($y[0],array_slice($y[0],$b[1],$b[0]-$b[1]-1,1))

<?for(;++$i<25;)$y[$i>=($b=$_GET[b])[0]&$i<=$b[1]][$i]=$i%12?:12;echo array_sum($y[1]??array_diff_key($y[0],array_slice($y[0],$b[1],$b[0]-$b[1]-1,1)));

Esto podría reducirse a 124 Bytes

<?for(;++$i<25;)$x[($v=($b=$_GET[b])[0]>$b[1])?$i<$b[0]&$i>$b[1]:$i>=$b[0]&$i<=$b[1]][$i]=$i%12?:12;echo array_sum($x[!$v]);

Ahora bien, en este punto, podemos reducir la matriz con sólo dos enteros 101 Bytes 2 Hacer sumas $x[0]y$x[1]

list($f,$g)=$_GET[b];

si $v=($f>$g luego agregar valor a $x[$i<$f&$i>$g] otro valor agregado a $x[$i>=$f&$i<=$g] la salida se encontrará por casoecho$x[!$v];

<?list($f,$g)=$_GET[b];for(;++$i<25;)$x[($v=$f>$g)?$i<$f&$i>$g:$i>=$f&$i<=$g]+=$i%12?:12;echo$x[!$v];

Después de eso encontré una manera de calcular el resultado directamente 112 Bytes

<?list($x,$y)=$_GET[t];echo(($b=$x>$y)+(($x-($s=$x%12?:12)^$y-($t=$y%12?:12))xor$b))*78-($s*($s-1)-$t*($t+1))/2;

103 Bytes recursivos

<?list($x,$y)=$_GET[t];function f($x,$y){return($x%12?:12)+($x-$y?f(++$x<25?$x:1,$y):0);}echo f($x,$y);
Jörg Hülsermann
fuente
2

PHP, 69 bytes

list(,$i,$a)=$argv;for($a+=$i>$a?24:0;$i<=$a;)$n+=$i++%12?:12;echo$n;

La extracción de la lista se inspiró en la respuesta de Jörg Hülsermann, pero el resto de las similitudes son el resultado de una evolución convergente y debido a que es bastante más corto y los condicionales en el bucle son lo suficientemente diferentes, lo publico como una respuesta separada.

Toma datos como 24 horas (bien con 0 o 24). Corre como:

php -r "list(,$i,$a)=$argv;for($a+=$i>$a?24:0;$i<=$a;)$n+=$i++%12?:12;echo$n;" 9 18
usuario59178
fuente
$i>$a?24:0tiene la misma longitud que ($i>$a)*24 wiki.php.net/rfc/short_list_syntax Quizás desee usar la sintaxis de lista corta que es nueva en 7.1 [$x,$i,$a]=$argv;-2 Bytes Antes de que no haya probado que no la usaría. Bueno, ahora me odio más de lo que no he encontrado de esta manera.
Jörg Hülsermann
gracias, conocía la próxima sintaxis de la lista corta, pero como php 7.1 aún no se ha lanzado correctamente (todavía en la versión candidata 3 al momento de escribir), asumí que aún no estaba permitido en las respuestas de PPCG.
user59178
2

Java, 72 71 78 76 bytes

Usage: 
    pm:    true if first time is past 11am
    time:  first time%12
    pm2:   true if second time is past 11am
    time2: second time%12

Editar :

  • -1 byte desactivado. Gracias a @ 1Darco1
  • Cabezal de función fija. +7 bytes en.
  • -2 bytes desactivados. Gracias a @Kevin Cruijssen
  • +2 bytes en. Ahora e/ clockse inicializa.

(a,b,c,d)->{int e=0;b+=a?12:0;d+=c?12:0;for(;b!=d;e+=b%12,b=++b%24);return e;}

Sin golf:

public static int clock(boolean pm, int time, boolean pm2, int time2){
  int clock=0;
  time+=pm?12:0;
  time2+=pm2?12:0;
  while(time!=time2){
    clock+=time%12;
    time=++time%24;
  }
  return clock;
}
Roman Gräf
fuente
¿Dónde define a, y d, y b? El método completo tiene sentido, pero a menos que me falte algo gravemente, creo que debes mirar tu lambda de golf nuevamente e intentar ejecutarlo. Para más golf: (time+1)puede convertirse ++time.
1Darco1
Hay un error en la parte de golf: a+=a?debería ser b+=a?. Además, puedes jugarlo en 2 bytes cambiando el whilecuerpo a un cuerpo forcomo este:(a,b,c,d)->{int e;b+=a?12:0;d+=c?12:0;for(;b!=d;e+=b%12,b=++b%24);return e;}
Kevin Cruijssen
Lo siento. Escribí este enfoque desde mi móvil y no pude probarlo. Fijo. :)
Roman Gräf
1

QBIC , 90 47 bytes

Entonces, aquí está la respuesta imprimiendo solo el número total de timbres:

::{c=a~c>12|c=c-12]d=d+c~a=b|_Xd]a=a+1~a>24|a=1

La entrada está en el rango 1-24; ay bson las entradas ( ::en el código), crealiza un seguimiento de am / pm, des el número total de timbres. Cuando hemos contado todas las horas, _Xdfinaliza el programa e imprime den el proceso.


OK, entendí mal la pregunta y pensé que el 1+2+3...=texto era parte del resultado, así que escribí que:

::{c=a~c>12|c=c-12]X=!c$Z=Z+X+@+| d=d+c~a=b|?left$$|(Z,len(Z)-1)+@ =|+!d$_X]a=a+1~a>24|a=1

Ahora, voy a codificar la respuesta correcta ...

Steenbergh
fuente
1

Pyth - 11 bytes

s|R12%R12}F

Test Suite .

Maltysen
fuente
2
Esto no cuenta alrededor de la medianoche, por ejemplo, 23, 1salidas 144cuando debería salir 24. (¡Tal caso, por supuesto, debería estar en las pruebas!)
Jonathan Allan
1

C #, 76 bytes

(a,b)=>Enumerable.Range(a,Math.Abs(b-a)+1).Select(n=>n%12==0?12:n%12).Sum();
downrep_nation
fuente
Esto no parece que se envuelva a medianoche.
Neil
Todos los casos de prueba tienen éxito
downrep_nation
No pregunté eso.
Neil
Entonces, ¿qué caso de prueba tuyo falla con mi implementación?
downrep_nation
a=23y b=0parece ser el ejemplo más obvio.
Neil
1

Perl, 36 bytes

Incluye +1 para -p

Indique la hora de inicio y finalización en formato de 24 horas en una línea en STDIN:

toll.pl
11
15
^D

toll.pl:

#!/usr/bin/perl -p
$\+=$_%12||12for$_..$_+(<>-$_)%24}{
Ton Hospel
fuente
1

Java 7, 64 bytes

int c(int x,int y){return(x%12<1?12:x%12)+(x!=y?c(-~x%24,y):0);}

Método recursivo basado en la respuesta Python 2 de @ETHproductions . Utiliza una entrada de reloj de 24 horas.

Ungolfed y código de prueba:

Pruébalo aquí

class M{
  static int c(int x, int y){
    return (x%12 < 1
             ? 12
             : x%12)
         + (x != y
             ? c(-~x % 24, y)
             : 0);
  }

  public static void main(String[] a){
    System.out.println(c(10, 12));
    System.out.println(c(1, 5));
    System.out.println(c(11, 15));
    System.out.println(c(10, 22));
    System.out.println(c(5, 5));
  }
}

Salida:

33
15
29
88
5
Kevin Cruijssen
fuente
1

Lote, 168 91 bytes

@cmd/cset/ax=(%1+23)%%24,y=x+(%2+24-%1)%%24,z=y%%12+1,(y/12-x/12)*78+z*-~z/2-(x%%=12)*-~x/2

Editar: Guardado 77 bytes al cambiar a un formulario cerrado para la respuesta.

  • %1y %2son los dos parámetros de la línea de comandos
  • @ Deshabilite el valor predeterminado de Batch, que es hacer eco del comando
  • cmd/c Fool Batch para imprimir inmediatamente el resultado del cálculo
  • set/a Realizar un cálculo numérico
  • x=(%1+23)%%24, Normalice la hora de inicio para que sea la cantidad de horas desde la 1AM (1PM también funcionaría, pero 11 no es más corto que 23)
  • y=x+(%2+24-%1)%%24, Normalice la hora de finalización para adelantarse a la hora de inicio, avanzando al día siguiente si es necesario
  • z=y%%12+1, Número de campanas golpeadas a la hora final
  • (y/12-x/12)*78+ Número de campanas debido a medio día extra
  • z*~-z/2- Número de campanas desde la 1 en punto hasta la hora de finalización inclusive
  • (x%%=12) Uno menos que el número de campanas golpeadas a la hora de inicio
  • *-~x/2 Número de campanas que habrían sonado desde la 1 en punto hasta la hora de inicio, pero sin incluir la hora de inicio
Neil
fuente
1

C, 56 bytes

f(a,b,c=0){while(b-->a){c+=b>12?b-12:b;}printf("%d",c);}

fuente
1

> <> , 48 + 2 = 50 bytes

<v$&%$-&:$+}:*2c
{>:?!v1-}:1+
v?=1l<++1%c+b$
>n;

Se espera que la entrada esté presente en la pila al inicio del programa, por lo que +2 bytes para el -vindicador. La entrada es dos enteros que especifican la hora en el reloj de 24 horas, por 10am - 10pmlo que se daría como 10 22.

Pruébalo en línea!

Sok
fuente
@LuisMendo Gracias, ya está arreglado
Sok
1

Cubix , 45 44 bytes

Guardado 1 byte, gracias a @ETHproductions

Mi primera incursión en Cubix ...

)$424tU4OI0Iuq;;-!^;^%&21u+rr;ss!;sqU>&%r$@;

O cubicado:

      ) $ 4
      2 4 t
      U 4 O
I 0 I u q ; ; - ! ^ ; ^
% & 2 1 u + r r ; s s !
; s q U > & % r $ @ ; .
      . . .
      . . .
      . . .

Puede probarlo en el intérprete en línea . La entrada está en formato de 24 horas, con la hora de finalización primero. Por ejemplo, de 5pm a 1am la entrada debería ser 1 17.


Versión anterior, 45 bytes:

)$442t\/OI0Iuq;;-!^;^%&21u+rr;ss!;sqU>&%r$@.;
Sok
fuente
1
Gracias por usar mi idioma, y ​​gran trabajo :-) Veo un pequeño byte que puede guardar reorganizando ligeramente y dejando de lado el no-op:)$424tU4OI0Iuq;;-!^;^%&21u+rr;ss!;sqU>&%r$@;
ETHproductions
0

Qbasic, 112 bytes

input "",a
input "",b
do
if a=25 then a=1
if a<=12 then
c=c+a
else
c=c+a-12
endif
a=a+1
loop until a=b+1
print c
anónimo2
fuente
¿No debería generar 12 cuando las horas de inicio y finalización son cero?
Neil
0

Python, 73 bytes

Sería mucho más corto si no tenemos para apoyar pma am. Yo uso la recursividad para apoyarlo.

f=lambda a,b:sum([~-i%12+1for i in range(a,b+1)]*(a<b)or[f(a,24),f(1,b)])

Pruébalo en línea

Sin soporte pmpara am(45 bytes):

lambda a,b:sum(~-i%12+1for i in range(a,b+1))
mbomb007
fuente