Giới thiệu

Một tháp chuông sẽ rung chuông mỗi giờ, nlần, với ngiờ hiện tại trên đồng hồ 12 giờ.

Ví dụ, một tiếng chuông sẽ vang lên 5 lần vào lúc 5 giờ chiều và 10 lần vào lúc 10 giờ sáng.

Bài tập

Cho hai lần trong một định dạng phù hợp, xuất ra số lần chuông sẽ reo, bao gồm thời gian bắt đầu và kết thúc

Ví dụ

"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

Nếu bắt đầu giống như kết thúc thì bạn chỉ cần đưa ra số lượng chuông cho giờ đó:

[5pm, 5pm]
5 = 5

Như bạn có thể thấy, bạn có thể chọn một phương thức nhập liệu nhưng đầu ra phải là một số nguyên trên chính nó (hoặc một sự thay thế có thể chấp nhận) theo dõi / dòng mới và khoảng trắng được cho phép.

Chú thích:

• đầu vào có thể kéo dài từ chiều của một ngày đến sáng hôm sau.
• sự khác biệt giữa hai lần sẽ không bao giờ quá 24 giờ.
• đầu vào là linh hoạt miễn là bạn nói rõ định dạng đầu vào của bạn là gì.
• đầu vào của bạn phải có sự phân biệt rõ ràng giữa AM và PM.

JavaScript (ES6), 38 35 byte

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

Đệ quy thêm số chuông hiện tại vào tổng số. Gọi như thế f(11,15); nửa đêm được đại diện là 24. Tôi đã nhận được một phần của ~-mẹo từ câu trả lời Python của @ xnor .

Kiểm tra đoạn

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>

Phiên bản không đệ quy (Firefox 30+), 56 byte

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

Tương đương với chức năng ES6 sau:

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

Dựa trên câu trả lời JS của tôi. Công thức đệ quy f cho giải pháp được định nghĩa như sau:

1. Bắt đầu với hai số nguyên x và y .
2. Lấy x mod 12 ; nếu đây là 0, hãy lấy 12 thay thế.
3. Nếu x! = Y , thêm kết quả của 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

Với rất nhiều sự giúp đỡ từ Emigna .

-24%ݹ+<12%>O

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến!

Python, 42 byte

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

Hàm đệ quy lấy hai số từ 0 đến 23. Mở rộng ~x's để -x-1cung cấp

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

Khái niệm (a+1)%12+1chuyển đổi một thời gian để số lượng nhẫn 1để 12. Sau đó, giới hạn dưới được tăng modulo 24 và hàm cho kết quả đệ quy được thêm vào. Đó là, trừ khi giờ hiện tại là giờ kết thúc, trong trường hợp đó chúng ta dừng lại.

Thay vào đó, tôi đã cố gắng viết một giải pháp hoàn toàn hợp lý, nhưng cho đến nay tôi chỉ tìm thấy những biểu hiện dài và lộn xộn.

Haskell, 48 43 byte

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

Việc sử dụng là startHour % endHour, với cả hai đầu vào được đưa ra ở định dạng 24 giờ.

chỉnh sửa: đã thêm cải tiến của @ xnor, tiết kiệm 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;}};

Đầu vào chấp nhận được: số nguyên trong phạm vi [0,23].

Giải pháp này không sử dụng LINQ.

Chương trình đầy đủ với các trường hợp thử nghiệm:

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

Thạch , 17 16 15 14 byte

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

Dùng thử

Làm sao?

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

Định dạng đầu vào như trong ví dụ thứ ba trong thử thách, nghĩa là hai số ở định dạng 24 giờ.

Hãy thử trực tuyến!

Giải trình

Lấy đầu vào 22, 10làm ví dụ.

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 byte

Định dạng đầu vào '[1,24]' trong khoảng từ 1 đến 24

Trong thử thách này, tôi ghét tại sao PHP lại chống lại các ngôn ngữ khác. Tôi thích thể hiện tất cả các ý tưởng của tôi. Có thể một PHP Crack khác tìm thấy một giải pháp ngắn hơn.

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

<?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 Byte một cách với tối thiểu và tối đa

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

được rồi, ý tưởng điên rồ này hoạt động với một mảng 149 Byte lấp đầy mảng $y[0]và $y[1]nếu $_GET["b"][0]<=$_GET["b"][1] có $y[1]thì nullchúng ta có thể tính tổng mảng này khôngarray_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)));

Điều này có thể được đánh xuống 124 Byte

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

Bây giờ tại thời điểm này, chúng ta có thể giảm mảng chỉ với hai int 101 Byte Tạo 2 tổng $x[0]và$x[1]

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

nếu $v=($f>$g sau đó thêm giá trị cho $x[$i<$f&$i>$g] người khác thêm giá trị cho $x[$i>=$f&$i<=$g] đầu ra sẽ được tìm thấy theo trường hợpecho$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];

Sau đó tôi đã tìm được cách tính kết quả trực tiếp 112 Byte

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

đệ quy 103 byte

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

Việc trích xuất danh sách được lấy cảm hứng từ câu trả lời của Jörg Hülsermann nhưng phần còn lại của những điểm tương đồng là kết quả của quá trình tiến hóa hội tụ và bởi vì nó khá ngắn hơn và các điều kiện trong vòng lặp đủ khác nhau nên tôi đăng nó như một câu trả lời riêng biệt.

Mất đầu vào là 24 giờ (tốt với 0 hoặc 24). Chạy như sau:

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

Chỉnh sửa :

• -1 byte tắt. Cảm ơn @ 1Darco1
• Đầu cố định chức năng. +7 byte trên.
• Tắt 2 byte. Cảm ơn @Kevin Cruijssen
• +2 byte trên. Bây giờ e/ clockđược khởi tạo.

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

Ung dung:

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

Vì vậy, đây là câu trả lời chỉ in tổng số chuông reo:

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

Đầu vào là trong phạm vi 1-24; avà blà các đầu vào ( ::trong mã), ctheo dõi sáng / chiều, dlà tổng số vòng. Khi chúng tôi đếm ngược tất cả các giờ, _Xdchấm dứt chương trình, in dtrong quy trình.

OK, tôi đã hiểu nhầm câu hỏi và nghĩ rằng 1+2+3...=văn bản là một phần của đầu ra, vì vậy tôi đã viết rằng:

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

Bây giờ, tôi sẽ viết mã câu trả lời thích hợp ...

Pyth - 11 byte

s|R12%R12}F

Phòng thử nghiệm .

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

Bao gồm +1 cho -p

Cung cấp thời gian bắt đầu và kết thúc ở định dạng 24 giờ trên mỗi dòng trên 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);}

Phương pháp đệ quy dựa trên câu trả lời Python 2 của @ETHproductions . Sử dụng đầu vào đồng hồ 24 giờ.

Mã thử nghiệm & mã hóa:

Hãy thử nó ở đây.

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

Đầu ra:

33
15
29
88
5

Hàng loạt, 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

Chỉnh sửa: Đã lưu 77 byte bằng cách chuyển sang dạng đóng cho câu trả lời.

• %1và %2là hai tham số dòng lệnh
• @ Vô hiệu hóa mặc định của Batch để lặp lại lệnh
• cmd/c Đánh lừa hàng loạt ngay lập tức in kết quả tính toán
• set/a Thực hiện tính toán số
• x=(%1+23)%%24, Bình thường hóa giờ bắt đầu là số giờ kể từ 1AM (1PM cũng sẽ hoạt động, nhưng 11 không ngắn hơn 23)
• y=x+(%2+24-%1)%%24, Bình thường hóa giờ kết thúc để đi trước giờ bắt đầu, tiến tới ngày tiếp theo nếu cần thiết
• z=y%%12+1, Số tiếng chuông vang lên vào giờ kết thúc
• (y/12-x/12)*78+ Số lượng chuông do thêm nửa ngày
• z*~-z/2- Số lượng chuông từ 1 giờ đến hết giờ kết thúc
• (x%%=12) Một ít hơn số lượng chuông đã đánh vào giờ bắt đầu
• *-~x/2 Số lượng chuông sẽ được đánh từ 1 giờ đến giờ bắt đầu, nhưng không bao gồm giờ bắt đầu

C, 56 byte

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;

Đầu vào dự kiến ​​sẽ có mặt trên ngăn xếp khi bắt đầu chương trình, vì vậy +2 byte cho -vcờ. Đầu vào là hai số nguyên chỉ định giờ trên đồng hồ 24 giờ, do đó 10am - 10pmsẽ được cung cấp dưới dạng 10 22.

Hãy thử trực tuyến!

Khối , 45 44 byte

Đã lưu 1 byte, nhờ @ETHproductions

Bước đột phá đầu tiên của tôi vào Cubix ...

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

Hoặc, được lập phương:

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

Bạn có thể dùng thử tại phiên dịch trực tuyến . Đầu vào ở định dạng 24 giờ, với thời gian kết thúc đầu tiên. Ví dụ: từ 5 giờ chiều đến 1 giờ sáng, đầu vào phải là 1 17.

Phiên bản trước, 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

Nó sẽ là ngắn hơn rất nhiều nếu chúng ta không phải hỗ trợ pmđể am. Tôi sử dụng đệ quy để hỗ trợ nó.

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

Dùng thử trực tuyến

Nếu không có hỗ trợ pmcho am(45 byte):

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