En Russie, nous avons quelque chose comme une tradition: nous aimons chercher des billets chanceux.

Voici à quoi ressemble un billet régulier:

Comme vous pouvez le voir, le ticket a un numéro à six chiffres.

Un nombre à six chiffres est considéré comme chanceux si la somme des trois premiers chiffres est égale à la somme des trois derniers.

Le numéro sur la photo n'a pas de chance:

038937
038 937
0 + 3 + 8 = 11
9 + 3 + 7 = 19
11 != 19

Défi

Étant donné les limites d'une plage (incluse), renvoyez le nombre de numéros de billets chanceux qu'elle contient.

Paramètres

• Entrée: 2 entiers: le premier et le dernier entier de la plage
• Les entrées seront comprises entre 0 et 999999 inclus
• Sortie: 1 entier: combien de numéros porte-bonheur sont dans la plage
• Vous pouvez prendre les entrées et renvoyer la sortie dans n'importe quel format acceptable
• Supposons des zéros non significatifs pour les nombres inférieurs à 100 000.

Exemples

0, 1 => 1
100000, 200000 => 5280
123456, 654321 => 31607
0, 999999 => 55252

Il s'agit de code-golf, donc la réponse la plus courte en octets dans chaque langue l'emporte.

Mise à jour: voici la chance

05AB1E , 8 (ou 10?) 11 (ou 13?) Octets

Ÿʒ₄n+¦S3ôOË

Essayez-le en ligne ou vérifiez d'autres cas de test .

REMARQUE: dans 05AB1E, les chaînes et les entiers sont interchangeables, donc les numéros de sortie ne contiennent pas de zéros de tête. Cela pourrait cependant être corrigé avec 1 octet supplémentaire ( 12 octets ):

Ÿ₄n+€¦ʒS3ôOË

Essayez-le en ligne ou vérifiez d'autres cas de test .

+3 octets pour les numéros de correction de bogues d'une longueur de 3 ou moins (plage [000000, 000999]).

Explication:

Ÿ          # Create an inclusive (on both sides) range from the two inputs
           #  i.e. 038920 and 038910 → 
           #   [38910,38911,38912,38913,38914,38915,38916,38917,38918,38919,38920]
 ʒ         # Filter this list by:
  ₄n+      #  Add 1,000,000 to the number
     |     #  And remove the leading 1
           #   i.e. 38910 → 1038910 → '038910'
  S        #  Transform it to a list of digits
           #   i.e. '038910' → ['0','3','8','9','1','0']
   3ô      #  Split it into chunks of length 3
           #   i.e. ['0','3','8','9','1','0'] → [['0','3','8'],['9','1','0']]
     O     #  Sum the digits in both parts
           #   i.e. [['0','3','8'],['9','1','0']] → [11,10]
      Ë    #  Check if they are equal (if they are, they remain in the filtered list)
           #   i.e. [11,10] → 0

EDIT: Il me semble (et la plupart des autres réponses) avoir mal lu le défi et le nombre de chiffres est demandé au lieu des chiffres eux-mêmes dans la plage. Dans ce cas, une fin }gpeut être ajoutée (fermez le filtre; et obtenez le nombre de chiffres restants dans la liste filtrée), c'est donc 10 13 octets à la place:

Ÿʒ₄n+¦S3ôOË}g

Essayez-le en ligne ou vérifiez d'autres cas de test .

C # (.NET Core) , 93 + 18 = 111 octets

a=>b=>Enumerable.Range(a,b-a+1).Select(e=>$"{e:D6}").Count(e=>e[0]+e[1]+e[2]==e[3]+e[4]+e[5])

Essayez-le en ligne!

18 octets pour using System.Linq;. Je supposais que les formats d'entrée et de sortie pouvaient être flexibles. Je prends donc deux entiers en entrée (la plage, inclus).

Quelques résultats de tests:

a=1000
b=1100

Lucky numbers = 3 [001001, 001010, 001100]

a=2000
b=2100

Lucky numbers = 3 [002002, 002011, 002020]

a=222000
b=222100

Lucky numbers = 7 [222006, 222015, 222024, 222033, 222042, 222051, 222060]

a=0
b=999999

Lucky numbers = 55252 (that's 5.5% of the total numbers)

JavaScript (ES6), 66 octets

Prend une entrée dans la syntaxe de curry (m)(n), où m est la borne supérieure inclusive exclusive et n est la borne inférieure inclusive.

m=>g=n=>n<=m&&![...n+=''].reduce((t,d,i)=>t-=n[i+3]?d:-d,0)+g(-~n)

Essayez-le en ligne!

Comment?

Nous testons chaque nombre en parcourant ses chiffres d i et en mettant à jour un total t :$n$$d_i$$t$

• s'il reste au moins 3 chiffres restants après celui-ci$t \gets t - d_i$
• sinon$t \gets t + d_i$

Si nous avons à la fin du processus, alors n est un nombre porte-bonheur.$t=0$$n$

JavaScript (ES6), 67 octets

Même format d'entrée.

m=>g=n=>n<=m&&!eval([...n/1e3+''].join`+`.split`+.`.join`^`)+g(n+1)

Essayez-le en ligne!

Comment?

$n$

• $1000$38937 --> 38.937
• contraindre à une chaîne et diviser: ['3','8','.','9','3','7']
• joindre avec +:"3+8+.+9+3+7"
• remplacer +.par ^:"3+8^+9+3+7"
• $0$24$11$$19$

$n \equiv 0 \pmod{1000}$$n=0$

Rubis , 56 54 octets

->a,b{(a..b).count{|i|j=i.digits;j[0,3].sum*2==j.sum}}

Essayez-le en ligne!

Méthode:

1. Pour chaque numéro, crée un tableau de chiffres (qui apparaît inversé)
2. Compare la somme des 3 premiers chiffres du tableau (les 3 derniers du nombre) multipliée par 2 à la somme du tableau entier
3. Compte les nombres pour lesquels les deux sommes sont égales

Japt , 38 15 octets

õV Ëì ò3n)mx r¥

-23 merci à Shaggy!

Ma première soumission Japt; merci à Shaggy pour toute son aide!

Essayez-le en ligne!

Python 3, 117 113 106 106 135 octets

Ceci est ma première réponse, donc je suis sûr qu'il y a place à amélioration.

def x(a,b):
    n=0
    for i in range(a,b+1):
        if sum(map(int,str(i//1000)))==sum(map(int,str(i%1000))):n+=1
    print(n)

• -4 octets grâce à WW
• -7 octets grâce à Asone Tuhid
• +29 octets pour créer une fonction

Obtient les trois premiers chiffres par division entière et les trois derniers par modulo. Les premiers et derniers nombres entiers dans la plage sont entrées en tant que arguments de la xfonction, aet b, respectivement. La sortie est nimprimée.

Non golfé:

def x(a, b):
    n = 0
    for i in range(a, b + 1):
        if sum(map(int, str(i // 1000))) == sum(map(int, str(i % 1000))):
            n += 1
    print(n)

R , 93 86 octets

Une logique plus courte à la fin compliments de @ Giuseppe /

function(a,b){for(i in sprintf("%06d",a:b)){x=utf8ToInt(i);F=F+!sum(x[1:3]-x[4:6])}
F}

Essayez-le en ligne!

Entrées entières. Garnissez-les avec 0. Convertissez en six points de code ASCII. FAbuser de la fonction intégrée.

Husk , 12 octets

#ȯ§¤=Σ↓↑3↔d…

Essayez-le en ligne!

Explication

#(§¤=Σ↓↑3↔d)…  -- example input: 100000 101000
            …  -- inclusive range: [100000,100001..100999,101000]
#(         )   -- count elements where (example with 100010)
          d    -- | digits: [1,0,0,0,1,0]
         ↔     -- | reversed: [0,1,0,0,0,1]
  §     3      -- | fork elements (3 and [0,1,0,0,0,1])
       ↑       -- | | take: [0,1,0]
      ↓        -- | | drop: [0,0,1]
   ¤=          -- | > compare the results by equality of their
     Σ         -- | | sums 1 == 1
               -- | : 1
               -- : 3

Fusain , 15 octets

ＩＬΦ…·ＮＮ⁼Σι⊗Σ÷ιφ

Essayez-le en ligne!Le lien est vers la version détaillée du code. Edit: Je pensais à l'origine que c'était la liste des numéros porte-bonheur qui était requise. Cela peut être fait en 14 octets (en supprimant le Ｌ, ce qui prend la longueur de la liste), ou en 20 octets si vous voulez un bon formatage:

ＥΦ…·ＮＮ⁼Σι⊗Σ÷ιφ﹪%06dι

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

    ＮＮ                  Input the range endpoints
  …·                    Inclusive range
 Φ                      Filter
        ι               Current value
       Σ                Sum of digits
            ι           Current value
             φ          Predefined variable 1000
           ÷            Integer divide
          Σ             Sum of digits
         ⊗              Doubled
      ⁼                 Equals
Ｅ                       Map over results
                   ι    Current value
               %06d     Literal string
              ﹪         Format value
                        Implicitly print each result on its own line

Perl 5 + -pl -MList::Util+(sum), 49 octets

@F=/./g,$\+=sum@F[5,4,3]==sum@F[2,1,0]for$_..<>}{

Essayez-le en ligne!

Perl 5 + -nl -MList::Util+(sum) -M5.010, 50 octets

La sortie de chaque ticket à la place est de +1 octet:

@F=/./g,sum@F[5,4,3]-sum(@F[2,1,0])||say for$_..<>

Essayez-le en ligne!

Python 3 , 89 86 octets

-2 merci à M. Xcoder.

-3 inspirant des réponses d'Asone Tuhid.

lambda a,b:sum(sum(map(int,str(i)))==2*sum(map(int,str(i)[-3:]))for i in range(a,b+1))

Résultats des tests:

Example 1 : 
a = 0
b = 1
Lucky numbers : 1 

Example 2 : 
a = 100000
b = 200000
Lucky numbers : 5280 

Example 3 : 
a = 123456
b = 654321
Lucky numbers : 31607 

Example 3 : 
a = 0
b = 999999
Lucky numbers : 55252 

Essayez-le en ligne!

MATL , 24 octets

&:1e3&\,!'%03d'&V2&sw]=s

Essayez-le en ligne!

(-2 octets grâce à Luis Mendo.)

&: - Faites une plage inclusive entre les deux nombres donnés

1e3&\ - 'divrem' - divisez par 1000 et obtenez les rappels et les quotients au sol dans deux tableaux.

, - faire deux fois

!'03d'&V - transposer et convertir chaque valeur en une chaîne à trois largeurs avec un rembourrage nul

&s - additionner les valeurs de chaque ligne

w - basculez pour faire apparaître le tableau de rappel et recommencez

] - boucle de fin

= - vérifier l'égalité (retourne 1s aux endroits où les tableaux sont égaux)

s - additionnez-les pour obtenir le nombre (sortie implicite)

Kotlin , 152 119 octets

{a:Int,b:Int->(a..b).map{String.format("%06d",it)}.filter{it[0].toInt()+it[1].toInt()+it[2].toInt()==it[3].toInt()+it[4].toInt()+it[5].toInt()}.count()}

Essayez-le en ligne!

Prendre deux entiers que convertir en six chaînes de symboles et compter.

Optimisé grâce à mazzy et sa solution à 119 octets.

{a:Int,b:Int->(a..b).count{val d="%06d".format(it);(d[0]-'0')+(d[1]-'0')+(d[2]-'0')==(d[3]-'0')+(d[4]-'0')+(d[5]-'0')}}

Essayez-le en ligne!

dc , 44 octets

sb[d]sD[dA00~[rA~rA~++rx]dx=D1+dlb!<L]dsLxkz

Prend deux arguments d'une pile autrement vide, sort en haut de la pile.

Essayez-le en ligne!

Le plus intelligent ici est l'utilisation d'une macro sans nom (c'est-à-dire non stockée) qui est dupliquée avant l'exécution afin d'exécuter une copie d'elle-même sur l'autre partie à trois chiffres.

Explication

La macro interne [rA~rA~++rx]a pour effet de "calculer la somme des chiffres du nombre à trois chiffres qui est le deuxième en haut de la pile, puis d'exécuter le haut d'origine de la pile en tant que macro".

Programme principal:

sb             Saves the upper bound as b so we'll know when to quit
[d]sD          Defines the macro D, which contextually is "increment stack depth"
[              Start the main loop - the next number to test is on top 
  d              Make a copy to increment later for loop purposes
  A00            The literal "1000"
  ~              Quotient and remainder, so "123456" is now "123 456"
  [rA~rA~++rx]d  Stack is now "123 456 M M", where M is the anonymous macro
  x              Run M on the stack "123 456 M", which (see definition 
                 above) ends up running M on the stack "123 15", which
                 leaves "15 6" (and executes the 6, which is a no-op)
  =D             If the two sums were equal, increment the stack depth
  1+             Increment the current test number
  dlb!<L         Loop unless the test number is now larger than b
]dsLx          Name and start the loop
kz             Current depth is 1+answer, so throw away top and return

Pascal (FPC) , 163 153 octets

var a,b:Int32;begin read(a,b);for a:=a to b do if a div$186A0+a div$2710mod$A+a div$3E8mod$A=a div$64mod$A+a div$Amod$A+a mod$Athen b:=b+1;write(b-a)end.

Essayez-le en ligne!

Explication

Voici d'abord un code d'aspect normal:

var a,b,i,s,c,d:Int32;
begin
  read(a,b);
  s:=0;
  for i:=a to b do begin
    c:=i div 1000;
    d:=i mod 1000;
    if c div 100+(c div 10) mod 10+c mod 10=d div 100+(d div 10) mod 10+d mod 10 then begin s:=s+1; {writeln(i)} end;
  end;
  write('There are ',s,' numbers');
end.

Essayez-le en ligne!

Ensuite, j'ai abusé du comportement de la boucle for:

• les valeurs de boucle sont définies à l'avance (de aà b), elles apeuvent donc être réutilisées comme variable de boucle,i ;
• à la fin de la boucle for, la variable de boucle est laissée à la valeur finale (valeur d' bavant la boucle). Je l'ai utilisé bcomme conteneur, l'incrémentant lorsqu'un numéro porte-bonheur est trouvé et à la fin de la boucle best éloigné de son ancienne valeur par la quantité de numéros porte-bonheur, ce qui b-adonne le résultat correct. Cela a chuté s.

Le remplacement dpar des opérations directement sur araccourcit la boucle. Remplacer cpar des opérations directement sur la adose ne raccourcit pas la boucle, mais, après la suppression d, les boucles beginet endsont inutiles et j'ai fini par utiliser seulement 2 variables :)

$démarre les constantes hexadécimales dans le code golfé. Bien qu'ils n'enregistrent pas d'octets, ils éliminent les espaces nécessaires avant les constantes décimales.

Java (OpenJDK 8) , 162 octets

... emprunte à l'exemple de Kotlin ci-dessus.

import java.util.stream.IntStream;

(a,b)->IntStream.range(a,b+1).mapToObj(i->String.format("%06d",i).getBytes()).filter(c->c[0]+c[1]+c[2]==c[3]+c[4]+c[5]).count();

Essayez-le en ligne!

La comparaison de la somme des octets de la chaîne équivaut à résumer les chiffres réels.

PHP , 131 octets

<?$f='array_sum(str_split(str_split(sprintf("%06d",$i),3)[';for($i=$argv[1]-1;$i++<$argv[2];)eval("\$a+=$f 0]))==$f 1]));");echo$a;

Pour l'exécuter:

php -n <filename> <from> <to>

Exemple:

php -n lucky_tickets.php 100 100000

Ou essayez-le en ligne!

Perl 6 , 51 49 octets

{+grep {[==] .flip.comb[^3,3..*]>>.sum},$^a..$^b}

Essayez-le en ligne!

Bloc de code anonyme qui prend deux nombres et renvoie le nombre de chanceux. Délai d'expiration pour les entrées plus importantes

Gelée ,  9  8 octets

-1 merci à Dennis ( rµ...E)S-> r...E€Spuisque tout vectorise.)

rdȷD§E€S

Un lien dyadique acceptant les deux points de terminaison de la plage (dans les deux sens) qui donne le nombre de tickets chanceux.

Essayez-le en ligne! Ou voir une suite de tests

Comment?

Notez que pour tout entier non négatif inférieur à $1000000$, $N$, nous pouvons obtenir deux nombres avec des chiffres qui totalisent les valeurs requises pour vérifier en utilisant la division entière par $1000$
(cédant, disons, $X=\lfloor\frac{N}{1000}\rfloor$)
et son reste
(disons$Y=N\mod{1000}$)
... c'est-à-dire,$N=1000\times X+Y$

Maintenant, nous voulons comparer les sommes des chiffres de $X$ et $Y$ pour chaque $N$ dans une plage et comptez ceux qui sont égaux.

rdȷD§E€S - Link: integer a; integer b
r        - inclusive range [a,b] (either [a,a+1,a+2,...,b] or [a,a-1,a-2,...,b])
         -                              e.g.: 0       or 78        or 7241
  ȷ      - literal 1000
 d       - divmod (vectorises)                [0,0]      [0,78]       [7,241]
   D     - to decimal lists (vectorises)      [[0],[0]]  [[0],[7,8]]  [[7],[2,4,1]]
    §    - sum each (vectorises)              [0,0]      [0,15]       [7,7]
     E€  - for €ach: all equal?               1          0            1
       S - sum (counts the 1s in the resulting list)

Powershell, 85 octets

($args[0]..$args[1]|%{'{0:D6}'-f$_}|?{+$_[0]+$_[1]+$_[2]-eq+$_[3]+$_[4]+$_[5]}).count

Script de test:

$f = {

($args[0]..$args[1]|%{'{0:D6}'-f$_}|?{+$_[0]+$_[1]+$_[2]-eq+$_[3]+$_[4]+$_[5]}).count

}

@(
    ,((0,1), 1)
    ,((1000,2000), 3)
    ,((2000,3000), 6)
    ,((10000, 20000), 282)
    ,((101000, 102000), 6)
    ,((201000, 202000), 10)
    ,((901000, 902000), 63)
    ,((100000, 200000), 5280)
    ,((123456, 654321), 31607)
    #,((0, 999999), 55252)
) | % {
    $c, $e = $_
    "      $c"
    $r = &$f $c[0] $c[1]
    "$($e-eq$r): actual=$r expected=$e"
}

Production:

      0 1
True: actual=1 expected=1
      1000 2000
True: actual=3 expected=3
      2000 3000
True: actual=6 expected=6
      10000 20000
True: actual=282 expected=282
      101000 102000
True: actual=6 expected=6
      201000 202000
True: actual=10 expected=10
      901000 902000
True: actual=63 expected=63
      100000 200000
True: actual=5280 expected=5280
      123456 654321
True: actual=31607 expected=31607

Kotlin, 95 octets

{a:Int,b:Int->(a..b).count{val d="%06d".format(it);d.chars().sum()==2*d.take(3).chars().sum()}}

.kt pour test:

var  f = {a:Int,b:Int->(a..b).count{val d="%06d".format(it);d.chars().sum()==2*d.take(3).chars().sum()}}

fun main(args: Array<String>) {
    println(f(0,1))             // 1
    println(f(1000,2000))       // 3
    println(f(2000,3000))       // 6
    println(f(101000, 102000))  // 6
    println(f(201000, 202000))  // 10
    println(f(901000, 902000))  // 63
    println(f(10000, 20000))    // 282
    println(f(100000, 200000))  // 5280
    println(f(123456, 654321))  // 31607
    println(f(0, 999999))       // 55252
}

Explication

Comptez les nombres de la plage où la somme de tous les chiffres est égale à la double somme des 3 premiers chiffres.

Stax , 14 octets

ît║l`Yµß╖vYü╢^

Exécutez-le et déboguez-le , mais soyez patient!

Python 2 ,  83  80 octets

-3 en utilisant l'observation d'Asone Tuhid - allez donner du crédit!

lambda a,b:sum(sum(map(int,`v/1000`))*2==sum(map(int,`v`))for v in range(a,b+1))

Essayez-le en ligne!

Tout comme ma réponse Jelly (mais les entrées doivent être triées ici, c'est-à-dire a<=b)

75 octets pour l'entrée a, b+1(c'est-à-dire que la plage exclut la limite droite):

lambda*r:sum(sum(map(int,`v/1000`))*2==sum(map(int,`v`))for v in range(*r))

Essaye celui-là

Clojure, 102 octets

#(count(for[i(range %(inc %2)):when(=(let[d(map int(format"%06d"i))](apply +(map -(drop 3 d)d)))0)]i))

Mélanger les cordes et les mathématiques n'est pas trop amusant.

J , 35 octets

[:+/(6#10)([:=/_3+/\])@#:[+i.@>:@-~

Essayez-le en ligne!

C (gcc), 90 88 octets

l=10;u(c,k,y){for(y=0;c<=k;)c++%l+c/l%l+c/100%l-c/1000%l-c/10000%l-c/100000%l?:++y;c=y;}

Port de ma réponse Java . Essayez-le en ligne ici . Merci à plafondcat pour avoir joué deux octets au golf.

Non golfé:

l=10; // constant, we will be using the number 10 rather a lot
u(c, k, // function returning an integer and taking two integer arguments: lower and upper bound
  y) { // abusing the argument list to declare a variable of type integer: the number of lucky tickets found in the range
    for(y = 0; c <= k; ) // set count to 0 and loop through the range
        c++ %l + c/l %l + c/100 %l // if the digit sum of the second half of the ticket number ...
        - c/1000 %l - c/10000 %l - c/100000 %l // ... is the same as the digit sum of the first half ...
        ?: ++y; // ... it's a lucky ticket: increment the count
    c = y; // return the count
}

Java 8, 101 99 octets

u->l->{int n=0,d=10;for(;l<=u;)if(l++%d+l/d%d+l/100%d==l/1000%d+l/10000%d+l/100000%d)++n;return n;}

Une approche différente de l'autre réponse Java . Au lieu d'utiliser des flux et des chaînes, cela utilise une boucle et évalue directement les nombres. Essayez-le en ligne ici .

Merci à plafondcat pour avoir joué deux octets au golf.

Non golfé:

u -> l -> { // lambda taking two integer arguments in currying syntax and returning an integer
    int n = 0, // the counter
        d = 10; // auxiliary constant, we will be using the number 10 rather a lot
    for(; l <=u ; ) // loop over all ticket numbers in the range
        if(l++ %d + l/d %d + l/100 %d // if the digit sum of the second half of the number ...
           == l/1000 %d + l/10000 %d + l/100000 %d) // ... is the same as the digit sum of the first half ...
            ++n; // ... it's a lucky ticket, add 1 to the counter
    return n; // return the count
}

VBA (Excel), 159 octets

Utilisation de la fenêtre immédiate et des cellules [A1] [A2]comme entrée.

c=[A1]-[A2]:d=IIf(c<0,[A1],[A2]):For x=d To d+Abs(c):e=String(6-Len(x),"0")&x:For y=1To 3:i=i+Mid(e,y,1):j=j+Mid(e,7-y,1):Next:z=IIf(i=j,z+1,z):i=0:j=0:Next:?z

F #, 110 octets

let t=string>>Seq.sumBy(int>>(-)48)
let r s e=Seq.where(fun n->t(n/1000)=t(n-(n/1000)*1000)){s..e}|>Seq.length

Essayez-le en ligne!

tconvertit la chaîne en nombres et les résume. rprend la plage de nombres de sà eet filtre les nombres malchanceux. Les trois premiers chiffres sont collectés par n/1000. Les trois derniers chiffres sont calculés par n-(n/1000)*1000.