Pergunta:

Você receberá os números inteiros inicial e final de uma sequência e deve retornar o número inteiro que não contém o dígito 5. Os números inicial e final devem ser incluídos!

Exemplos:

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

O resultado pode conter cinco.

O número inicial sempre será menor que o número final. Ambos os números também podem ser negativos!

Estou muito curioso por suas soluções e pela maneira como você as resolve. Talvez alguém encontre uma solução fácil de matemática pura.

Editar Este é um desafio do código-golfe, portanto o código mais curto vence.

JavaScript (ES6), 36 33 bytes

Recebe entrada com sintaxe de currying (a)(b).

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

Formatado e 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 teste

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

Geléia , 8 7 bytes

-1 byte graças a Dennis (use o fato de que a indexação em um número trata esse número como uma lista decimal)

rAw€5¬S

TryItOnline!

Quão?

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

* O átomo de valor absoluto Aé necessário, pois um número negativo convertido para uma lista decimal possui entradas negativas, nenhuma das quais seria um 5(o exemplo dado contaria todos os oito em vez de dois).

Bash + grep, 17 bytes

seq $@|grep -cv 5

Experimente online!

2sable , 6 5 bytes

Guardou um byte graças a Adnan

Ÿ5¢_O

Experimente online!

Explicação

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

Nota: Isso funciona devido a um erro ao ¢fazer a função se aplicar a cada elemento em vez de contar os elementos correspondentes na lista.

Python2, 59 55 52 51 47 43 42 bytes

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

Uma solução recursiva. Agradeço ao @xnor por me motivar a encontrar uma solução usando operadores lógicos! Além disso, obrigado a @ JonathanAllan e @ xnor por me orientarem e cortarem o byte de 43 para 42!

Outras tentativas em 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)

Utilitários Bash / Unix, 21 bytes

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

Experimente online!

05AB1E , 8 7 6 bytes

Guardou um byte graças a Adnan

Ÿ5.å_O

Experimente online!

Explicação

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

Pitão, 9 8 bytes

Guardou um byte graças a FryAmTheEggman!

lf-\5T}E

Explicação:

        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

Experimente online!

Perl 6 , 23 bytes

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

Experimente online!

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

Experimente online! Uso:

Prelude> 4 ! 17
12

Explicação:

             [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

Oitava , 36 bytes

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

Experimente online!

Groovy, 47 45 43 40 bytes

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

Este é um fechamento sem nome. findAllé semelhante a adicionar uma ifcondição em uma compreensão de lista em python.

Experimente online!

PHP 7.1, 57 55 bytes

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

Correr com php -r '<code>' <a> <b>

Mathematica, 46 44 42 bytes

Obrigado a alephalpha e DavidC por economizar 2 bytes cada!

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

Função sem nome, recebendo dois argumentos inteiros e retornando um número inteiro. IntegerDigits@Range@##converte todos os números entre as entradas em listas de dígitos; FreeQ@5testa essas listas para decidir quais não contêm nenhuma 5. Em seguida, Booleconverte booleanos em zeros e uns e Trsoma os resultados.

Outras soluções (44 e 47 bytes):

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

IntegerDigits@x~FreeQ~5determina se a lista de dígitos de um número está livre de 5s e Count[Range@##,x_/;...]&conta quantos números entre as entradas passam no teste.

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

1##&@@IntegerDigits@#-5pega a lista de dígitos de um número, subtrai 5 de todos eles e multiplica as respostas; Sign[...]^2depois converte todos os números diferentes de zero em 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;}

Ungolfed:

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

Código do teste:

Experimente aqui.

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

Saída:

8
12

PowerShell, 42 41 bytes

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

Chamado na linha 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 graças 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%

O loop manual salva alguns bytes porque, de qualquer maneira, eu preciso do contador de loop em uma variável.

PHP, 56 bytes

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

Execute assim:

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

Uma versão para PHP 7.1 seria de 53 bytes (créditos para Titus):

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

Explicação

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 "solução fácil de matemática pura", 60

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

Experimente online

Leva os números em qualquer ordem, em uma matriz.

Explicação:

Um problema central é calcular f (n) = o número de números não-5 de 1 a n (inclusive) para qualquer n positivo. E a resposta é: pegue os dígitos decimais de n, substitua todos os dígitos após os 5 primeiros (se houver) por 9, depois substitua todos os dígitos 5..9 por 4..8 (decremento) e converta da base 9. Por exemplo, 1752 → 1759 → 1648 → 1 * 9 ^ 3 + 6 * 9 ^ 2 + 4 * 9 + 8 = 1259. Basicamente, cada posição de dígito possui 9 valores aceitáveis ​​e um 5xxxx é equivalente a um 49999 porque não há mais números válidos entre eles.

Depois que resolvemos isso, temos alguns casos: se os números de entrada (digamos aeb, a <b) forem (estritamente) positivos, o resultado será f (b) -f (a-1). Se eles são negativos, podemos pegar os valores absolutos, reordená-los e usar o mesmo cálculo. E se a <= 0 <= b, o resultado é f (-a) + f (b) +1.

O programa implementa primeiro a função F conforme descrito acima (mas aplicada a cada número em uma matriz), depois lê a entrada, converte os números no valor absoluto e os reordena e usa um dos 2 cálculos acima, com base em se um * b> 0 inicialmente.

Python 2 , 54 bytes

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

Experimente online!

Não é a resposta mais curta do Python Usa o mesmo algoritmo, mas uma maneira diferente de implementar com um loop while e não é uma função lambda.

Java 7, 77 bytes

Esta é uma melhoria da resposta de Kevins , mas como ainda não tenho reputação de comentar, essa nova resposta terá que ser feita.

Então o que eu fiz foi:

• Substitua as indexOfinstruções porcontains (-1 byte)
• Mova a parte de incremento do loop for para a instrução condicional (-2 bytes)

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

Saída:

8
12

8
12

Teste aqui !

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

Golfed 7 bytes graças a ETHproductions .

MATL , 10 bytes

&:!V53-!As

Experimente online!

Explicação

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

Chamada lambda anônima.

Usa n(primeiro número) e m(último número) como entrada e, em seguida, verifica via contenção de cadeia ( "".Contains("")).

Na verdade , 13 bytes

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

Experimente online!

Explicação:

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