Bir çan kulesi kaç kez çalacak?


24

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 .

2
Kendi girdi metodumuzu mu seçiyoruz, yoksa bütün belirtilenleri desteklemek zorunda mı?
anonim 2

1
Giriş yöntemini seçebilirsiniz
Shaun Wild

1
Bunu daha net girişler şekilde gitmesidir yapmalıdır pmiçin amböylece 2 güne geçen.
mbomb007

3
Gece yarısı 0 veya 24 olarak verilecek mi?
xnor

4
Sandbox'ın , ana siteye gönderilmeden önce zorluklarla ilgili sorunları çözmek için kullanılmasını teşvik ediyoruz .
Mego

Yanıtlar:


12

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

Ö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

7

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

6

Python 2, 59 54 bayt

a=lambda x,y:sum(1+i%12for i in range(x-1,y+24*(x>y)))
Eşittir
summ=0
if start > end:
    end+=24
for hour in range(start-1,end):
    summ +=1+hour%12
print summ

3
Sanırım a=parçaya ihtiyacın yok .
16'da

@daHugLenny tam (kullanılabilir) bir işlev olması gerekir
Rod

(y + 24)% 24 sadece y
Vladimir Cravero

1
@Rod ihtiyacınız yok a=. Saf bir lambda olmasına izin verilir.
Yytsi,

1
@VladimirCravero Elbette değil. Bu aynıdır y%24.
Outgolfer Erik,


3

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.


Ah, anlıyorum: temelde Python cevabımla aynı teknik, ancak gerçekten zekice dolaşmanın bir yolu var or. Güzel bir!
ETHProductions,

3

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


Yerine değişen ezaman e<s, sen aralığı filtreleme yapabilirsiniz s%e=sum[mod(x-1)12+1|x<-[s..e+24],x<=e||s>e]. Daha sonra x'i 1: aşağı kaydırmak için bir bayt kaydeder s%e=sum[mod x 12+1|x<-[s-1..e+23],x<e||s>e].
xnor,

3

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

3

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

2

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

2

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

2

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

$i>$a?24:0($i>$a)*24 wiki.php.net/rfc/short_list_syntax ile aynı uzunluğa sahip olabilir Belki de kullanmayacağımı [$x,$i,$a]=$argv;test etmeden önce 7.1 -2 Bayt'ta yeni olan kısa liste sözdizimini kullanmak istiyorsunuz. Güzel bir şekilde şimdi benden daha fazla nefret ediyorum, bu şekilde bulmam.
Jörg Hülsermann

teşekkürler, yaklaşmakta olan kısa liste sözdizimini biliyordum, ancak php 7.1 henüz yeterince serbest bırakılmadığı için (hala yazarken 3. adayda) PPCG cevaplarında henüz izin verilmediğini varsaydım.
kullanici59178

2

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

Nerede tanımlıyorsunuz ave dve b? Tam yöntem mantıklı, ancak ciddi bir şey kaçırmadığım sürece, golflü lambdaya tekrar bakmanız ve aslında onu çalıştırmaya çalışmanız gerektiğini düşünüyorum. Daha fazla golf oynamak için: (time+1)olabilir ++time.
1Darco1

Golf bölümünde bir hata var: a+=a?olmalı b+=a?. Ayrıca, bunun gibi whilebir bedensizlik içine değiştirerek 2 byte golf for(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;}
oynayabilirsiniz

Üzgünüm. Bu yaklaşımı cep telefonumdan yazdım ve test edemedim. Sabit. :)
Roman Gräf

1

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


1

Pyth - 11 bayt

s|R12%R12}F

Test Takımı .


2
Bu, gece yarısı civarında sayılmaz, örneğin 23, 1çıktı 144alması gereken çıktılar 24. (Böyle bir durum elbette testlerde olmalı!)
Jonathan Allan

1

C #, 76 bayt

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

Bu gece yarısı dolanıyor gibi görünmüyor.
Neil

Tüm test vakaları başarılı oldu
downrep_nation 4:16 '

Bunu sormadım.
Neil

Öyleyse hangi sınav durumunuz benim uygulamamda başarısız oluyor?
downrep_nation

a=23ve b=0en açık örnek olarak gözüküyor.
Neil

1

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

1

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

1

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

1

C, 56 Bayt

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

1

> <> , 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!


@LuisMendo Teşekkürler, şimdi düzeltildi
Sok

1

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$@.;

1
Benim dilimi kullandığınız için teşekkür ederiz ve tek gördüğüm :-) harika bir iş bir hafifçe yeniden düzenleyerek ve hiçbir-op bırakarak kaydedebilirsiniz küçük byte:)$424tU4OI0Iuq;;-!^;^%&21u+rr;ss!;sqU>&%r$@;
ETHproductions

0

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

Hem başlangıç ​​hem de bitiş saati sıfır olduğunda, 12 çıkış yapmamalı mıydınız?
Neil

0

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))
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.