Cuente los boletos de la suerte dentro del rango dado

18

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

Así es como se ve un boleto normal:

boleto de autobús

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 por lo que gana la respuesta más corta en bytes en cada idioma.

Actualización: aquí está el afortunado suertudo

Дмитрий Архипенко
fuente
2
Relacionados .
user202729

Respuestas:

10

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:

Ÿʒ₄nS3ôOË}g

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

Kevin Cruijssen
fuente
Para el rango que comienza por debajo de 1000 (por ejemplo [0; 1000]), su resultado parece estar un poco apagado (se encuentran 1000 números de la suerte).
frosqh
1
Si entiendo el desafío correctamente, agregar 1,000,000 a cada número y eliminar el primer carácter resolvería este problema. También eliminaría el uso de R.
Adnan
@Adnan Gracias, de hecho, esa es una muy buena manera de manejarlo.
Kevin Cruijssen
Es el recuento que se requiere (y la salida no requiere ceros a la izquierda), entonces 13.
Jonathan Allan
9

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)
Charlie
fuente
8

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

  • si quedan al menos 3 dígitos después de estett-reyo
  • contrariott+reyo

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


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?

norte

  • 100038937 --> 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 0241119

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 = 0norte0 0(modificación1000)norte=0 0

Arnauld
fuente
Se ha hecho inclusivo.
Jonathan Allan
7

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
Asone Tuhid
fuente
6

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!

Anfibológico
fuente
Bienvenido a Japt! :)
Shaggy
@ Shaggy gracias! ¡Es un lenguaje bastante bueno!
Anfibológico
Para ayudarlo a comenzar . Si tiene alguna pregunta, no dude en hacerme ping en el chat .
Shaggy
@ Shaggy Eso es increíble. Definitivamente aprendí mucho de eso. ¿Estás planeando publicarlo como tu propia respuesta? ¡Debieras!
Anfibológico
No, puedes tenerlo :) Como dije, para ayudarte a comenzar.
Shaggy
6

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)
usuario8276
fuente
1
No necesita la sangría después del if por cierto. Además, probablemente será más barato convertir a cadena antes de tomar los primeros o últimos 3 dígitos.
Wheat Wizard
2
Bienvenido a PPCG! Eche un vistazo a Consejos para jugar golf en Python para obtener consejos y trucos, hay un hilo similar para la mayoría de los idiomas si está interesado. Además, es una buena práctica incluir un enlace TIO como demostración.
Asone Tuhid
Me gustaría sugerir la sustitución n=n+1con n+=1y moviéndolo justo después de la sentencia if ( if...:n+=1)
ASONE Tuhid
No puede tomar ay bcomo variables pre-declaradas. Tienes que tener una función o tomarlos a través de la entrada
Jo King
1
Si lo mantiene como una función, puede mover la n=0parte al encabezado, comodef x(a,b,n=0)
Jo King
6

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.

ngm
fuente
Me devuelve un NA de esa función.
Robert S.
He revertido la edición. La nueva versión falla en 0 debido al scipenproblema. Oh bien.
ngm
91 bytes
Giuseppe
86 bytes
Giuseppe
6

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
ბიმო
fuente
Parece que su solución tiene el mismo defecto que tenía mi versión inicial: [000000, 001001]debería dar como resultado 2( 000000y 001001), pero da como resultado en su 1001lugar. ( 1,000,0001
Agregué y eliminé
1
@KevinCruijssen: Creo que puedo recordar que este desafío inicialmente no estaba claro, no tengo tiempo para investigarlo, así que simplemente regresé a mi presentación inicial, que parece estar bien.
ბიმო
5

Carbón de leña , 15 bytes

ILΦ…·NN⁼Σι⊗Σ÷ιφ

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:

EΦ…·NN⁼Σι⊗Σ÷ιφ﹪%06dι

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

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

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!

Dom Hastings
fuente
3

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!

frosqh
fuente
1
En la versión de conteo, sumpuede hacer cualquier generador para que [...] no se necesiten los soportes
Sr. Xcoder
range(a,b+1)La especificación ahora dice "inclusivo" (si no fuera así, podría usarlo *ren su lugar a,b, consulte mi respuesta de Python 2). También tenga en cuenta que la especificación ahora confirma que debería ser el recuento que se emite.
Jonathan Allan
3

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)

sundar - Restablece a Monica
fuente
3

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!

Yolybév
fuente
1
Puede compactarlo hasta 133 bytes{a:Int,b:Int->(a..b).map{"%06d".format(it)}.filter{(it[0]-'0')+(it[1]-'0')+(it[2]-'0')==(it[3]-'0')+(it[4]-'0')+(it[5]-'0')}.count()}
mazzy
3

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
Sophia Lechner
fuente
3

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.

AlexRacer
fuente
3

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.

Christoph
fuente
2
Puede guardar un byte al curry ( a->b->), pero deberá calificar por completo IntStreamya que no está en java.lang.
Jakob
Bienvenido a PPCG! Como @Jakob mencionó, las importaciones son parte del conteo de bytes, por lo que tendrá que agregar el java.util.stream.frente IntStreama su código y el conteo de bytes. Como también mencionó Jakob , puede guardar un byte usando a->b->, y también puede guardar algunos bytes adicionales al cambiar String.formata "".format. Pruébelo en línea: 139 bytes . Buena primera respuesta, sin embargo. +1 de mi parte ¡Disfruta tu estancia!
Kevin Cruijssen
2

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!

Noche2
fuente
2

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

Jo King
fuente
2

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?

1000000norte1000
X=norte1000

Y=nortemodificación1000
norte=1000×X+Y

XYnorte

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)
Jonathan Allan
fuente
E€Sguarda el µ.
Dennis
@ Dennis ah, sí, ¡estaba trabajando desde otra solución que no vectorizó todo en el camino!
Jonathan Allan
2

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
mazzy
fuente
¿Potencia Shell? Realmente no lo vi venir: D
Дмитрий Архипенко
2

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.

mazzy
fuente
1

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

Jonathan Allan
fuente
1

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.

NikoNyrh
fuente
1

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
}
OOBalance
fuente
Sugerir en L'✐'lugar de 10000y asignar 10a una variable.
ceilingcat el
@ceilingcat Me gusta porque me da un nombre de variable adicional, pero no pude guardar ningún byte asignando 10: bit.ly/2O5ND2Y En cuanto al L'…'truco, está bien; pero guarda bytes? Me parece que es un carácter de varios bytes, por lo que al guardar caracteres, no puede guardar bytes ... ¿o sí?
OOBalance
@ceilingcat Mi error, se pueden guardar dos bytes asignando 10 a una variable. Gracias.
OOBalance
1

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
}
OOBalance
fuente
1

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
remodelar
fuente
1

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.

Ciaran_McCarthy
fuente