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.

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

f=(x,y)=>~-x%12-~(x-y&&f(x%24+1,y))
g=(x,y)=>console.log("x:",x,"y:",y,"result:",f(x,y))

g(10,12)
g(1,5)
g(11,15)
g(22,10)

<input id=A type="number" min=1 max=24 value=9>
<input id=B type="number" min=1 max=24 value=17>
<button onclick="g(A.value,B.value)">Run</button>

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

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

Python 2, 59 54 bytes

a=lambda x,y:sum(1+i%12for i in range(x-1,y+24*(x>y)))

summ=0
if start > end:
    end+=24
for hour in range(start-1,end):
    summ +=1+hour%12
print summ

05AB1E , 13 bytes

Con mucha ayuda de Emigna .

-24%ݹ+<12%>O

Utiliza la codificación CP-1252 . Pruébalo en línea!

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.

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

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

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

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

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

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

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

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

Pyth - 11 bytes

s|R12%R12}F

Test Suite .

C #, 76 bytes

(a,b)=>Enumerable.Range(a,Math.Abs(b-a)+1).Select(n=>n%12==0?12:n%12).Sum();

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

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

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

C, 56 bytes

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

> <> , 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!

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$@.;

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

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