Quante volte suonerà un campanile?


24

introduzione

Un campanile suonerà le sue campane ogni ora, a nvolte, nessendo l'ora corrente su un orologio di 12 ore.

Ad esempio, una campana suona 5 volte alle 17:00 e 10 volte alle 10:00.

Compito

Dato due volte in un formato adatto, emettere il numero di volte che suonerà la campana, compresi i tempi di inizio e fine

Esempi

"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

Se l'inizio è lo stesso della fine, allora hai semplicemente emesso il numero di carillon per quell'ora:

[5pm, 5pm]
5 = 5

Come puoi vedere, puoi scegliere un metodo di input ma l'output deve essere un numero intero a sé stante (o un'alternativa accettabile).

Nota:

  • gli input possono estendersi dal pomeriggio di un giorno alla mattina del giorno successivo.
  • la differenza tra le due volte non sarà mai più di 24 ore.
  • l'input è flessibile fintanto che dichiari chiaramente quale formato è l'input.
  • il tuo contributo deve avere una chiara distinzione tra AM e PM.

2
Scegliamo il nostro metodo di input o deve supportare tutti i citati?
anonymous2,

1
Puoi scegliere il metodo di input
Shaun Wild

1
Dovresti chiarire che gli input possono passare da pma am, passando così al 2 ° giorno.
mbomb007,

3
La mezzanotte verrà data come 0 o 24?
xnor

4
Incoraggiamo l'uso di Sandbox per risolvere eventuali problemi con problemi prima che vengano pubblicati sul sito principale.
Mego

Risposte:


12

JavaScript (ES6), 38 35 byte

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

Aggiunge ricorsivamente il numero attuale di campane al totale. Chiamato come f(11,15); mezzanotte è rappresentata come 24. Ho preso parte del ~-trucco dalla risposta Python di @ xnor .

Snippet di prova

Versione non ricorsiva (Firefox 30+), 56 byte

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

Equivalente alla seguente funzione ES6:

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

7

Python 2, 46 byte

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

Basato sulla mia risposta JS. La formula ricorsiva f per la soluzione è definita come segue:

  1. Inizia con due interi x e y .
  2. Prendi x mod 12 ; se questo è 0, prendi invece 12 .
  3. Se x! = Y , aggiungi il risultato di f (x + 1 mod 24, y) .

6

Python 2, 59 54 byte

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

3
Penso che non ti serva la a=parte.
acrolith,

@daHugLenny deve essere una funzione completa (utilizzabile)
Rod

(y + 24)% 24 è proprio y
Vladimir Cravero,

1
@Rod Non è necessario a=. È permesso essere un lambda puro.
Yytsi,

1
@VladimirCravero Certo che no. È lo stesso di y%24.
Erik the Outgolfer,


3

Python, 42 byte

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

Una funzione ricorsiva che accetta due numeri da 0 a 23. L'espansione di ~x"s" -x-1

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

L'espressione (a+1)%12+1converte un tempo nel numero di squilli 1in 12. Quindi, il limite inferiore viene incrementato modulo 24 e viene aggiunta la funzione per il risultato ricorsivo. Cioè, a meno che l'ora corrente non sia l'ora di fine, nel qual caso ci fermiamo.

Ho cercato invece di scrivere una soluzione puramente aritmetica, ma finora ho trovato solo espressioni lunghe e disordinate.


Ah, capisco: è sostanzialmente la stessa tecnica della mia risposta Python, ma con un modo davvero intelligente di aggirare il or. Ben fatto!
ETHproductions

3

Haskell, 48 43 byte

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

L'utilizzo è startHour % endHour, con entrambi gli ingressi dati in formato 24 ore.

modifica: aggiunto il miglioramento di @ xnor, salvando 5 byte


Invece di cambiare equando e<s, è possibile filtrare l'intervallo s%e=sum[mod(x-1)12+1|x<-[s..e+24],x<=e||s>e]. E poi salva un byte di spostamento x dalla 1: s%e=sum[mod x 12+1|x<-[s-1..e+23],x<e||s>e].
xnor

3

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 accettabile: numeri interi nell'intervallo [0,23].

Questa soluzione non utilizza LINQ.


Programma completo con casi di test:

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

Gelatina , 17 16 15 14 byte

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

TryItOnline

Come?

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

yy>24*+&:12X\s

Il formato di input è come nel terzo esempio della sfida, ovvero due numeri in formato 24 ore.

Provalo online!

Spiegazione

Prendi gli input 22, 10ad esempio.

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 byte

Formato di input '[1,24]' tra 1 e 24

In questa sfida che odio il motivo per cui PHP è in contrasto con altre lingue. Preferisco mostrare tutte le mie idee. Forse un altro crack di PHP trova una soluzione più breve.

<?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 a tratta con min e max

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

Va bene questa folle idea funziona con una serie 149 Byte riempie la matrice $y[0]e $y[1]se $_GET["b"][0]<=$_GET["b"][1] se $y[1]è nullPossiamo riassumere questo arrayarray_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)));

Questo potrebbe essere ridotto a 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]);

Ora a questo punto possiamo ridurre l'array con solo due in 101 byte. Fare 2 somme $x[0]e$x[1]

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

se $v=($f>$g quindi aggiungi valore, $x[$i<$f&$i>$g] altrimenti aggiungi valore $x[$i>=$f&$i<=$g] all'output verrà trovato per casoecho$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];

Successivamente ho trovato un modo per calcolare il risultato direttamente 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;

103 byte ricorsivi

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

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

L'estrazione dell'elenco è stata ispirata dalla risposta di Jörg Hülsermann, ma il resto delle somiglianze sono il risultato di un'evoluzione convergente e poiché è molto più breve e i condizionali nel ciclo sono abbastanza diversi, lo sto postando come una risposta separata.

Accetta input come tempi di 24 ore (va bene con 0 o 24). Esegui come:

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:0ha la stessa lunghezza di ($i>$a)*24 wiki.php.net/rfc/short_list_syntax Forse vuoi usare la sintassi dell'elenco breve che è nuova in 7.1 [$x,$i,$a]=$argv;-2 byte Prima di non aver verificato che non l'avrei usato. In questo modo ora mi odio di più che non ho trovato in questo modo.
Jörg Hülsermann,

grazie, sapevo dell'imminente sintassi della short list ma poiché php 7.1 non è stato ancora rilasciato correttamente (ancora in rilascio candidato 3 al momento della stesura) ho pensato che non fosse ancora consentito nelle risposte PPCG.
user59178

2

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

Modifica :

  • -1 byte spento. Grazie a @ 1Darco1
  • Testa a funzione fissa. +7 byte attivi .
  • -2 byte di sconto. Grazie a @Kevin Cruijssen
  • +2 byte attivi . Ora e/ clockè inizializzato.

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

Dove si definisce a, e d, e b? Il metodo completo ha senso, ma a meno che non mi manchi gravemente qualcosa, penso che tu debba guardare di nuovo il tuo lambda golfizzato e in realtà provare a eseguirlo. Per ulteriori golf: (time+1)può diventare ++time.
1Darco1

C'è un errore nella parte golfata: a+=a?dovrebbe essere b+=a?. Inoltre, puoi giocare a golf di 2 byte cambiando whilein un bodyless in forquesto modo:(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;}
Kevin Cruijssen,

Scusate. Ho scritto questo approccio dal mio cellulare e non sono riuscito a testarlo. Fisso. :)
Roman Gräf,

1

QBIC , 90 47 byte

Quindi, ecco la risposta stampando solo il numero totale di campanelli:

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

L'ingresso è nel range 1-24; ae bsono gli input ( ::nel codice), ctiene traccia di am / pm, dè il numero totale di squilli. Quando abbiamo fatto il conto alla rovescia per tutte le ore, _Xdtermina il programma, stampando dnel processo.


OK, ho frainteso la domanda e ho pensato che il 1+2+3...=testo fosse parte dell'output, quindi ho scritto che:

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

Ora vado a scrivere la risposta corretta ...


1

Pyth - 11 byte

s|R12%R12}F

Test Suite .


2
Questo non conta verso mezzanotte, per esempio 23, 1uscite 144quando dovrebbe uscita 24. (Un caso del genere, ovviamente, dovrebbe essere nei test!)
Jonathan Allan,

1

C #, 76 byte

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

Non sembra che si avvolga a mezzanotte.
Neil,

Tutti i casi di test hanno esito positivo
downrep_nation

Non l'ho chiesto.
Neil,

Quindi quale dei tuoi casi di test fallisce con la mia implementazione?
downrep_nation

a=23e b=0sembra essere l'esempio più ovvio.
Neil

1

Perl, 36 byte

Include +1 per -p

Fornisci l'ora di inizio e fine in formato 24 ore su una riga ciascuno su STDIN:

toll.pl
11
15
^D

toll.pl:

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

1

Java 7, 64 byte

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

Metodo ricorsivo basato sulla risposta Python 2 di @ETHproductions . Utilizza un ingresso orologio di 24 ore.

Codice non testato e test:

Provalo qui.

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

Produzione:

33
15
29
88
5

1

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

Modifica: salvato 77 byte passando a un modulo chiuso per la risposta.

  • %1e %2sono i due parametri della riga di comando
  • @ Disabilita l'impostazione predefinita di Batch che è l'eco del comando
  • cmd/c Fool Batch stampa immediatamente il risultato del calcolo
  • set/a Eseguire un calcolo numerico
  • x=(%1+23)%%24, Normalizza l'ora di inizio in modo che corrisponda al numero di ore dall'1: 00 (anche 1PM funzionerebbe, ma 11 non è inferiore a 23)
  • y=x+(%2+24-%1)%%24, Normalizza l'ora di fine per essere in anticipo rispetto all'ora di partenza, avanzando al giorno successivo, se necessario
  • z=y%%12+1, Numero di campane suonate all'ora di fine
  • (y/12-x/12)*78+ Numero di campane a causa di mezze giornate in più
  • z*~-z/2- Numero di campane dall'1 all'ora di fine compresa
  • (x%%=12) Uno in meno del numero di campane suonate all'ora di partenza
  • *-~x/2 Numero di campane che sarebbero state suonate dall'una all'ora di partenza, ma non compresa l'ora di partenza

1

C, 56 byte

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

1

> <> , 48 + 2 = 50 byte

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

Si prevede che l'input sia presente nello stack all'avvio del programma, quindi +2 byte per il -vflag. L'input è due numeri interi che specificano l'ora sull'orologio 24 ore, quindi 10am - 10pmsarebbe dato come 10 22.

Provalo online!


@LuisMendo Grazie, è stato risolto
Sok

1

Cubix , 45 44 byte

Salvato 1 byte, grazie a @ETHproductions

La mia prima incursione in Cubix ...

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

O, cubificato:

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

Puoi provarlo presso l' interprete online . L'ingresso è in formato 24 ore, con l'ora di fine prima. Ad esempio, dalle 17:00 all'01: 00 l'ingresso dovrebbe essere 1 17.


Versione precedente, 45 byte:

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

1
Grazie per aver usato la mia lingua e un ottimo lavoro :-) Vedo un piccolo byte che puoi salvare riorganizzando leggermente e rilasciando la no-op:)$424tU4OI0Iuq;;-!^;^%&21u+rr;ss!;sqU>&%r$@;
ETHproductions

0

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

Non dovresti produrre 12 quando l'ora di inizio e di fine sono zero?
Neil,

0

Python, 73 byte

Sarebbe così molto più breve, se non abbiamo dovuto sostenere pma am. Uso la ricorsione per supportarla.

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

Provalo online

Senza supporto pma am(45 byte):

lambda a,b:sum(~-i%12+1for i in range(a,b+1))
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.