En Rusia tenemos algo así como una tradición: nos gusta buscar boletos con suerte.

Así es como se ve un boleto normal:

Como puede ver, el boleto tiene un número de seis dígitos.

Un número de seis dígitos se considera afortunado si la suma de los primeros tres dígitos es igual a la suma de los últimos tres.

El número de la foto no tiene suerte:

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

Desafío

Dados los límites de un rango (inclusive), devuelve el número de números de boletos de suerte que contiene.

Parámetros

• Entrada: 2 enteros: el primero y el último entero en el rango
• Las entradas serán entre 0 y 999999 inclusive
• Salida: 1 entero: cuántos números de la suerte hay en el rango
• Puede tomar las entradas y devolver la salida en cualquier formato aceptable
• Suponga ceros a la izquierda para números menores a 100000.

Ejemplos

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

Este es el código de golf, por lo que gana la respuesta más corta en bytes en cada idioma.

Actualización: aquí está el afortunado

05AB1E , 8 (¿o 10?) 11 (¿o 13?) Bytes

Ÿʒ₄n+¦S3ôOË

Pruébelo en línea o verifique algunos casos de prueba más .

NOTA: en 05AB1E, las cadenas y los enteros son intercambiables, por lo que los números de salida no contienen ceros a la izquierda. Sin embargo, esto podría solucionarse con 1 byte adicional ( 12 bytes ):

Ÿ₄n+€¦ʒS3ôOË

Pruébelo en línea o verifique algunos casos de prueba más .

+3 bytes para corregir errores con una longitud de 3 o menos (rango [000000, 000999]).

Explicación:

Ÿ          # 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

EDITAR: Parece que I (y la mayoría de las otras respuestas) interpretaron mal el desafío y se pregunta la cantidad de números en lugar de los números dentro del rango. En ese caso, }gse puede agregar un final (cierre el filtro; y obtenga la cantidad de números restantes en la lista filtrada), por lo que son 10 13 bytes en su lugar:

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

Pruébelo en línea o verifique algunos casos de prueba más .

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

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

Pruébalo en línea!

18 bytes para using System.Linq;. Supuse que los formatos de entrada y salida podrían ser flexibles. Entonces tomo dos enteros como entrada (el rango, inclusive).

Algunos resultados de la prueba:

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 bytes

Toma entrada en la sintaxis de curry (m)(n), donde m es el límite superior inclusivo exclusivo yn es el límite inferior inclusivo.

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

Pruébalo en línea!

¿Cómo?

Probamos cada número caminando a través de sus dígitos d i y actualizando un total t :$n$$d_i$$t$

• si quedan al menos 3 dígitos después de este$t \gets t - d_i$
• contrario$t \gets t + d_i$

Si tenemos al final del proceso, entonces n es un número de la suerte.$t=0$$n$

JavaScript (ES6), 67 bytes

Mismo formato de entrada.

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

Pruébalo en línea!

¿Cómo?

$n$

• $1000$38937 --> 38.937
• coaccionar a una cadena y dividir: ['3','8','.','9','3','7']
• unirse con +:"3+8+.+9+3+7"
• reemplazar +.con ^:"3+8^+9+3+7"
• $0$24$11$$19$

Si , no se genera punto decimal y la expresión evaluada es solo una suma positiva (falsedad), a menos que (verdad). Este es el resultado esperado en ambos casos.n = $n \equiv 0 \pmod{1000}$$n=0$

Ruby , 56 54 bytes

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

Pruébalo en línea!

Método:

1. Para cada número, crea una matriz de dígitos (que sale invertida)
2. Compara la suma de los primeros 3 dígitos de la matriz (los últimos 3 en el número) multiplicados por 2 con la suma de la matriz completa
3. Cuenta los números para los cuales las dos sumas son iguales

Japt , 38 15 bytes

õV Ëì ò3n)mx r¥

-23 gracias a Shaggy!

Mi primera presentación de Japt; ¡Gracias a Shaggy por toda la ayuda!

Pruébalo en línea!

Python 3, 117 113 106 135 bytes

Esta es mi primera respuesta, así que estoy seguro de que hay margen de mejora.

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 bytes gracias a WW
• -7 bytes gracias a Asone Tuhid
• +29 bytes para crear una función

Obtiene los primeros tres dígitos a través de la división de enteros, y los últimos tres a través del módulo. El primer y el último número entero en el rango se ingresan como argumentos de la xfunción, como ay b, respectivamente. La salida es nimpresa.

Sin 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 bytes

Lógica más corta al final cumplidos 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}

Pruébalo en línea!

Entradas enteras. Rellenarlos con 0. Convierte a los seis puntos de código ASCII. Abusar de la Fconstrucción.

Casco , 12 bytes

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

Pruébalo en línea!

Explicación

#(§¤=Σ↓↑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

Carbón de leña , 15 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Editar: Originalmente pensé que se requería la lista de números de la suerte. Esto se puede hacer en 14 bytes (quitando el Ｌ, que toma la longitud de la lista), o en 20 bytes si desea un buen formato:

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

    ＮＮ                  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 bytes

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

Pruébalo en línea!

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

Para generar cada boleto en su lugar es +1 byte:

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

Pruébalo en línea!

Python 3 , 89 86 bytes

-2 gracias al Sr. Xcoder.

-3 inspirador de la respuesta de 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))

Resultados de las pruebas:

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 

Pruébalo en línea!

MATL , 24 bytes

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

Pruébalo en línea!

(-2 bytes gracias a Luis Mendo.)

&: - Haga un rango inclusivo entre los dos números dados

1e3&\ - 'divrem': divide entre 1000 y obtén los recordatorios y los cocientes del suelo en dos matrices.

, - hacer dos veces

!'03d'&V - transponer y convertir cada valor en una cadena de tres anchos con relleno de cero

&s - suma los valores de cada fila

w - cambie para sacar el conjunto de recordatorios y vuelva a hacer esto

] - bucle final

= - comprobar la igualdad (devuelve 1s en lugares donde las matrices son iguales)

s - sumar aquellos para obtener el conteo (salida implícita)

Kotlin , 152 119 bytes

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

Pruébalo en línea!

Tomar dos enteros que convertirlo en seis cadenas de símbolos y contar.

Lo optimizó gracias a mazzy y su solución a 119 bytes.

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

Pruébalo en línea!

dc , 44 bytes

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

Toma dos argumentos de una pila vacía, sale a la parte superior de la pila.

Pruébalo en línea!

El bit inteligente aquí es el uso de una macro sin nombre (es decir, sin almacenar) que se duplica antes de la ejecución para ejecutar una copia de sí mismo en la otra parte de tres dígitos.

Explicación

La macro interna [rA~rA~++rx]tiene el efecto "calcular la suma de dígitos del número de tres dígitos que ocupa el segundo lugar en la pila, luego ejecuta la parte superior original de la pila como una macro".

Programa 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 bytes

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.

Pruébalo en línea!

Explicación

Aquí hay un código de aspecto normal primero:

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.

Pruébalo en línea!

Luego abusé del comportamiento del bucle for:

• los valores del bucle se establecen de antemano (de aa b), por lo que ase pueden reutilizar como la variable del bucle, soltando i;
• al final del ciclo for, la variable del ciclo se deja en el valor final (valor banterior al ciclo). Lo usé bcomo contenedor, incrementándolo cuando se encuentra un número de la suerte y al final del ciclo bestá lejos de su valor anterior por la cantidad de números de la suerte, por lo que b-ada el resultado correcto. Esto dejó caer s.

Reemplazar dcon operaciones directamente en aacorta el ciclo. Sustitución de clas operaciones directamente en adosis no acortar el bucle, pero, después de caer d, el lazo de beginy endson innecesarias y que terminó con el uso de variables de sólo 2 :)

$inicia constantes hexadecimales en el código de golf. Si bien no guardan bytes, eliminan los espacios necesarios antes de las constantes decimales.

Java (OpenJDK 8) , 162 bytes

... toma prestado del ejemplo de Kotlin anterior.

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

Pruébalo en línea!

Comparar la suma de los bytes de la cadena es tan bueno como sumar los dígitos reales.

PHP , 131 bytes

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

Para ejecutarlo:

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

Ejemplo:

php -n lucky_tickets.php 100 100000

O Pruébelo en línea!

Perl 6 , 51 49 bytes

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

Pruébalo en línea!

Bloque de código anónimo que toma dos números y devuelve el número de afortunados. Tiempos de espera para entradas más grandes

Jalea ,  9  8 bytes

-1 gracias a Dennis ( rµ...E)S-> r...E€Sya que todo se vectoriza).

rdȷD§E€S

Un enlace diádico que acepta los dos puntos finales del rango (en ambos sentidos) que produce el recuento de boletos afortunados.

Pruébalo en línea! O ver un conjunto de pruebas

¿Cómo?

$1000000$$N$$1000$
$X=\lfloor\frac{N}{1000}\rfloor$

$Y=N\mod{1000}$
$N=1000\times X+Y$

$X$$Y$$N$

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 bytes

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

Script de prueba:

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

Salida:

      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 bytes

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

.kt para prueba:

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
}

Explicación

Cuente los números del rango donde la suma de todos los dígitos numéricos es igual a la suma doble de los primeros 3 dígitos.

Stax , 14 bytes

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

¡Corre y depúralo , pero sé paciente!

Python 2 ,  83  80 bytes

-3 usando la observación de Asone Tuhid - ¡ ve a dar crédito!

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

Pruébalo en línea!

Al igual que mi respuesta Jelly (pero las entradas deben ordenarse aquí, es decir a<=b)

75 bytes para entrada a, b+1(es decir, el rango excluye el límite derecho):

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

Prueba este

Clojure, 102 bytes

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

Mezclar cadenas y matemáticas no es demasiado divertido.

J , 35 bytes

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

Pruébalo en línea!

C (gcc), 90 88 bytes

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

Puerto de mi respuesta Java . Pruébelo en línea aquí . Gracias a ceilingcat por jugar al golf dos bytes.

Sin 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 bytes

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

Un enfoque diferente al de la otra respuesta Java . En lugar de usar secuencias y cadenas, esto usa un bucle y evalúa los números directamente. Pruébelo en línea aquí .

Gracias a ceilingcat por jugar al golf dos bytes.

Sin 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 bytes

Usando la ventana inmediata y las celdas [A1] [A2]como entrada.

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 bytes

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

Pruébalo en línea!

tconvierte la cadena en números y los resume. rtoma el rango de números de sa ey filtra los números que tienen mala suerte. Los primeros tres dígitos son recopilados por n/1000. Los segundos tres dígitos son calculados por n-(n/1000)*1000.