Einführung

Ein Glockenturm wird seine Glocken jede Stunde klingelt, nmal, mit nder der aktuellen Stunde auf einer 12 - Stunden - Uhr sein.

Zum Beispiel klingelt eine Glocke 5 Mal um 17 Uhr und 10 Mal um 10 Uhr.

Aufgabe

Geben Sie in einem geeigneten Format zweimal an, wie oft die Glocke läuten soll, einschließlich Start- und Endzeit

Beispiele

"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

Wenn der Anfang mit dem Ende identisch ist, geben Sie einfach die Anzahl der Glockenspiele für diese Stunde ein:

[5pm, 5pm]
5 = 5

Wie Sie sehen, können Sie eine Eingabemethode auswählen, die Ausgabe muss jedoch eine Ganzzahl sein (oder eine akzeptable Alternative). Zeilenumbrüche und Leerzeichen sind zulässig.

Hinweis:

• Eingaben können vom Nachmittag eines Tages bis zum Morgen des nächsten Tages erfolgen.
• Die Differenz zwischen den beiden Zeiten wird niemals mehr als 24 Stunden betragen.
• Die Eingabe ist flexibel, solange Sie genau angeben, in welchem ​​Format die Eingabe erfolgt.
• Ihre Eingabe muss eine klare Unterscheidung zwischen AM und PM aufweisen.

JavaScript (ES6), 38-35 Byte

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

Addiert rekursiv die aktuelle Anzahl der Klingelzeichen zur Gesamtsumme. Genannt wie f(11,15); Mitternacht ist dargestellt als 24. Ich habe einen Teil des ~-Tricks von @ xnors Python-Antwort erhalten .

Testschnipsel

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>

Nicht rekursive Version (Firefox 30+), 56 Bytes

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

Entspricht der folgenden ES6-Funktion:

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

Basierend auf meiner Antwort von JS. Die rekursive Formel f für die Lösung ist wie folgt definiert:

1. Beginnen Sie mit zwei ganzen Zahlen x und y .
2. Nimm x mod 12 ; Wenn dies 0 ist, nimm 12 stattdessen .
3. Wenn x! = Y , addiere das Ergebnis von 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

Mit viel Hilfe von Emigna .

-24%ݹ+<12%>O

Verwendet die CP-1252- Codierung. Probieren Sie es online!

Python, 42 Bytes

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

Eine rekursive Funktion , die zwei Zahlen von 0 bis 23. Der Ausbau der nimmt ~x‚s zu -x-1erhalten

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

Der Ausdruck (a+1)%12+1wandelt eine Zeit in die Anzahl der Klingeltöne 1um 12. Dann wird die Untergrenze modulo 24 inkrementiert und die Funktion für das rekursive Ergebnis hinzugefügt. Das heißt, es sei denn, die aktuelle Stunde ist die Endstunde. In diesem Fall hören wir auf.

Ich habe versucht, stattdessen eine rein arithmetische Lösung zu schreiben, aber bisher habe ich nur lange und unordentliche Ausdrücke gefunden.

Haskell, 48 43 Bytes

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

Die Verwendung erfolgt startHour % endHourmit beiden Eingaben im 24-Stunden-Format.

edit: @ xnors Verbesserung hinzugefügt, 5 Bytes gespart

C #, 73 Bytes

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

Zulässige Eingabe: ganze Zahlen im Bereich [0,23].

Diese Lösung verwendet kein LINQ.

Volles Programm mit Testfällen:

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

Jelly , 17 16 15 14 Bytes

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

TryItOnline

Wie?

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

Das Eingabeformat entspricht dem dritten Beispiel in der Challenge, dh zwei Zahlen im 24-Stunden-Format.

Probieren Sie es online!

Erläuterung

Nehmen Sie Eingaben 22, 10als Beispiel.

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

Eingabeformat '[1,24]' zwischen 1 und 24

Bei dieser Herausforderung hasse ich es, warum PHP gegen andere Sprachen locker ist. Ich zeige lieber alle meine Ideen. Vielleicht findet ein anderer PHP-Crack eine kürzere Lösung.

<?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 a way mit min und 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;

okay , diese verrückte Idee funktioniert mit einer Reihe 149 Bytes das Array füllt $y[0]und $y[1]wenn , $_GET["b"][0]<=$_GET["b"][1] wenn $y[1]ist nullkönnen wir dieses Array - Summen-array_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)));

Dies könnte bis 124 Bytes Golf gespielt werden

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

Jetzt können wir das Array mit nur zwei Ints verkleinern. 101 Bytes Machen Sie 2 Summen $x[0]und$x[1]

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

wenn $v=($f>$g dann add value to $x[$i<$f&$i>$g] else add value to $x[$i>=$f&$i<=$g] the output wird fallweise ermitteltecho$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];

Danach habe ich eine Möglichkeit gefunden, das Ergebnis direkt mit 112 Bytes zu berechnen

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

rekursive 103 Bytes

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

Die Listenextraktion wurde von Jörg Hülsermanns Antwort inspiriert, aber der Rest der Gemeinsamkeiten ist das Ergebnis einer konvergenten Entwicklung. Da es viel kürzer ist und die Bedingungen in der Schleife unterschiedlich sind, veröffentliche ich es als separate Antwort.

Nimmt Eingaben als 24-Stunden-Zeiten vor (gut mit 0 oder 24). Laufen Sie wie folgt:

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

Bearbeiten :

• -1 Byte aus. Vielen Dank an @ 1Darco1
• Fester Funktionskopf. +7 Bytes an.
• -2 Bytes aus. Vielen Dank an Kevin Cruijssen
• +2 Bytes an. Jetzt wird e/ clockinitialisiert.

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

Ungolfed:

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

Hier ist die Antwort, die nur die Gesamtzahl der Klingelzeichen ausgibt:

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

Die Eingabe ist im Bereich 1-24; aund bsind die Eingänge ( ::im Code), cverfolgt am / pm, dist die Gesamtzahl der Klingeltöne. Wenn wir alle Stunden heruntergezählt haben, wird _Xddas Programm beendet und dabei gedruckt d.

OK, ich habe die Frage falsch verstanden und dachte, der 1+2+3...=Text sei Teil der Ausgabe, also schrieb ich Folgendes:

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

Jetzt werde ich die richtige Antwort codieren ...

Pyth - 11 Bytes

s|R12%R12}F

Test Suite .

76 Bytes

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

Perl, 36 Bytes

Beinhaltet +1 für -p

Geben Sie die Start- und Endzeit im 24-Stunden-Format in einer Zeile in STDIN an:

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

Rekursive Methode basierend auf der Antwort von @ETHproductions auf Python 2 . Verwendet einen 24-Stunden-Takteingang.

Ungolfed & Testcode:

Probieren Sie es hier aus.

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

Ausgabe:

33
15
29
88
5

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

Bearbeiten: 77 Byte gespeichert, indem für die Antwort in ein geschlossenes Formular gewechselt wird.

• %1und %2sind die beiden Befehlszeilenparameter
• @ Deaktivieren Sie die Standardeinstellung von Batch, bei der der Befehl wiederholt wird
• cmd/c Fool Batch, um das Ergebnis der Berechnung sofort auszudrucken
• set/a Führen Sie eine numerische Berechnung durch
• x=(%1+23)%%24, Normalisieren Sie die Startstunde auf die Anzahl der Stunden seit 1:00 Uhr morgens (1:00 Uhr würde auch funktionieren, aber 11 ist nicht kürzer als 23).
• y=x+(%2+24-%1)%%24, Normalisieren Sie die Endstunde so, dass sie vor der Startstunde liegt, und fahren Sie gegebenenfalls mit dem nächsten Tag fort
• z=y%%12+1, Anzahl der Glocken, die zur Endstunde geschlagen wurden
• (y/12-x/12)*78+ Anzahl der Glocken aufgrund zusätzlicher halber Tage
• z*~-z/2- Anzahl der Glocken von 1 Uhr bis einschließlich der Endstunde
• (x%%=12) Eine weniger als die Anzahl der Glocken, die zur Startstunde geschlagen wurden
• *-~x/2 Anzahl der Glocken, die von 1 Uhr bis zur Startstunde geläutet worden wären, jedoch ohne Startstunde

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;

Es wird erwartet, dass die Eingabe beim Programmstart auf dem Stack vorhanden ist, also +2 Byte für das -vFlag. Die Eingabe besteht aus zwei Ganzzahlen, die die Stunde im 24-Stunden-Format 10am - 10pmangeben 10 22.

Probieren Sie es online!

Cubix , 45 44 Bytes

Dank @ETHproductions 1 Byte gespart

Mein erster Ausflug nach Cubix ...

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

Oder kubisch:

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

Sie können es am Online-Dolmetscher ausprobieren . Die Eingabe erfolgt im 24-Stunden-Format, wobei die Endzeit an erster Stelle steht. Zum Beispiel sollte der Eingang von 17.00 bis 01.00 Uhr sein 1 17.

Vorherige Version, 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

Es wäre so viel kürzer , wenn wir nicht zu unterstützen , haben pmzu am. Ich benutze Rekursion, um es zu unterstützen.

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

Probieren Sie es online aus

Ohne Unterstützung pmvon am(45 Bytes):

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