Wie oft klingelt ein Glockenturm?

24

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.
Shaun Wild
quelle
2
Wählen wir unsere eigene Eingabemethode oder muss sie alle genannten unterstützen?
anonymous2
1
Sie können die Eingabemethode wählen
Shaun Wild
1
Sie sollten klarer machen, dass die Eingaben von pmbis gehen können amund somit auf einen zweiten Tag übergehen.
mbomb007
3
Wird Mitternacht als 0 oder 24 angegeben?
xnor
4
Wir empfehlen die Verwendung der Sandbox , um Probleme mit Herausforderungen zu lösen, bevor sie auf der Hauptseite veröffentlicht werden.
Mego

Antworten:

12

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

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
ETHproductions
quelle
7

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) .
ETHproductions
quelle
6

Python 2, 59 54 Bytes

a=lambda x,y:sum(1+i%12for i in range(x-1,y+24*(x>y)))
Gleichwertig
summ=0
if start > end:
    end+=24
for hour in range(start-1,end):
    summ +=1+hour%12
print summ
Stange
quelle
3
Ich denke, du brauchst das a=Teil nicht.
Acrolith
@daHugLenny es muss eine vollständige (nutzbare) Funktion sein
Rod
(y + 24)% 24 ist nur y
Vladimir Cravero
1
@ Rod Du brauchst nicht a=. Es darf ein reines Lambda sein.
Yytsi
1
@VladimirCravero Natürlich nicht. Es ist dasselbe wie y%24.
Erik the Outgolfer
3

05AB1E , 13 Bytes

Mit viel Hilfe von Emigna .

-24%ݹ+<12%>O

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

Adnan
quelle
3

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.

xnor
quelle
Ah, ich verstehe: Es ist im Grunde die gleiche Technik wie meine Python-Antwort, aber mit einer wirklich geschickten Art, um die herumzukommen or. Schön!
ETHproductions
3

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

Nick Hansen
quelle
Anstatt den eZeitpunkt zu ändern e<s, können Sie den Bereich filtern s%e=sum[mod(x-1)12+1|x<-[s..e+24],x<=e||s>e]. Es speichert dann ein Byte zu Verschiebung von 1 x nach unten: 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;}};

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
        }
    }
}
adrianmp
quelle
3

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
Jonathan Allan
quelle
2

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
Luis Mendo
quelle
2

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);
Jörg Hülsermann
quelle
2

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
user59178
quelle
$i>$a?24:0hat die gleiche Länge wie ($i>$a)*24 wiki.php.net/rfc/short_list_syntax Vielleicht möchten Sie die Shortlist-Syntax verwenden, die neu in [$x,$i,$a]=$argv;7.1-2 Bytes ist. Bevor ich nicht getestet habe, würde ich sie nicht verwenden. Jetzt hasse ich mich mehr, als ich es auf diese Weise gefunden habe.
Jörg Hülsermann
danke, ich wusste über die bevorstehende Syntax der kurzen Liste Bescheid, aber da PHP 7.1 noch nicht ordnungsgemäß veröffentlicht wurde (noch auf Release Candidate 3 zum Zeitpunkt des Schreibens), nahm ich an, dass es in PPCG-Antworten noch nicht zulässig war.
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

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;
}
Roman Gräf
quelle
Wo definieren Sie aund dund b? Die vollständige Methode ist sinnvoll, aber ich denke, Sie müssen sich Ihr Golf-Lambda noch einmal ansehen und tatsächlich versuchen, es auszuführen, es sei denn, ich vermisse ernsthaft etwas. Für weiteres Golfen: (time+1)kann werden ++time.
1Darco1
Es liegt ein Fehler im Golfteil vor: Sollte a+=a?sein b+=a?. Sie können auch 2 Bytes Golf spielen, indem Sie die whilein eine körperlose for(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;}
umwandeln
Es tut uns leid. Ich habe diesen Ansatz von meinem Handy aus geschrieben und konnte ihn nicht testen. Fest. :)
Roman Gräf
1

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

steenbergh
quelle
1

Pyth - 11 Bytes

s|R12%R12}F

Test Suite .

Maltysen
quelle
2
Dies zählt nicht um Mitternacht, 23, 1gibt beispielsweise aus , 144wann es ausgegeben werden soll 24. (Ein solcher Fall sollte natürlich in den Tests sein!)
Jonathan Allan
1

76 Bytes

(a,b)=>Enumerable.Range(a,Math.Abs(b-a)+1).Select(n=>n%12==0?12:n%12).Sum();
downrep_nation
quelle
Das sieht nicht so aus, als würde es um Mitternacht herumlaufen.
Neil
Alle Testfälle sind erfolgreich
downrep_nation
Das habe ich nicht gefragt.
Neil
Welcher Ihrer Testfälle schlägt mit meiner Implementierung fehl?
downrep_nation
a=23und b=0scheint das offensichtlichste Beispiel zu sein.
Neil
1

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}{
Tonne Hospel
quelle
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);}

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
Kevin Cruijssen
quelle
1

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
Neil
quelle
1

C 56 Bytes

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

quelle
1

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

Sok
quelle
@ LuisMendo Danke, es ist jetzt behoben
Sok
1

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$@.;
Sok
quelle
1
Danke, dass du meine Sprache benutzt und tolle Arbeit geleistet hast :-) Ich sehe eine hast kleines Byte, das du sparen kannst, indem du es leicht neu )$424tU4OI0Iuq;;-!^;^%&21u+rr;ss!;sqU>&%r$@;
anordnest
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
anonymous2
quelle
Sollten Sie nicht 12 ausgeben, wenn sowohl Start- als auch Endstunde Null sind?
Neil
0

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