Pregunta:

Se le darán los enteros iniciales y finales de una secuencia y deberá devolver el número de enteros que no contienen el dígito 5. ¡Se deben incluir los números de inicio y fin!

Ejemplos:

1,9 → 1,2,3,4,6,7,8,9 → Resultado 8

4,17 → 4,6,7,8,9,10,11,12,13,14,16,17 → Resultado 12

50,60 → 60 → Resultado 1

-59, -50 → → Resultado 0

El resultado puede contener cinco.

El número inicial siempre será más pequeño que el número final. ¡Ambos números también pueden ser negativos!

Tengo mucha curiosidad por sus soluciones y la forma en que las resuelve. Quizás alguien de ustedes encuentre una solución matemática pura y fácil.

Editar Este es un desafío de código de golf, por lo que gana el código más corto.

JavaScript (ES6), 36 33 bytes

Toma entrada con la sintaxis de curry (a)(b).

a=>F=b=>b<a?0:!/5/.test(b)+F(b-1)

Formateado y comentado

a =>                 // outer function: takes 'a' as argument, returns F
  F = b =>           // inner function F: takes 'b' as argument, returns the final result
    b < a ?          // if b is less than a
      0              //   return 0
    :                // else
      !/5/.test(b) + //   add 1 if the decimal representation of b does not contain any '5'
      F(b - 1)       //   and do a recursive call to F with b - 1

Casos de prueba

let f =

a=>F=b=>b<a?0:!/5/.test(b)+F(b-1)

console.log(f(1)(9))
console.log(f(4)(17))
console.log(f(50)(60))
console.log(f(-50)(-59))

Gelatina , 8 7 bytes

-1 byte gracias a Dennis (use el hecho de que la indexación en un número trata ese número como una lista decimal)

rAw€5¬S

TryItOnline!

¿Cómo?

rAw€5¬S - Main link: from, to    e.g. -51, -44
r       - range(from, to)        e.g. [-51,-50,-49,-48,-47,-46,-45,-44]
 A      - absolute value         e.g. [51,50,49,48,47,46,45,44]
  w€    - first index of... for €ach (0 if not present)
    5   - five                   e.g. [1,1,0,0,0,0,2,0]
     ¬  - logical not            e.g. [0,0,1,1,1,1,0,1]
      S - sum                    e.g. 5

* El átomo de valor absoluto Aes necesario ya que un número negativo emitido a una lista decimal tiene entradas negativas, ninguna de las cuales sería nunca un 5(el ejemplo dado contaría los ocho en lugar de dos).

Bash + grep, 17 bytes

seq $@|grep -cv 5

Pruébalo en línea!

2sable , 6 5 bytes

Salvó un byte gracias a Adnan

Ÿ5¢_O

Pruébalo en línea!

Explicación

 Ÿ      # inclusive range
  5¢    # count 5's in each element of the range
    _   # negate
     O  # sum

Nota: Esto funciona debido a un error al ¢hacer que la función se aplique a cada elemento en lugar de contar elementos coincidentes en la lista.

Python2, 59 55 52 51 47 43 42 bytes

f=lambda a,b:a<=b and-(`5`in`a`)-~f(a+1,b)

Una solución recursiva. ¡Gracias a @xnor por motivarme a encontrar una solución utilizando operadores lógicos! Además, gracias a @JonathanAllan y @xnor por guiarme y cortar el byte del 43 al 42!

Otros intentos a 43 bytes

f=lambda a,b:a<=b and-~-(`5`in`a`)+f(a+1,b)
f=lambda a,b:a<=b and 1-(`5`in`a`)+f(a+1,b)

Utilidades Bash / Unix, 21 bytes

seq $*|sed /5/d|wc -l

Pruébalo en línea!

05AB1E , 8 7 6 bytes

Salvó un byte gracias a Adnan

Ÿ5.å_O

Pruébalo en línea!

Explicación

Ÿ         # inclusive range
 5.å      # map 5 in y for each y in the list
    _     # logical negation 
     O    # sum

Pyth, 9 8 bytes

¡Ahorré un byte gracias a FryAmTheEggman!

lf-\5T}E

Explicación:

        Q # Input
      }E  # Form an inclusive range starting from another input
          #   order is reversed, but doesn't matter
 f-\5T    # Filter by absence of '5'
l         # Count the number of elements left

Pruébalo en línea!

Perl 6 , 23 bytes

{+grep {!/5/},$^a..$^b}

Pruébalo en línea!

Cómo funciona

{                     }  # A lambda.
              $^a..$^b   # Range between the two lambda arguments.
  grep {!/5/},           # Get those whose string representation doesn't match the regex /5/.
 +                       # Return the size of this list.

Haskell , 39 bytes

s!e=sum[1|x<-[s..e],notElem '5'$show x]

Pruébalo en línea! Uso:

Prelude> 4 ! 17
12

Explicación:

             [s..e]                     -- yields the range from s to e inclusive
          x<-[s..e]                     -- for each x in this range
          x<-[s..e],notElem '5'$show x  -- if the char '5' is not in the string representation of x
       [1|x<-[s..e],notElem '5'$show x] -- then add a 1 to the resulting list      
s!e=sum[1|x<-[s..e],notElem '5'$show x] -- take the sum of the list

R, 33 bytes

f=function(x,y)sum(!grepl(5,x:y))

Uso:

> f=function(x,y)sum(!grepl(5,x:y))
> f(40,60)
[1] 10
> f(1,9)
[1] 8
> f(4,17)
[1] 12

Octava , 36 bytes

@(m,n)sum(all(dec2base(m:n,10)'-52))

Pruébalo en línea!

Groovy, 47 45 43 40 bytes

{a,b->(a..b).findAll{!(it=~/5/)}.size()}

Este es un cierre sin nombre. findAlles similar a agregar unif condición en una lista de comprensión en python.

Pruébalo en línea!

PHP 7.1, 57 55 bytes

for([,$a,$b]=$argv;$a<=$b;)$n+=!strstr($a++,53);echo$n;

Corre con php -r '<code>' <a> <b>

Mathematica, 46 44 42 bytes

¡Gracias a alephalpha y DavidC por guardar 2 bytes cada uno!

Tr@Boole[FreeQ@5/@IntegerDigits@Range@##]&

Función sin nombre que toma dos argumentos enteros y devuelve un entero. IntegerDigits@Range@##convierte todos los números entre las entradas en listas de dígitos; FreeQ@5prueba esas listas para decidir cuáles no contienen ninguna 5. Luego Booleconvierte los booleanos a ceros y unos, y Trsuma los resultados.

Otras soluciones (44 y 47 bytes):

Count[Range@##,x_/;IntegerDigits@x~FreeQ~5]&

IntegerDigits@x~FreeQ~5determina si la lista de dígitos de un número no tiene 5 segundos y Count[Range@##,x_/;...]&cuenta cuántos números entre las entradas pasan esa prueba.

Tr[Sign[1##&@@IntegerDigits@#-5]^2&/@Range@##]&

1##&@@IntegerDigits@#-5toma la lista de dígitos de un número, resta 5 de todos ellos y multiplica las respuestas juntas; Sign[...]^2luego convierte todos los números distintos de cero a 1.

Ruby, 36 35 bytes

->a,b{(a..b).count{|x|!x.to_s[?5]}}

Thx IMP1 para -1 byte

Java 7, 80 78 bytes

int c(int a,int b){int r=0;for(;a<=b;)r+=(""+a++).contains("5")?0:1;return r;}

Sin golf:

int c(int a, int b){
  int r = 0;
  for (; a <= b; ) {
    r += ("" + a++).contains("5")
          ? 0
          : 1;
  }
  return r;
}

Código de prueba:

Pruébalo aquí

class M{
  static int c(int a,int b){int r=0;for(;a<=b;)r+=(""+a++).contains("5")?0:1;return r;}

  public static void main(String[] a){
    System.out.println(c(1, 9));
    System.out.println(c(4, 17));
  }
}

Salida:

8
12

PowerShell, 42 41 bytes

param($a,$b)$a..$b|%{$z+=!($_-match5)};$z

Llamado desde la línea de comando como. \ No5s.ps1 1 20

Python 2, 61 56 bytes

lambda a,b:len([n for n in range(a,b+1) if not"5"in`n`])

-5 bytes gracias a tukkaaX

Swift 52 bytes

($0...$1).filter { !String($0).contains("5") }.count

Lote, 95 bytes

@set/an=0,i=%1
:g
@if "%i%"=="%i:5=%" set/an+=1
@set/ai+=1
@if %i% leq %2 goto g
@echo %n%

El bucle manual ahorra algunos bytes porque de todos modos necesito el contador de bucle en una variable.

PHP, 56 bytes

for($i=$argv[1];$i<=$argv[2];)trim(5,$i++)&&$x++;echo$x;

Corre así:

php -r 'for($i=$argv[1];$i<=$argv[2];)trim(5,$i++)&&$x++;echo$x;' 1 9 2>/dev/null;echo
> 8

Una versión para PHP 7.1 tendría 53 bytes (créditos para Titus):

for([,$i,$e]=$argv;$i<=$e;)trim(5,$i++)&&$x++;echo$x;

Explicación

for(
  $i=$argv[1];          # Set iterator to first input.
  $i<=$argv[2];         # Loop until second input is reached.
)
  trim(5,$i++) && $x++; # Trim string "5" with the characters in the
                        # current number; results in empty string when
                        # `5` is present in the number. If that is not
                        # the case, increment `$x`

echo$x;                 # Output `$x`

CJam "solución matemática pura y fácil", 60

{{Ab5+_,\_5#)<\9e]);_4f>.m9b}%}:F;q~_:z$\:*0>{((+F:-}{F:+)}?

Pruébalo en línea

Toma los números en cualquier orden, en una matriz.

Explicación:

Un problema central es calcular f (n) = el número de números que no son 5 de 1 a n (inclusive) para cualquier n positivo. Y la respuesta es: tome los dígitos decimales de n, reemplace todos los dígitos después de los primeros 5 (si los hay) con 9, luego reemplace todos los dígitos 5..9 con 4..8 (decremento), y convierta desde la base 9. Ej. 1752 → 1759 → 1648 → 1 * 9 ^ 3 + 6 * 9 ^ 2 + 4 * 9 + 8 = 1259. Básicamente, cada posición de dígito tiene 9 valores aceptables, y un 5xxxx es equivalente a un 49999 porque no hay más números válidos entre ellos.

Una vez que resolvimos esto, tenemos algunos casos: si los números de entrada (digamos a y b, a <b) son (estrictamente) positivos, entonces el resultado es f (b) -f (a-1). Si son negativos, entonces podemos tomar los valores absolutos, reordenarlos y usar el mismo cálculo. Y si a <= 0 <= b, entonces el resultado es f (-a) + f (b) +1.

El programa primero implementa la función F como se describió anteriormente (pero se aplica a cada número en una matriz), luego lee la entrada, convierte los números al valor absoluto y los reordena, y usa uno de los 2 cálculos anteriores, en función de si * b> 0 inicialmente.

Python 2 , 54 bytes

i,j=input();k=0
while i<=j:k+=not"5"in`i`;i+=1
print k

Pruébalo en línea!

No es la respuesta más corta de Python. Utiliza el mismo algoritmo pero una forma diferente de implementar con un ciclo while y no es una función lambda.

Java 7, 77 bytes

Esta es una mejora de la respuesta de Kevins , pero dado que aún no tengo la reputación de comentar, esta nueva respuesta tendrá que funcionar.

Entonces lo que hice fue:

• Reemplace las indexOfdeclaraciones concontains (-1 byte)
• Mueva la parte incremental del ciclo for a la instrucción condicional (-2 bytes)

bucle for ( 77 bytes ):

int c(int a,int b){int r=1;for(;a++<b;)r+=(""+a).contains("5")?0:1;return r;}

recursivo ( 79 bytes ):

int d(int r,int a,int b){r+=(""+a).contains("5")?0:1;return a!=b?d(r,a+1,b):r;}

Salida:

8
12

8
12

¡Pruébalo aquí !

C #, 67 bytes

a=>b=>{int c=0;for(;a<=b;)c+=(a+++"").Contains("5")?0:1;return c;};

JavaScript (ES6), 58 56 49 bytes

let f =

(s,e)=>{for(c=0;s<=e;)c+=!/5/.test(s++);return c}

console.log(f(1, 9));
console.log(f(4, 17));
console.log(f(-9, -1));

Golfó 7 bytes gracias a ETHproductions .

MATL , 10 bytes

&:!V53-!As

Pruébalo en línea!

Explicación

        % Implicitly grab two input arguments
&:      % Create an array from [input1....input2]
!V      % Convert to a string where each number is it's own row
53-     % Subtract ASCII '5' from each character.
!A      % Detect which rows have no false values (no 5's). Returns a logical array
s       % Sum the logical array to get the # numbers without 5's
        % Implicitly display the result

C #, 77 bytes

(n,m)=>{var g=0;for(var i=n;i<m+1;i++)g+=(i+"").Contains("5")?0:1;return g;};

Llamada anónima lambda.

Utiliza n(primer número) y m(último número) como entrada, luego verifica mediante la contención de cadena ( "".Contains("")).

En realidad , 13 bytes

u@x`$'5íuY`░l

Pruébalo en línea!

Explicación:

u@x`$'5íuY`░l
u@x            range(a, b+1)
   `$'5íuY`░   take where:
    $            string representation
     '5íuY       does not contain "5"
            l  length