introduction

Un clocher sonnera toutes les heures, toutes les heures, navec nl'heure actuelle sur une horloge de 12 heures.

Par exemple, une cloche sonnera 5 fois à 17h et 10 fois à 10h.

Tâche

Donné deux fois dans un format approprié, affichez le nombre de sonneries, y compris les heures de début et de fin

Exemples

"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 le début est le même que la fin, il vous suffit de sortir le nombre de carillons pour cette heure:

[5pm, 5pm]
5 = 5

Comme vous pouvez le voir, vous pouvez choisir une méthode d'entrée, mais la sortie doit être un entier seul (ou une alternative acceptable) les sauts de ligne / début et les espaces sont autorisés.

Remarque:

• les intrants peuvent s'étendre de l'après-midi d'un jour au matin du lendemain.
• la différence entre les deux temps ne sera jamais supérieure à 24 heures.
• l'entrée est flexible tant que vous indiquez clairement le format de votre entrée.
• votre entrée doit avoir une distinction claire entre AM et PM.

JavaScript (ES6), 38 35 octets

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

Ajoute récursivement le nombre actuel de sonneries au total. Appelé comme f(11,15); minuit est représenté par 24. J'ai obtenu une partie de l' ~-astuce de la réponse Python de @ xnor .

Extrait de test

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>

Version non récursive (Firefox 30+), 56 octets

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

Équivalent à la fonction ES6 suivante:

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

Python 2, 46 octets

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

Basé sur ma réponse JS. La formule récursive f pour la solution est définie comme suit:

1. Commencez avec deux entiers x et y .
2. Prenez x mod 12 ; si c'est 0, prenez 12 place.
3. Si x! = Y , ajoutez le résultat de f (x + 1 mod 24, y) .

Python 2, 59 54 octets

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 octets

Avec beaucoup d'aide d' Emigna .

-24%ݹ+<12%>O

Utilise l' encodage CP-1252 . Essayez-le en ligne!

Python, 42 octets

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

Une fonction récursive qui prend deux nombres de 0 à 23. L'extension du ~x's à -x-1donne

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

L'expression (a+1)%12+1convertit un temps en nombre de sonneries 1en12 . Ensuite, la borne inférieure est incrémentée modulo 24 et la fonction pour le résultat récursif est ajoutée. Autrement dit, sauf si l'heure actuelle est l'heure de fin, auquel cas nous nous arrêtons.

J'ai plutôt essayé d'écrire une solution purement arithmétique, mais jusqu'à présent, je n'ai trouvé que des expressions longues et désordonnées.

Haskell, 48 43 octets

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

L'utilisation est startHour % endHour, avec les deux entrées données au format 24 heures.

edit: ajout de l'amélioration de @ xnor, économisant 5 octets

C #, 73 octets

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

Entrée acceptable: entiers dans la plage [0,23].

Cette solution n'utilise pas LINQ.

Programme complet avec cas de test:

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

Gelée , 17 16 15 14 octets

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

TryItOnline

Comment?

>×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 octets

yy>24*+&:12X\s

Le format d'entrée est comme dans le troisième exemple du défi, c'est-à-dire deux nombres au format 24 heures.

Essayez-le en ligne!

Explication

Prenez des entrées 22, à 10titre d'exemple.

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 octets

Format d'entrée «[1,24]» entre 1 et 24

Dans ce défi que je déteste pourquoi PHP lâche contre d'autres langages. Je préfère montrer toutes mes idées. Peut-être qu'un autre PHP Crack trouve une solution plus courte.

<?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 octets

<?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 octets par chemin avec min et 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 cette idée folle fonctionne avec un tableau 149 octets remplit le tableau $y[0]et $y[1]si $_GET["b"][0]<=$_GET["b"][1] si $y[1]est que nullnous pouvons résumer ce tableauarray_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)));

Cela pourrait être joué sur 124 octets

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

Maintenant, à ce stade, nous pouvons réduire le tableau avec seulement deux pouces 101 octets faire 2 sommes $x[0]et$x[1]

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

si $v=($f>$g alors ajouter de la valeur à $x[$i<$f&$i>$g] autre ajouter de la valeur à $x[$i>=$f&$i<=$g] la sortie sera trouvé par casecho$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];

Après cela, j'ai trouvé un moyen de calculer le résultat directement 112 octets

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

récursif 103 octets

<?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 octets

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

L'extraction de la liste a été inspirée par la réponse de Jörg Hülsermann, mais le reste des similitudes est le résultat d'une évolution convergente et parce qu'elle est beaucoup plus courte et que les conditions de la boucle sont suffisamment différentes, je la poste en tant que réponse distincte.

Prend l'entrée en tant que 24 heures (bien avec 0 ou 24). Courez comme:

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 octets

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

Modifier :

• -1 octet désactivé. Merci à @ 1Darco1
• Tête de fonction fixe. +7 octets activés .
• -2 octets éteints. Merci à @Kevin Cruijssen
• +2 octets activés . Maintenant e/ clockest initialisé.

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

Non 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 octets

Voici donc la réponse en n'imprimant que le nombre total de sonneries:

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

L'entrée est dans la plage 1-24; aetb sont les entrées ( ::dans le code), cgarde une trace de am / pm, dest le nombre total de sonneries. Lorsque nous avons décompté toutes les heures, _Xdmet fin au programme et imprime ddans le processus.

OK, j'ai mal compris la question et j'ai pensé que le 1+2+3...=texte faisait partie de la sortie, alors j'ai écrit ceci:

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

Maintenant, je vais coder la bonne réponse ...

Pyth - 11 octets

s|R12%R12}F

Suite de tests .

C #, 76 octets

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

Perl, 36 octets

Comprend +1 pour -p

Donnez l'heure de début et de fin au format 24 heures sur une ligne chacun sur STDIN:

toll.pl
11
15
^D

toll.pl:

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

Java 7, 64 octets

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

Méthode récursive basée sur la réponse Python 2 de @ETHproductions . Utilise une entrée d'horloge de 24 heures.

Code non testé et testé:

Essayez-le ici.

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

Sortie:

33
15
29
88
5

Lot, 168 91 octets

@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

Modifier: 77 octets enregistrés en passant à un formulaire fermé pour la réponse.

• %1 et %2 sont les deux paramètres de ligne de commande
• @ Désactiver la valeur par défaut de Batch qui consiste à faire écho à la commande
• cmd/c Tromper le lot en imprimant immédiatement le résultat du calcul
• set/a Effectuer un calcul numérique
• x=(%1+23)%%24, Normaliser l'heure de début comme étant le nombre d'heures écoulées depuis 1 heure du matin (1 heure fonctionnerait également, mais 11 n'est pas inférieur à 23)
• y=x+(%2+24-%1)%%24, Normaliser l'heure de fin pour être en avance sur l'heure de début, passer au jour suivant si nécessaire
• z=y%%12+1, Nombre de cloches frappées à l'heure de fin
• (y/12-x/12)*78+ Nombre de cloches en raison de demi-journées supplémentaires
• z*~-z/2- Nombre de cloches de 1 heure à l'heure de fin incluse
• (x%%=12) Un de moins que le nombre de cloches frappées à l'heure de départ
• *-~x/2 Nombre de cloches qui auraient été frappées de 1 heure à l'heure de départ, mais sans compter l'heure de départ

C, 56 octets

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

> <> , 48 + 2 = 50 octets

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

L'entrée devrait être présente sur la pile au démarrage du programme, donc +2 octets pour l' -vindicateur. L'entrée est deux entiers spécifiant l'heure sur une horloge de 24 heures, donc 10am - 10pmserait donnée comme10 22 .

Essayez-le en ligne!

Cubix , 45 44 octets

1 octet enregistré grâce à @ETHproductions

Ma première incursion dans Cubix ...

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

Ou, cubifié:

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

Vous pouvez l'essayer sur l' interprète en ligne . L'entrée est au format 24 heures, avec l'heure de fin en premier. Par exemple, de 17 h à 1 h, l'entrée doit être 1 17.

Version précédente, 45 octets:

)$442t\/OI0Iuq;;-!^;^%&21u+rr;ss!;sqU>&%r$@.;

Qbasic, 112 octets

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 octets

Il serait tellement plus court si nous ne devions pas soutenir pmà am. J'utilise la récursivité pour le supporter.

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

Essayez-le en ligne

Sans prise en charge pmde am(45 octets):

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