介绍

钟楼会响每小时其铃铛，n倍，n是在12小时的时钟的当前小时。

例如，响铃将在下午5点响5次，在上午10点响10次。

任务

以适当的格式给出两次提示，输出铃声响起的次数，包括开始和结束时间

例子

"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

如果开始与结束相同，那么您只需输出该小时的铃声数即可：

[5pm, 5pm]
5 = 5

如您所见，您可以选择一种输入法，但输出本身必须是整数（或可接受的替代方法），允许尾随/前导换行符和空格。

注意：

• 输入时间可能从一天的下午到第二天的早晨。
• 两次之间的时间差不会超过24小时。
• 输入很灵活，只要您清楚说明输入格式是什么即可。
• 您的输入必须清楚地区分AM和PM。

JavaScript（ES6），38 35字节

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

递归将当前响铃次数添加到总数中。叫样f(11,15); 午夜表示为24。我~-从@xnor的Python answer中获得了一些技巧。

测试片段

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>

非递归版本（Firefox 30 +），56个字节

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

等效于以下ES6功能：

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

Python 2，46个字节

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

基于我的JS答案。解决方案的递归公式f定义如下：

1. 以两个整数x和y开头。
2. 以x mod 12 ; 如果为0，则取12。
3. 如果x！= y，则将f（x + 1 mod 24，y）的结果相加。

Python 2，59 54字节

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个字节

在Emigna的帮助下。

-24%ݹ+<12%>O

使用CP-1252编码。在线尝试！

Python，42个字节

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

递归函数，它接受从0两个数字到23扩大~x的以-x-1给出

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

表达(a+1)%12+1一个时间转换成环的数目1来12。然后，下限以模24递增，并添加了递归结果的函数。也就是说，除非当前时间是结束时间，否则我们将停止。

我一直在尝试编写一个纯粹的算术解决方案，但是到目前为止，我只发现了冗长且混乱的表达式。

Haskell，48个 43字节

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

用法为startHour % endHour，两个输入均以24小时格式给出。

编辑：添加了@xnor的改进，节省了5个字节

C＃，73个字节

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

可接受的输入：[0,23]范围内的整数。

此解决方案不使用LINQ。

完整的测试用例程序：

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

果冻，17 16 15 14 字节

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

在线试用

怎么样？

>×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个字节

yy>24*+&:12X\s

输入格式与挑战中的第三个示例一样，即两个24小时制的数字。

在线尝试！

说明

取输入22，10作为一个例子。

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字节

输入格式'[1,24]'在1到24之间

在这个挑战中，我讨厌PHP为什么不能与其他语言相对比。我更喜欢展示我所有的想法。也许另一个PHP Crack可以找到一个更短的解决方案。

<?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字节

<?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字节

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

还好这个疯狂的想法时用一个阵列149个字节填充阵列$y[0]和$y[1]如果$_GET["b"][0]<=$_GET["b"][1] ，如果$y[1]是null我们可以总结这个数组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)));

这可以打倒124字节

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

现在，在这一点上，我们可以只用两个int 101 Bytes来简化数组，求2 $x[0]和$x[1]

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

如果$v=($f>$g 然后将值添加到$x[$i<$f&$i>$g] 其他值，$x[$i>=$f&$i<=$g] 则将根据情况找到输出的值echo$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];

之后，我找到了一种直接计算结果的方法112字节

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

递归103字节

<?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字节

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

列表提取的灵感来自JörgHülsermann的答案，但其余相似之处是融合进化的结果，因为它的长度要短得多，循环中的条件也足够不同，因此我将其发布为单独的答案。

输入时间为24小时（可使用0或24进行细化）。运行像：

php -r "list(,$i,$a)=$argv;for($a+=$i>$a?24:0;$i<=$a;)$n+=$i++%12?:12;echo$n;" 9 18

爪哇，72 71 78 76字节

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

编辑：

• -1字节关闭。感谢@ 1Darco1
• 固定功能头。 +7个字节。
• -2个字节。感谢@Kevin Cruijssen
• +2个字节。现在e/ clock已初始化。

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

取消高尔夫：

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字节

因此，这是仅打印铃响总数的答案：

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

输入范围内1-24; a和b是输入（::在代码中），c跟踪am / pm，d是响铃总数。当我们计算完所有时间后，_Xd终止程序，打印d在过程中进行。

好的，我误解了这个问题，并认为1+2+3...=文本是输出的一部分，所以我这样写：

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

现在，我将编码正确的答案...

Pyth-11个字节

s|R12%R12}F

测试套件。

C＃，76个字节

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

Perl，36个字节

包括+1的 -p

在STDIN的每一行上以24小时格式给出开始和结束时间：

toll.pl
11
15
^D

toll.pl：

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

Java 7，64个字节

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

基于递归的方法 @ETHproductions的Python 2答案的。使用24小时制时钟输入。

取消测试的代码：

在这里尝试。

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

输出：

33
15
29
88
5

批处理，168 91字节

@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

编辑：通过切换为答案的封闭形式保存了77个字节。

• %1和%2是两个命令行参数
• @ 禁用批处理的默认值，即回显命令
• cmd/c 傻瓜批处理立即打印计算结果
• set/a 执行数值计算
• x=(%1+23)%%24, 将开始时间标准化为从1AM开始的小时数（也可以使用1PM，但11不少于23）
• y=x+(%2+24-%1)%%24, 将结束时间标准化为开始时间之前的时间，如有必要，前进至第二天
• z=y%%12+1, 结束钟声敲响的次数
• (y/12-x/12)*78+ 半天后响铃的次数
• z*~-z/2- 从1点钟到结束时间的钟声数量
• (x%%=12) 比开始钟声敲响的钟声少一圈
• *-~x/2 从1点钟到开始时间的钟声数量，但不包括开始时间

C，56字节

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

> <>，48 + 2 = 50字节

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

程序启动时，预计输入将出现在堆栈上，因此该-v标志为+2字节。输入的是两个整数，用于指定24小时制的小时，因此10am - 10pm将指定为10 22。

在线尝试！

Cubix，45 44字节

由于@ETHproductions，节省了1个字节

我第一次尝试Cubix ...

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

或者，陈词滥调：

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

您可以在在线解释器中试用。输入为24小时格式，首先是结束时间。例如，从5pm到1am输入应该为1 17。

先前版本，45个字节：

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

Qbasic，112字节

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个字节

这将是如此短得多，如果我们没有支持pm到am。我使用递归来支持它。

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

在线尝试

无支撑pm到am（45个字节）：

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