Giriş

Bir çan kulesi onun çan her saat, çalar nile, kez n12 saatlik biçimde geçerli saat olmak.

Örneğin, bir zil, saat 5'te 5 kez, saat 10'da 10 kez çalar.

Görev

Uygun bir biçimde iki kez verildiğinde, başlangıç ​​ve bitiş zamanları dahil olmak üzere zilin kaç kez çalacağını belirleyin

Örnekler

"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

Eğer başlangıç ​​son ile aynıysa, o zaman sadece o saat için çanlar sayısını çıkarmanız yeterlidir:

[5pm, 5pm]
5 = 5

Gördüğünüz gibi, bir giriş yöntemi seçebilirsiniz, ancak çıktının kendi başına (veya kabul edilebilir bir alternatif) izleyen / önde gelen yeni satırlara ve boşluklara izin verilen bir tam sayı olması gerekir.

Not:

• girdiler bir günün öğleden sonrasına kadar değişebilir.
• iki zaman arasındaki fark asla 24 saatten fazla olmayacak.
• Girdi biçiminin ne olduğunu açıkça belirttiğiniz sürece girdi esnektir.
• Girişiniz, AM ve PM arasında açık bir ayrım olmalıdır .

JavaScript (ES6), 38 35 bayt

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

Geçerli zil çalma sayısını toplamına art arda ekler. Gibi denilen f(11,15); gece yarısı olarak temsil edilir 24. ~-Hile parçası @ xnor'ın Python cevabından aldım .

Test snippet'i

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>

Özyinelemeli olmayan sürüm (Firefox 30+), 56 bayt

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

Aşağıdaki ES6 işlevine eşdeğer:

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

Python 2,46 bayt

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

JS cevabımı temel alıyor. Çözüm için özyinelemeli formül f şöyle tanımlanır:

1. İki tamsayı x ve y ile başlayın .
2. X 12 modunu alın ; bu 0 ise, 12 yerine.
3. Eğer x! = Y , sonucunu eklemek f (x + 1 mod 24, y) .

Python 2, 59 54 bayt

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 bayt

Emigna'dan çok yardımla .

-24%ݹ+<12%>O

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin!

Python, 42 bayt

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

Genişleyen 23'e 0 ile iki sayı alan bir özyinelemeli fonksiyon ~xiçin 's -x-1verir

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

İfadesi (a+1)%12+1halkalarının numaraya bir zaman dönüştürür 1için 12. Daha sonra, alt sınır modulo 24 arttırılır ve özyinelemeli sonuç için fonksiyon eklenir. Yani, şu anki saat bitiş saati değilse, bu durumda dururuz.

Bunun yerine tamamen aritmetik bir çözüm yazmaya çalışıyordum, ancak şu ana kadar sadece uzun ve dağınık ifadeler buldum.

Haskell, 48 43 bayt

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

Kullanım, startHour % endHour24 saatlik formatta verilen her iki girişle birliktedir.

düzenleme: eklenen @ xnor'ın iyileştirme, 5 bayt tasarrufu

C #, 73 bayt

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

Kabul edilebilir giriş: [0,23] aralığındaki tamsayılar.

Bu çözüm LINQ kullanmaz.

Test vakaları ile tam program:

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

Jöle , 17 16 15 14 bayt

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

TryItOnline

Nasıl?

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

yy>24*+&:12X\s

Giriş formatı, üçüncü örnekte olduğu gibi, 24 saatlik formatta iki sayıdır.

Çevrimiçi deneyin!

açıklama

Girdileri almak 22, 10bir örnek olarak.

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 Bayt

Giriş formatı '[1,24]' 1 ile 24 arasında

Bu meydan okumada PHP'nin neden diğer dillere karşı kaybedilmesinden nefret ediyorum. Tüm fikirlerimi göstermeyi tercih ederim. Belki başka bir PHP Crack daha kısa bir çözüm bulur.

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

<?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 Bayt, min ve maks ile bir yol

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

tamam bu çılgın fikri 149 Bayt dizi doldurur bir dizi ile çalışır $y[0]ve $y[1]eğer $_GET["b"][0]<=$_GET["b"][1] varsa $y[1]olduğunu nullbu diziyi özetleyebilirimarray_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)));

Bu 124 Bytes golf oynayabilir

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

Şimdi bu noktada diziyi sadece iki inç ile azaltabiliriz 101 Bayt 2 toplamı yap $x[0]ve$x[1]

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

eğer $v=($f>$g öyleyse değere $x[$i<$f&$i>$g] başka bir değer $x[$i>=$f&$i<=$g] katarsa ​​çıktıya değer katar , duruma göre bulunurecho$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];

Bundan sonra doğrudan sonucu 112 Bytes hesaplamak için bir yol buldum

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

özyinelemeli 103 Bayt

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

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

Liste çıkarma, Jörg Hülsermann'ın cevabından ilham aldı ancak benzerliklerin geri kalanı yakınsak evrimin bir sonucudur ve oldukça kısa olduğundan ve döngüdeki şartlamalar ayrı bir cevap olarak gönderiyorum.

Girişi 24 saat kez alır (0 veya 24 ile ince). Gibi koş:

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 bayt

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

Düzenle :

• -1 bayt kapalı. @ 1Darco1 sayesinde
• Sabit fonksiyon başlığı. +7 bayt açık.
• -2 bayt kapalı. @Kevin Cruijssen 'e teşekkürler
• +2 bayt açık. Şimdi e/ clockbaşlatıldı.

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

Yani, işte cevap sadece toplam zil sayısını yazdırıyor:

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

Giriş menzilde 1-24; ave bgirişler ( ::kodda), cam / pm öğelerini tutar d, toplam çalma sayısıdır. Tüm saatleri saydığımızda _Xd, programı sonlandırıyor d, işlemi yazdırıyor .

Tamam, soruyu yanlış anladım ve 1+2+3...=metnin çıktının bir parçası olduğunu düşündüm.

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

Şimdi uygun cevabı kodlayacağım ...

Pyth - 11 bayt

s|R12%R12}F

Test Takımı .

C #, 76 bayt

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

Perl, 36 bayt

İçin +1 içerir -p

Her biri STDIN'de bir satırda 24 saatlik biçimde başlangıç ​​ve bitiş zamanı verin:

toll.pl
11
15
^D

toll.pl:

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

Java 7, 64 bayt

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

@ETHproductions'un Python 2 cevabını temel alan özyinelemeli yöntem . 24 saatlik bir saat girişi kullanır.

Ungolfed ve test kodu:

Burada dene.

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

Çıktı:

33
15
29
88
5

Toplu iş, 168 91 bayt

@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

Düzenleme: Cevap için kapalı bir forma geçerek 77 bayt kaydedildi.

• %1ve %2iki komut satırı parametresidir
• @ Komutu tekrarlamak için Toplu İş varsayılanını devre dışı bırakın
• cmd/c Toplu hesaplamanın sonucunu derhal yazdırmak için
• set/a Sayısal bir hesaplama yapın
• x=(%1+23)%%24, Başlangıç ​​saatini 01: 00’dan bu yana geçen saat sayısı olacak şekilde normalize edin (1 PM de çalışır, ancak 11 23’den kısa değildir)
• y=x+(%2+24-%1)%%24, Bitiş saatini başlangıç ​​saatinden önce olacak şekilde normalleştirin, gerekirse sonraki güne ilerleyin
• z=y%%12+1, Bitiş saatinde vurulan çan sayısı
• (y/12-x/12)*78+ Fazladan yarım gün nedeniyle çan sayısı
• z*~-z/2- Saat 1'den bitiş saatine kadar geçen zillerin sayısı
• (x%%=12) Başlangıç ​​saatinde gerçekleşen çanlar sayısından az
• *-~x/2 Saat 1'den başlangıç ​​saatine kadar vurulan zillerin sayısı, ancak başlangıç ​​saati dahil değil

C, 56 Bayt

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

> <> , 48 + 2 = 50 bayt

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

Girişte program başlangıcında yığında bulunması beklenir, bu nedenle -vbayrak için +2 bayt . Girdi 24 saatlik biçimde saat belirterek iki tamsayı, yani 10am - 10pmolarak verilir 10 22.

Çevrimiçi deneyin!

Cubix , 45 44 bayt

@ETHproductions sayesinde 1 bayt kaydedildi

Cubix'e ilk baskınım ...

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

Veya cubified:

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

Online tercümanda deneyebilirsiniz . Giriş 24 saat biçimindedir, bitiş zamanı ilkdir. Örneğin, 5: 00-01: 00 arasında giriş yapılmalıdır 1 17.

Önceki sürüm, 45 bayt:

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

Qbasic, 112 bayt

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 bayt

Biz desteklemek zorunda olmasaydı bu kadar kısa olacağını pmetmek am. Desteklemek için özyineleme kullanıyorum.

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

Çevrimiçi deneyin

Destek olmadan pmiçin am(45 bayt):

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