एक घंटी टॉवर की अंगूठी कितनी बार होगी?

24

परिचय

एक घंटी टॉवर हर घंटे, 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

जैसा कि आप देख सकते हैं, आप एक इनपुट विधि का चयन कर सकते हैं, लेकिन आउटपुट अपने आप में एक पूर्णांक होना चाहिए (या एक स्वीकार्य विकल्प) अनुगामी / अग्रणी newlines और रिक्त स्थान की अनुमति है।

ध्यान दें:

  • इनपुट एक दिन की दोपहर से अगली सुबह तक हो सकते हैं।
  • दो समय के बीच का अंतर कभी भी 24 घंटे से अधिक नहीं होगा।
  • इनपुट इतना लचीला है कि आप स्पष्ट रूप से बता सकते हैं कि आपका इनपुट किस प्रारूप में है।
  • आपके इनपुट में AM और PM के बीच स्पष्ट अंतर होना चाहिए ।
code-golf  clock 
— शॉन वाइल्ड
स्रोत
2
क्या हम अपनी स्वयं की इनपुट विधि चुनते हैं, या क्या इसमें सभी उल्लेखों का समर्थन करना है?
— अनाम
1
आप इनपुट विधि चुन सकते हैं
— शॉन वाइल्ड
1
आप इसे और अधिक स्पष्ट है कि आदानों से जा सकते हैं बनाना चाहिए pmकरने के लिए amइस प्रकार एक 2 दिन के लिए पार।
— mbomb007
3
क्या आधी रात को 0 या 24 के रूप में दिया जाएगा?
— xnor
4
हम सैंडबॉक्स के उपयोग को प्रोत्साहित करते हैं कि वे किसी भी मुद्दे को मुख्य साइट पर पोस्ट करने से पहले चुनौतियों का सामना कर सकें।
— मेगो

जवाबों:

12

जावास्क्रिप्ट (ईएस 6), 38 35 बाइट्स

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

पुनरावर्ती कुल में घंटी के छल्ले की वर्तमान संख्या को जोड़ता है। जैसे पुकारा गया f(11,15); आधी रात के रूप में प्रतिनिधित्व किया है 24। मुझे @ xnor के पायथन उत्तर~- से चाल का हिस्सा मिला ।

टेस्ट स्निपेट

कोड स्निपेट दिखाएं

गैर-पुनरावर्ती संस्करण (फ़ायरफ़ॉक्स 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
— ETHproductions
स्रोत
7

पायथन 2, 46 बाइट्स

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

मेरे जेएस जवाब के आधार पर। पुनरावर्ती सूत्र च समाधान के लिए इतनी के रूप में परिभाषित किया गया है:

  1. दो पूर्णांक x और y से शुरू करें ।
  2. एक्स मॉड 12 लें ; यदि यह 0 है, तो इसके बजाय 12 लें ।
  3. यदि x! = Y , f (x + 1 mod 24, y) का परिणाम जोड़ें ।
— ETHproductions
स्रोत
6

पायथन 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
— छड़ी
स्रोत
3
मुझे लगता है कि आपको a=भाग की आवश्यकता नहीं है ।
— एक्रोलिथ
@daHugLenny को एक पूर्ण (प्रयोग करने योग्य) कार्य होने की आवश्यकता है
— रॉड
(y + 24)% 24 सिर्फ y है
— व्लादिमीर क्रेवरो
1
@Rod आप की जरूरत नहीं है a=। यह एक शुद्ध भेड़ का बच्चा होने की अनुमति है।
— 11
1
@VladimirCravero बिल्कुल नहीं। यह वैसा ही है y%24।
— आउटगॉल्फ ऑक्ट
3

पायथन, 42 बाइट्स

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

एक पुनरावर्ती समारोह है कि विस्तार 23. 0 से दो नंबर लेता ~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 है और पुनरावर्ती परिणाम के लिए फ़ंक्शन जोड़ा जाता है। यही है, जब तक कि वर्तमान समय अंतिम घंटे नहीं है, तब तक हम किस स्थिति में रुकते हैं।

मैं इसके बजाय एक विशुद्ध रूप से अंकगणितीय हल लिखने का प्रयास कर रहा हूं, लेकिन अभी तक मुझे केवल लंबे और गंदे भाव ही मिले हैं।

— XNOR
स्रोत
आह, मैं इसे प्राप्त करता हूं: यह मूल रूप से मेरी पायथन उत्तर के समान तकनीक है, लेकिन चारों ओर प्राप्त करने का वास्तव में चतुर तरीका है or। अच्छा है!
— ETHproductions
3

हास्केल, 48 43 बाइट्स

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

उपयोग startHour % endHour, 24-घंटा प्रारूप में दिए गए दोनों इनपुट के साथ है।

संपादित करें: जोड़ा गया @ xnor का सुधार, 5 बाइट्स की बचत

— निक हेंसन
स्रोत
बदल रहा है के बजाय eजब e<s, आप सीमा पर फ़िल्टर कर सकते s%e=sum[mod(x-1)12+1|x<-[s..e+24],x<=e||s>e]। इसके बाद x को 1 से नीचे शिफ्ट करने के लिए एक बाइट बचाता है s%e=sum[mod x 12+1|x<-[s-1..e+23],x<e||s>e]।
— xnor
3

सी #, 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
        }
    }
}
— adrianmp
स्रोत
3

जेली , 17 16 15 14 बाइट्स

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

TryItOnline

कैसे?

>×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
— जोनाथन एलन
स्रोत
2

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
— लुइस मेंडो
स्रोत
2

PHP, 90 बाइट्स

1 और 24 के बीच इनपुट प्रारूप '[1,24]'

इस चुनौती में कि मुझे नफरत है क्यों PHP अन्य भाषाओं के खिलाफ ढीली है। मैं अपने सभी विचारों को दिखाना पसंद करता हूं। हो सकता है कि एक अन्य PHP क्रैक एक छोटा समाधान ढूंढता है।

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

अब इस बिंदु पर हम केवल दो ints 101 बाइट्स मेक 2 sums $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);
— जार्ग हुल्सरमैन
स्रोत
2

PHP, 69 बाइट्स

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

सूची निष्कर्षण जोर्ग हल्सरमैन के उत्तर से प्रेरित था लेकिन बाकी समानताएँ अभिसरण विकास का परिणाम हैं और क्योंकि यह काफी छोटा है और लूप में स्थितियां काफी अलग हैं और मैं इसे एक अलग उत्तर के रूप में पोस्ट कर रहा हूं।

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
— user59178
स्रोत
$i>$a?24:0($i>$a)*24 wiki.php.net/rfc/short_list_syntax के समान लंबाई है शायद आप छोटी सूची के सिंटैक्स का उपयोग करना चाहते हैं जो 7.1 [$x,$i,$a]=$argv;-2 बाइट्स में नया है इससे पहले कि मैंने परीक्षण नहीं किया है कि मैं इसका उपयोग नहीं करूंगा। अब मैं इस तरह से नहीं मिला था कि मुझे अधिक नफरत है NIce तरह।
— जार्ज ह्यूल्समैन 16
धन्यवाद, मुझे आगामी लघु सूची सिंटैक्स के बारे में पता था लेकिन php 7.1 के रूप में अभी तक ठीक से जारी नहीं किया गया है (अभी भी लेखन के समय उम्मीदवार 3 पर जारी है) मुझे लगा कि यह अभी तक पीपीसीजी के उत्तर में अनुमति नहीं थी।
— user59178
2

जावा, 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 क्रूज़सेन को धन्यवाद
  • +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;}

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;
}
— रोमन ग्रैफ़
स्रोत
आप कहां परिभाषित करते हैं a, और d, और b? पूरी विधि समझ में आती है, लेकिन जब तक मैं कुछ याद नहीं कर रहा हूं, मुझे लगता है कि आपको अपने गोल्फ के लैंब को फिर से देखने की जरूरत है और वास्तव में इसे निष्पादित करने का प्रयास करें। आगे गोल्फिंग के लिए: (time+1)बन सकते हैं ++time।
— तारकोल
गोल्फ वाले हिस्से में एक त्रुटि है: a+=a?होना चाहिए b+=a?। इसके अलावा, आप इसे 2 बाइट्स में बदलकर whilefor(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;}
— बॉडीलेस
माफ़ कीजिये। मैंने अपने मोबाइल से इस दृष्टिकोण को लिखा और इसका परीक्षण नहीं कर सका। फिक्स्ड। :)
— रोमन ग्रफ
1

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सुबह / दोपहर का ट्रैक रखता है, 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

अब, मैं कोड को उचित उत्तर दूंगा ...

— steenbergh
स्रोत
1

पायथ - 11 बाइट्स

s|R12%R12}F

टेस्ट सूट ।

— Maltysen
स्रोत
2
यह लगभग आधी रात में नहीं गिना जाता, उदाहरण के लिए 23, 1आउटपुट 144जब यह उत्पादन करना चाहिए 24। (इस तरह के एक मामले को, निश्चित रूप से, परीक्षणों में होना चाहिए!)
— जोनाथन एलन
1

सी #, 76 बाइट्स

(a,b)=>Enumerable.Range(a,Math.Abs(b-a)+1).Select(n=>n%12==0?12:n%12).Sum();
— downrep_nation
स्रोत
यह ऐसा नहीं दिखता है कि यह आधी रात को घूमता है।
— नील
सभी परीक्षण मामले सफल होते हैं
— downrep_nation 12
मैंने ऐसा नहीं पूछा।
— नील
फिर आपका कौन सा परीक्षण मामला मेरे कार्यान्वयन में विफल रहता है?
— डाउनरेप_न्यूज
a=23और b=0सबसे स्पष्ट उदाहरण लगता है।
— नील
1

पर्ल, 36 बाइट्स

के लिए +1 शामिल है -p

STDIN पर प्रत्येक पंक्ति में 24-घंटे के प्रारूप में आरंभ और समाप्ति समय दें:

toll.pl
11
15
^D

toll.pl:

#!/usr/bin/perl -p
$\+=$_%12||12for$_..$_+(<>-$_)%24}{
— टन हास्पेल
स्रोत
1

जावा 7, 64 बाइट्स

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

@ETHproductions के पायथन 2 उत्तर के आधार पर पुनरावर्ती विधि । 24 घंटे के घड़ी इनपुट का उपयोग करता है।

Ungolfed और परीक्षण कोड:

इसे यहाँ आज़माएँ।

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
— केविन क्रूज़सेन
स्रोत
1

बैच, 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, 1 घंटे के बाद से शुरू होने वाले घंटे को सामान्य करें (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 बजे से शुरू होने वाले घंटे तक होती थी, लेकिन शुरुआती घंटे शामिल नहीं होती थी
— नील
स्रोत
1

सी, 56 बाइट्स

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

> <> , 48 + 2 = 50 बाइट्स

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

इनपुट कार्यक्रम प्रारंभ में स्टैक पर मौजूद होने की उम्मीद है, इसलिए -vध्वज के लिए +2 बाइट्स । इनपुट दो पूर्णांक है जो 24 घंटे की घड़ी पर घंटे को निर्दिष्ट करता है, इसलिए 10am - 10pmइसे दिया जाएगा 10 22।

इसे ऑनलाइन आज़माएं!

— सोक
स्रोत
@LuisMendo धन्यवाद, यह अब ठीक हो गया है
— सोक
1

क्यूबिक्स , 45 44 बाइट्स

सहेजे गए 1 बाइट, @ETHproductions के लिए धन्यवाद

क्यूबिक्स में मेरा पहला प्रवेश ...

)$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 घंटे के प्रारूप में है। उदाहरण के लिए, शाम 5 बजे से 1 बजे तक इनपुट होना चाहिए 1 17।

पिछला संस्करण, 45 बाइट्स:

)$442t\/OI0Iuq;;-!^;^%&21u+rr;ss!;sqU>&%r$@.;
— सोक
स्रोत
1
मेरी भाषा, और महान नौकरी का उपयोग करने के लिए धन्यवाद :-) मुझे एक छोटी बाइट दिखाई देती है जिसे आप थोड़ा सा पुन: व्यवस्थित करके बचा सकते हैं और छोड़ सकते हैं:)$424tU4OI0Iuq;;-!^;^%&21u+rr;ss!;sqU>&%r$@;
— ETHproductions
0

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
— anonymous2
स्रोत
क्या आपको 12 का आउटपुट नहीं देना चाहिए जब शुरू और समाप्त होने का समय दोनों शून्य हो?
— नील
0

पायथन, 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))
— mbomb007
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.