pengantar

Menara lonceng akan membunyikan bel setiap jam, nkali, dengan nmenjadi jam saat ini pada jam 12 jam.

Misalnya, bel akan berdering 5 kali pada jam 5 sore, dan 10 kali pada jam 10 pagi.

Tugas

Diberikan dua kali dalam format yang sesuai, menampilkan berapa kali bel akan berdering, termasuk waktu mulai dan akhir

Contohnya

"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

Jika awal sama dengan akhir maka Anda hanya cukup jumlah lonceng untuk jam itu:

[5pm, 5pm]
5 = 5

Seperti yang Anda lihat, Anda dapat memilih metode input tetapi output harus berupa bilangan bulat sendiri (atau alternatif yang dapat diterima) mengikuti / memimpin baris baru dan spasi diizinkan.

catatan:

• input dapat berkisar dari sore hari sampai pagi hari berikutnya.
• perbedaan antara dua kali tidak akan pernah lebih dari 24 jam.
• input fleksibel selama Anda jelas menyatakan apa format input Anda.
• input Anda harus memiliki perbedaan yang jelas antara AM dan PM.

JavaScript (ES6), 38 35 byte

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

Secara rekursif menambahkan jumlah bel berbunyi saat ini ke total. Disebut seperti f(11,15); tengah malam direpresentasikan sebagai 24. Saya mendapat bagian dari ~-trik dari jawaban Python @ xnor .

Cuplikan tes

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 non-rekursif (Firefox 30+), 56 byte

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

Setara dengan fungsi ES6 berikut:

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

Python 2, 46 byte

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

Berdasarkan jawaban JS saya. Rumus rekursif f untuk solusi didefinisikan sebagai:

1. Mulai dengan dua bilangan bulat x dan y .
2. Ambil x mod 12 ; jika ini 0, ambil 12 sebagai gantinya.
3. Jika x! = Y , tambahkan hasil f (x + 1 mod 24, y) .

Python 2, 59 54 byte

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 byte

Dengan banyak bantuan dari Emigna .

-24%ݹ+<12%>O

Menggunakan pengkodean CP-1252 . Cobalah online!

Python, 42 byte

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

Sebuah fungsi rekursif yang mengambil dua angka 0 sampai 23. Memperluas ~x's untuk -x-1memberikan

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

Ekspresi (a+1)%12+1mengubah waktu ke jumlah dering 1ke 12. Kemudian, batas bawah ditambah modulo 24 dan fungsi untuk hasil rekursif ditambahkan. Yaitu, kecuali jam saat ini adalah jam akhir, dalam hal ini kita berhenti.

Saya telah mencoba untuk menulis solusi aritmatika murni, tetapi sejauh ini saya hanya menemukan ekspresi yang panjang dan berantakan.

Haskell, 48 43 byte

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

Penggunaannya adalah startHour % endHour, dengan kedua input diberikan dalam format 24 jam.

sunting: menambahkan peningkatan @ xnor, menghemat 5 byte

C #, 73 byte

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

Input yang dapat diterima: bilangan bulat dalam kisaran [0,23].

Solusi ini tidak menggunakan LINQ.

Program lengkap dengan uji kasus:

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 byte

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

TryItOnline

Bagaimana?

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

yy>24*+&:12X\s

Format input seperti pada contoh ketiga dalam tantangan, yaitu dua angka dalam format 24 jam.

Cobalah online!

Penjelasan

Ambil input 22, 10sebagai contoh.

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

Masukkan format '[1,24]' antara 1 dan 24

Dalam tantangan ini saya benci mengapa PHP kalah terhadap bahasa lain. Saya lebih suka menunjukkan semua ide saya. Mungkin PHP Crack lain menemukan solusi yang lebih pendek.

<?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 dengan min dan maks

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

oke ide gila ini bekerja dengan array 149 Bytes mengisi array $y[0]dan $y[1]jika $_GET["b"][0]<=$_GET["b"][1] jika $y[1]adalah nullkita dapat meringkas array iniarray_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)));

Ini bisa diturunkan 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]);

Sekarang pada titik ini kita dapat mengurangi array dengan hanya dua ints, 101 Bytes, buat 2 jumlah $x[0]dan$x[1]

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

jika $v=($f>$g kemudian menambahkan nilai ke nilai tambah yang $x[$i<$f&$i>$g] lain untuk $x[$i>=$f&$i<=$g] output akan ditemukan oleh kasusecho$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];

Setelah itu saya menemukan cara untuk menghitung hasilnya secara langsung 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;

rekursif 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 byte

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

Ekstraksi daftar diilhami oleh jawaban Jörg Hülsermann tetapi kesamaan lainnya adalah hasil dari evolusi konvergen dan karena itu jauh lebih pendek dan persyaratan dalam loop cukup berbeda, saya mempostingnya sebagai jawaban terpisah.

Dimasukkan input sebagai 24 jam kali (baik dengan 0 atau 24). Jalankan seperti:

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 byte

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

Edit :

• -1 byte mati. Terima kasih kepada @ 1Darco1
• Fungsi kepala tetap. +7 byte aktif.
• Off -2 byte. Terima kasih kepada @Kevin Cruijssen
• +2 byte aktif. Sekarang e/ clockdiinisialisasi.

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

Tidak Disatukan:

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 byte

Jadi, inilah jawaban yang hanya mencetak jumlah bel-dering:

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

Input dalam jangkauan 1-24; adan binput ( ::dalam kode), cmelacak am / pm, dadalah jumlah total dering. Ketika kami telah menghitung mundur semua jam, _Xdmenghentikan program, mencetak ddalam proses.

OK, saya salah paham pertanyaan dan menganggap 1+2+3...=teks itu bagian dari output, jadi saya menulis bahwa:

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

Sekarang, saya akan menuliskan kode jawaban yang tepat ...

Pyth - 11 byte

s|R12%R12}F

Test Suite .

C #, 76 byte

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

Perl, 36 byte

Termasuk +1 untuk -p

Berikan waktu mulai dan berakhir dalam format 24 jam pada setiap baris di STDIN:

toll.pl
11
15
^D

toll.pl:

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

Java 7, 64 byte

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

Metode rekursif berdasarkan pada @ETHproductions jawaban Python 2 . Menggunakan input jam 24 jam.

Tidak digabungkan & kode uji:

Coba di sini.

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

Keluaran:

33
15
29
88
5

Batch, 168 91 byte

@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

Sunting: Disimpan 77 byte dengan beralih ke formulir tertutup untuk jawabannya.

• %1 dan %2 merupakan dua parameter baris perintah
• @ Nonaktifkan Batch's default yaitu untuk mengulang perintah
• cmd/c Menipu Batch ke segera mencetak hasil perhitungan
• set/a Lakukan perhitungan numerik
• x=(%1+23)%%24, Normalisasi jam awal menjadi jumlah jam sejak 01:00 (13:00 juga akan bekerja, tetapi 11 tidak lebih pendek dari 23)
• y=x+(%2+24-%1)%%24, Normalisasi jam berakhir lebih cepat dari jam awal, naik ke hari berikutnya jika perlu
• z=y%%12+1, Jumlah bel terdengar pada jam terakhir
• (y/12-x/12)*78+ Jumlah lonceng karena tambahan setengah hari
• z*~-z/2- Jumlah bel mulai dari jam 1 hingga jam berakhir termasuk
• (x%%=12) Satu kurang dari jumlah bel yang terdengar pada jam awal
• *-~x/2 Jumlah lonceng yang akan dipukul dari jam 1 ke jam mulai, tetapi tidak termasuk jam awal

C, 56 Bytes

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

> <> , 48 + 2 = 50 byte

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

Input diharapkan ada pada stack saat program dimulai, jadi +2 byte untuk -vflag. Input adalah dua bilangan bulat yang menentukan jam pada jam 24 jam, jadi 10am - 10pmakan diberikan sebagai 10 22.

Cobalah online!

Cubix , 45 44 byte

Disimpan 1 byte, terima kasih kepada @ETHproductions

Terjun pertama saya ke Cubix ...

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

Atau, kubus:

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

Anda dapat mencobanya di juru bahasa online . Input dalam format 24 jam, dengan waktu akhir pertama. Misalnya, mulai jam 17:00 hingga 01:00 input seharusnya 1 17.

Versi sebelumnya, 45 byte:

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

Qbasic, 112 byte

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 byte

Ini akan jauh lebih pendek jika kita tidak harus mendukung pmuntuk am. Saya menggunakan rekursi untuk mendukungnya.

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

Cobalah online

Tanpa mendukung pmke am(45 byte):

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