Combien de fois un clocher sonnera-t-il?


24

introduction

Un clocher sonnera toutes les heures, toutes les heures, navec nl'heure actuelle sur une horloge de 12 heures.

Par exemple, une cloche sonnera 5 fois à 17h et 10 fois à 10h.

Tâche

Donné deux fois dans un format approprié, affichez le nombre de sonneries, y compris les heures de début et de fin

Exemples

"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

Si le début est le même que la fin, il vous suffit de sortir le nombre de carillons pour cette heure:

[5pm, 5pm]
5 = 5

Comme vous pouvez le voir, vous pouvez choisir une méthode d'entrée, mais la sortie doit être un entier seul (ou une alternative acceptable) les sauts de ligne / début et les espaces sont autorisés.

Remarque:

  • les intrants peuvent s'étendre de l'après-midi d'un jour au matin du lendemain.
  • la différence entre les deux temps ne sera jamais supérieure à 24 heures.
  • l'entrée est flexible tant que vous indiquez clairement le format de votre entrée.
  • votre entrée doit avoir une distinction claire entre AM et PM.

2
Choisissons-nous notre propre méthode de saisie ou doit-elle prendre en charge tous les éléments mentionnés?
anonymous2

1
Vous pouvez choisir la méthode de saisie
Shaun Wild

1
Vous devez préciser que les entrées peuvent aller de pmà am, passant ainsi à un 2e jour.
mbomb007

3
Minuit sera-t-il donné à 0 ou 24?
xnor

4
Nous encourageons l'utilisation du bac à sable pour résoudre les problèmes rencontrés avant qu'ils ne soient publiés sur le site principal.
Mego

Réponses:


12

JavaScript (ES6), 38 35 octets

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

Ajoute récursivement le nombre actuel de sonneries au total. Appelé comme f(11,15); minuit est représenté par 24. J'ai obtenu une partie de l' ~-astuce de la réponse Python de @ xnor .

Extrait de test

Version non récursive (Firefox 30+), 56 octets

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

Équivalent à la fonction ES6 suivante:

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

7

Python 2, 46 octets

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

Basé sur ma réponse JS. La formule récursive f pour la solution est définie comme suit:

  1. Commencez avec deux entiers x et y .
  2. Prenez x mod 12 ; si c'est 0, prenez 12 place.
  3. Si x! = Y , ajoutez le résultat de f (x + 1 mod 24, y) .

6

Python 2, 59 54 octets

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

3
Je pense que vous n'avez pas besoin de la a=pièce.
acrolith

@daHugLenny, il doit s'agir d'une fonction complète (utilisable)
Rod

(y + 24)% 24 est juste y
Vladimir Cravero

1
@Rod Vous n'avez pas besoin a=. Il est permis d'être un pur lambda.
Yytsi

1
@VladimirCravero Bien sûr que non. C'est la même chose que y%24.
Erik the Outgolfer


3

Python, 42 octets

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

Une fonction récursive qui prend deux nombres de 0 à 23. L'extension du ~x's à -x-1donne

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

L'expression (a+1)%12+1convertit un temps en nombre de sonneries 1en12 . Ensuite, la borne inférieure est incrémentée modulo 24 et la fonction pour le résultat récursif est ajoutée. Autrement dit, sauf si l'heure actuelle est l'heure de fin, auquel cas nous nous arrêtons.

J'ai plutôt essayé d'écrire une solution purement arithmétique, mais jusqu'à présent, je n'ai trouvé que des expressions longues et désordonnées.


Ah, je comprends: c'est fondamentalement la même technique que ma réponse Python, mais avec une façon vraiment intelligente de contourner le or. Joli!
ETHproductions du

3

Haskell, 48 43 octets

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

L'utilisation est startHour % endHour, avec les deux entrées données au format 24 heures.

edit: ajout de l'amélioration de @ xnor, économisant 5 octets


Au lieu de changer equand e<s, vous pouvez filtrer la plage s%e=sum[mod(x-1)12+1|x<-[s..e+24],x<=e||s>e]. Elle enregistre ensuite un octet à décalage x par 1: s%e=sum[mod x 12+1|x<-[s-1..e+23],x<e||s>e].
xnor

3

C #, 73 octets

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

Entrée acceptable: entiers dans la plage [0,23].

Cette solution n'utilise pas LINQ.


Programme complet avec cas de 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

Gelée , 17 16 15 14 octets

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

TryItOnline

Comment?

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

yy>24*+&:12X\s

Le format d'entrée est comme dans le troisième exemple du défi, c'est-à-dire deux nombres au format 24 heures.

Essayez-le en ligne!

Explication

Prenez des entrées 22, à 10titre d'exemple.

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 octets

Format d'entrée «[1,24]» entre 1 et 24

Dans ce défi que je déteste pourquoi PHP lâche contre d'autres langages. Je préfère montrer toutes mes idées. Peut-être qu'un autre PHP Crack trouve une solution plus courte.

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

<?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 octets par chemin avec min et 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;

bien cette idée folle fonctionne avec un tableau 149 octets remplit le tableau $y[0]et $y[1]si $_GET["b"][0]<=$_GET["b"][1] si $y[1]est que nullnous pouvons résumer ce tableauarray_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)));

Cela pourrait être joué sur 124 octets

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

Maintenant, à ce stade, nous pouvons réduire le tableau avec seulement deux pouces 101 octets faire 2 sommes $x[0]et$x[1]

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

si $v=($f>$g alors ajouter de la valeur à $x[$i<$f&$i>$g] autre ajouter de la valeur à $x[$i>=$f&$i<=$g] la sortie sera trouvé par casecho$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];

Après cela, j'ai trouvé un moyen de calculer le résultat directement 112 octets

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

récursif 103 octets

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

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

L'extraction de la liste a été inspirée par la réponse de Jörg Hülsermann, mais le reste des similitudes est le résultat d'une évolution convergente et parce qu'elle est beaucoup plus courte et que les conditions de la boucle sont suffisamment différentes, je la poste en tant que réponse distincte.

Prend l'entrée en tant que 24 heures (bien avec 0 ou 24). Courez comme:

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:0a la même longueur que ($i>$a)*24 wiki.php.net/rfc/short_list_syntax Peut-être que vous voulez utiliser la syntaxe de liste courte qui est nouvelle dans 7.1 [$x,$i,$a]=$argv;-2 octets Avant je n'ai pas testé que je ne l'utiliserais pas. Maintenant, je vais plus me détester que je n'ai pas trouvé ça.
Jörg Hülsermann du

merci, je connaissais la prochaine syntaxe de la liste restreinte, mais comme php 7.1 n'a pas encore été correctement publié (toujours sur la version 3 du candidat au moment de la rédaction), j'ai supposé qu'elle n'était pas encore autorisée dans les réponses PPCG.
user59178

2

Java, 72 71 78 76 octets

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

Modifier :

  • -1 octet désactivé. Merci à @ 1Darco1
  • Tête de fonction fixe. +7 octets activés .
  • -2 octets éteints. Merci à @Kevin Cruijssen
  • +2 octets activés . Maintenant e/ clockest initialisé.

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

Non golfé:

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

Où définissez-vous a, et d, et b? La méthode complète est logique, mais à moins que je manque sérieusement quelque chose, je pense que vous devez regarder à nouveau votre lambda golfé et essayer de l'exécuter. Pour plus de golf: (time+1)peut devenir ++time.
1Darco1

Il y a une erreur dans la partie golfée: a+=a?devrait l'être b+=a?. En outre, vous pouvez whilejouer au golf de 2 octets en changeant le en un sans corps forcomme ceci:(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

Désolé. J'ai écrit cette approche depuis mon mobile et je n'ai pas pu la tester. Fixé. :)
Roman Gräf

1

QBIC , 90 47 octets

Voici donc la réponse en n'imprimant que le nombre total de sonneries:

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

L'entrée est dans la plage 1-24; aetb sont les entrées ( ::dans le code), cgarde une trace de am / pm, dest le nombre total de sonneries. Lorsque nous avons décompté toutes les heures, _Xdmet fin au programme et imprime ddans le processus.


OK, j'ai mal compris la question et j'ai pensé que le 1+2+3...=texte faisait partie de la sortie, alors j'ai écrit ceci:

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

Maintenant, je vais coder la bonne réponse ...


1

Pyth - 11 octets

s|R12%R12}F

Suite de tests .


2
Cela ne compte pas vers minuit, par exemple les 23, 1sorties 144quand elles devraient sortir 24. (Un tel cas devrait, bien sûr, être dans les tests!)
Jonathan Allan

1

C #, 76 octets

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

Cela ne semble pas se terminer à minuit.
Neil

Tous les cas de test réussissent
downrep_nation

Je n'ai pas demandé ça.
Neil

Alors, quel cas de test le vôtre échoue avec mon implémentation?
downrep_nation du

a=23et b=0semble être l'exemple le plus évident.
Neil

1

Perl, 36 octets

Comprend +1 pour -p

Donnez l'heure de début et de fin au format 24 heures sur une ligne chacun sur STDIN:

toll.pl
11
15
^D

toll.pl:

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

1

Java 7, 64 octets

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

Méthode récursive basée sur la réponse Python 2 de @ETHproductions . Utilise une entrée d'horloge de 24 heures.

Code non testé et testé:

Essayez-le ici.

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

Sortie:

33
15
29
88
5

1

Lot, 168 91 octets

@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

Modifier: 77 octets enregistrés en passant à un formulaire fermé pour la réponse.

  • %1 et %2 sont les deux paramètres de ligne de commande
  • @ Désactiver la valeur par défaut de Batch qui consiste à faire écho à la commande
  • cmd/c Tromper le lot en imprimant immédiatement le résultat du calcul
  • set/a Effectuer un calcul numérique
  • x=(%1+23)%%24, Normaliser l'heure de début comme étant le nombre d'heures écoulées depuis 1 heure du matin (1 heure fonctionnerait également, mais 11 n'est pas inférieur à 23)
  • y=x+(%2+24-%1)%%24, Normaliser l'heure de fin pour être en avance sur l'heure de début, passer au jour suivant si nécessaire
  • z=y%%12+1, Nombre de cloches frappées à l'heure de fin
  • (y/12-x/12)*78+ Nombre de cloches en raison de demi-journées supplémentaires
  • z*~-z/2- Nombre de cloches de 1 heure à l'heure de fin incluse
  • (x%%=12) Un de moins que le nombre de cloches frappées à l'heure de départ
  • *-~x/2 Nombre de cloches qui auraient été frappées de 1 heure à l'heure de départ, mais sans compter l'heure de départ

1

C, 56 octets

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

1

> <> , 48 + 2 = 50 octets

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

L'entrée devrait être présente sur la pile au démarrage du programme, donc +2 octets pour l' -vindicateur. L'entrée est deux entiers spécifiant l'heure sur une horloge de 24 heures, donc 10am - 10pmserait donnée comme10 22 .

Essayez-le en ligne!


@LuisMendo Merci, c'est résolu maintenant
Sok

1

Cubix , 45 44 octets

1 octet enregistré grâce à @ETHproductions

Ma première incursion dans Cubix ...

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

Ou, cubifié:

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

Vous pouvez l'essayer sur l' interprète en ligne . L'entrée est au format 24 heures, avec l'heure de fin en premier. Par exemple, de 17 h à 1 h, l'entrée doit être 1 17.


Version précédente, 45 octets:

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

1
Merci d'utiliser ma langue et excellent travail :-) Je vois un petit octet que vous pouvez enregistrer en réorganisant légèrement et en supprimant le non-op:)$424tU4OI0Iuq;;-!^;^%&21u+rr;ss!;sqU>&%r$@;
ETHproductions

0

Qbasic, 112 octets

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

Ne devriez-vous pas afficher 12 lorsque l'heure de début et l'heure de fin sont nulles?
Neil

0

Python, 73 octets

Il serait tellement plus court si nous ne devions pas soutenir pmà am. J'utilise la récursivité pour le supporter.

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

Essayez-le en ligne

Sans prise en charge pmde am(45 octets):

lambda a,b:sum(~-i%12+1for i in range(a,b+1))
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.