Sua tarefa é escrever uma função ou programa que use dois números inteiros não negativos ie k( i≤ k) e descobrir quantos zeros você escreveria se escrevesse todos os números inteiros de iaté k(inclusive) na sua base de escolha em uma peça de papel. Envie esse número inteiro, o número de zeros, para stdout ou similar.

-30%se você também aceitar um terceiro argumento b, a base inteira para anotar os números. Pelo menos duas bases devem ser manipuladas para obter esse bônus.

• Você pode aceitar a entrada em qualquer base que desejar e alterar a base entre os casos de teste.
• Você pode aceitar os argumentos e i, kopcionalmente, bem qualquer ordem que desejar.
• As respostas devem lidar com pelo menos uma base que não é unária.

Casos de teste (na base 10):

i k -> output
10 10 -> 1
0 27 -> 3
100 200 -> 22
0 500 -> 92

Isso é código-golfe; menos bytes vencidos.

Geléia, 1 byte

¬

Isso usa base k+2, caso em que existe um único 0 se 0 ié 0. São necessários dois argumentos, mas aplica o NOT lógico apenas ao primeiro.

Se não queremos trapacear:

7 bytes - 30% = 4,9

-1,1 pontos por @Dennis

rb⁵$¬SS

Isso recebe o bônus.

             dyadic link:
r            inclusive range
 b⁵$           Convert all to base input.
    ¬          Vectorized logical NOT
     S         Sum up 0th digits, 1st digits, etc.
      S        Sum all values

Python 2, 36 bytes

lambda a,b:`range(a,b+1)`.count('0')

Crédito para muddyfish pelo `` truque.

05AB1E , 3 1 byte

Usa base k+2 como a resposta Jelly, Código:

_

Explicação:

_  # Logical NOT operator

Versão sem trapaças de 3 bytes:

Código:

Ÿ0¢

Explicação:

Ÿ    # Inclusive range
 0¢  # Count zeroes

O bônus me dá 3,5 bytes devido a um erro:

ŸB)0¢

Explicação:

Ÿ      # Inclusive range
 B     # Convert to base input
  )    # Wrap into an array (which should not be needed)
   0¢  # Count zeroes

Usa a codificação CP-1252.

Japonês, 3 bytes

+!U

Usa base k+2, como a resposta da geléia. Existe um zero se i==0. Teste online!

Versão melhorada, 10 8 bytes

UòV ¬è'0

Este usa a base 10. Teste online!

Versão bônus, 14 12 bytes - 30% = 8,4

UòV msW ¬è'0

Infelizmente, com o golfe que fiz, o bônus não vale mais a pena ... Teste on-line!

Como funciona

UòV msW ¬è'0   // Implicit: U = start int, V = end int, W = base
UòV            // Create the inclusive range [U..V].
    msW        // Map each item by turning it into a base-W string.
        ¬      // Join into a string.
         è'0   // Count the number of occurances of the string "0".

ES6, 91 86 - 30% = 60,2 bytes

(i,k,b=10)=>([...Array(k+1-i)].map((_,n)=>(i+n).toString(b))+'0').match(/0/g).length-1

Ou salve 3 (2,1) bytes se b não precisar usar o padrão 10.

A melhor versão sem bônus que eu pude fazer foi de 65 bytes:

(i,k)=>([...Array(k+1).keys()].slice(i)+'0').match(/0/g).length-1

Editar: salvou 5 bytes usando o truque de contagem zero de @ edc65.

Sério, 10 bytes

'0,,u@xεjc

Explicação:

'0,,u@xεjc
'0,,u       push "0", i, k+1
     @x     swap i and k+1, range(i, k+1)
       εjc  join on empty string and count 0s

Experimente online!

Com bônus: 11,9 bytes

'0,,u@x,╗`╜@¡`Mεjc

Experimente online!

Explicação:

'0,,u@x,╗`╜@¡`MΣc
'0,,u@x             push "0", range(i, k+1)
       ,╗           push b to register 0
         `   `M     map:
          ╜@¡         push b, push string of a written in base b
               Σc   sum (concat for strings), count 0s

CJam, 12 10 3 bytes

li!

Isso usa o atalho @ThomasKwa.

Se isso não for permitido, aqui está uma resposta de 10 bytes.

q~),>s'0e=

Bom e curto! Funciona como a resposta séria do @ Mego.

Obrigado @Dennis!

Diverti-me escrevendo minha primeira resposta CJam!

Experimente aqui!

T-SQL, 394 bytes (sem bônus)

Eu imagino 'por que não ', certo?

DECLARE @i INT, @k INT SET @i = 100 SET @k = 200  WITH g AS (SELECT @i AS n UNION ALL SELECT n+1 FROM g WHERE n+1<=@k ) SELECT LEN(n) AS c FROM (SELECT STUFF((SELECT REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(n, 1, ''), 2, ''), 3, ''), 4, ''), 5, ''), 6, ''), 7, ''), 8, ''), 9, ''), ' ', '') FROM g FOR XML PATH ('')) ,1,0,'') n ) a OPTION (maxrecursion 0)

E o amigável:

-- CG!

DECLARE @i INT, @k INT 
SET @i = 100
SET @k = 200

WITH g AS 
(
    SELECT @i AS n
    UNION ALL
    SELECT n+1 FROM g WHERE n+1<=@k
)

SELECT LEN(n) AS c FROM 
(
    SELECT 
        STUFF((SELECT REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(n, 1, ''), 2, ''), 3, ''), 4, ''), 5, ''), 6, ''), 7, ''), 8, ''), 9, ''), ' ', '')
FROM g FOR XML PATH ('')) ,1,0,'') n
) a

OPTION (maxrecursion 0)

Ruby, 46 - 30% = 32,2 bytes

Você provavelmente poderia jogar mais isso, mas pelo menos eu recebo o bônus de 30%!

->i,k,b{((i..k).map{|a|a.to_s b}*"").count ?0}

... ou sem o bônus (27 bytes.)

->i,k{([*i..k]*"").count ?0}

Dicas são bem-vindas, ainda aprendendo toda essa coisa de "Ruby".

Braquilog , 26 bytes

,{,.e?}?:1frcS:0xlI,Sl-I=.

Leva a entrada como uma lista [i,k].

Explicação

,{    }?:1f                § Unify the output with a list of all inputs which verify the
                           § predicate between brackets {...} with output set as the input
                           § of the main predicate

  ,.e?                     § Unify the input with a number between i and k with the ouput
                           § being the list [i,k]

           rcS             § Reverse the list and concatenate everything into a single
                           § number (we reverse it to not lose the leading 0 if i = 0 when
                           § we concatenate into a single number). Call this number S.

              :0xlI        § Remove all occurences of 0 from S, call I the length of this new
                           § number with no zeros

                   ,Sl-I=. § Output the length of S minus I.

Julia, 48 bytes - 30% = 33,6

f(i,k,b)=sum(j->sum(c->c<49,[base(b,j)...]),i:k)

Esta é uma função que aceita três números inteiros e retorna um número inteiro. Um dos argumentos especifica a base, portanto, qualifica-se para o bônus.

Ungolfed:

function f(i, k, b)
    # For each j in the inclusive range i to k, convert j to base
    # b as a string, splat the string into a character array, and
    # compare each character to the ASCII code 49 (i.e. '1'). The
    # condition will only be true if the character is '0'. We sum
    # these booleans to get the number of zeros in that number,
    # then we sum over the set of sums to get the result.
    sum(j -> sum(c -> c < 49, [base(b, j)...]), i:k)
end

A implementação do bônus gera uma pontuação apenas um pouco melhor do que a não implementação (34 bytes):

f(i,k)=sum(c->c<49,[join(i:k)...])

Sério, 2 bytes

Isso pode levar o truque de resposta Jelly até o limite, mas aqui está uma resposta simples de 2 bytes a sério.

,Y

Experimente online!

Pitão, 6,3 bytes, com bônus (9 bytes - 30%)

/sjRQ}EE0

Explicação:

  jRQ     - [conv_base(Q, d) for d in V]
     }EE  - inclusive_range(eval(input), eval(input))
 s        - sum(^, [])
/       0 - ^.count(0)

Experimente aqui

Ou 7 bytes sem o bônus:

/`}EE\0

Explicação:

  }EE   - inclusive_range(eval(input), eval(input))
 `      - repr(^)
/    \0 - ^.count("0")

Experimente aqui

Ou use uma suíte de testes

PHP, 50 bytes

suporta apenas decimal

<?=substr_count(join(range($argv[1],$argv[2])),0);

suporta decimal e binário com bônus 63

<?=substr_count(join(array_map([2=>decbin,10=>""][$argv[3]],range($argv[1],$argv[2]))),0);

suporta decimal, hexadecimal, octal e binário com bônus 77.7

<?=substr_count(join(array_map([2=>decbin,8=>decoct,10=>"",16=>dechex][$argv[3]],range($argv[1],$argv[2]))),0);

suporta base 2 - 36 com bônus 78,4

<?=substr_count(join(array_map(function($i){return base_convert($i,10,$_GET[2]);},range($_GET[0],$_GET[1]))),0);

JavaScript (ES6), 50 (71 - 30%)

(n,k,b)=>eval("for(o=0;n<=k;++n)o+=n.toString(b)").match(/0/g).length-1

Sem bônus, a base k + 2 é 10 bytes(i,k)=>+!i

Nenhum bônus, unário é 8 bytes(i,k)=>0

TESTE

f=(n,k,b)=>eval("for(o=0;n<=k;++n)o+=n.toString(b)").match(/0/g).length-1

function go() {
  var i=I.value.match(/\d+/g)
  R.textContent = f(i[0],i[1],i[2])
}

go()

i,k,b:<input id=I value='0,500,10' oninput="go()">
<span id=R></span>

Jolf, 7 bytes

Substitua ♂por \x11. Experimente aqui!

Zl♂sjJ0
   sjJ  inclusive range between two numeric inputs
  ♂      chopped into single-length elements
Zl    0  and count the number of zeroes
        implicitly printed

Lua 74 bytes

z,c=io.read,""for a=z(),z()do c=c..a end o,b=string.gsub(c,"0","")print(b)

Tem que haver uma maneira mais eficaz de fazer isso ...

Eu pensei que estava realmente em algo aqui:

c,m,z=0,math,io.read for a=z(),1+z()do c=c+((m.floor(a/10))%10==0 and 1 or a%100==0 and 1 or a%10==0 and 1 or 0) end print(c)

Mas, infelizmente ... Ele está ficando cada vez mais longo, pois eu percebo que há mais e mais zeros que eu esqueci ...

APL, 22 bytes

{+/'0'⍷∊0⍕¨(⍺-1)↓⍳⍵}

Esta é uma função monádica que aceita os limites do intervalo à esquerda e à direita e retorna um número inteiro.

Ungolfed:

           (⍺-1)↓⍳⍵}  ⍝ Construct the range ⍺..⍵ by dropping the first
                      ⍝ ⍺-1 values in the range 1..⍵
       ∊0⍕¨           ⍝ Convert each number to a string
{+/'0'⍷               ⍝ Count the occurrences of '0' in the string

Experimente aqui

Haskell, 29 bytes

i#k=sum[1|'0'<-show=<<[i..k]]

Estou usando a base 10 .

Exemplo de uso: 100 # 200->22

Como funciona: transforme cada elemento da lista de iem kpara sua representação de string, concatene em uma única string, use a 1para cada caractere '0'e some esses 1s.

MATL , 7 (10 bytes - bônus de 30%)

2$:i:qYA~z

Experimente online!

Isso funciona na liberação 11.0.2 , que é anterior a esse desafio.

Explicação

2$:      % implicitly input two numbers and generate inclusive range
i:q      % input base b and generate vector [0,1,...,b-1]
YA       % convert range to base b using symbols 0,1,...,b-1. Gives 2D array
~        % logical negation. Zeros become 1, rest of symbols become 0
z        % number of nonzero elements in array

Matlab: 27 bytes

@(q,w)nnz(num2str(q:w)==48)

cria um vetor do número mais baixo para o maior, depois converte todos os números em string e conta todos os símbolos '0'.

Python 3, 52.

Tentou implementar o bônus, mas não parece valer a pena.

lambda a,b:''.join(map(str,range(a,b+1))).count('0')

Com casos de teste:

assert f(10, 10) == 1
assert f(0, 27) == 3
assert f(100, 200) == 22
assert f(0, 500) == 92

Perl 6 , 23 bytes

{+($^i..$^k).comb(/0/)}

1. cria um intervalo ( $^i..$^k)
2. une os valores com espaços implicitamente ( .comb é um método Str)
3. cria uma lista apenas dos zeros ( .comb(/0/) )
4. retorna o número de elementos na lista ( + )

Uso:

my &zero-count = {…}

for (10,10), (0,27), (100,200), (0,500), (0,100000) {
  say zero-count |@_
}

1
3
22
92
38895

Mathematica, 39 bytes, 27,3 com bônus

Count[#~Range~#2~IntegerDigits~#3,0,2]&

C # 112 bytes

int z(int i,int k)=>String.Join("",Enumerable.Range(i,k-i+1)).Count(c=>c=='0')

1. Crie uma sequência com números do primeiro até o último número
2. Conte os zero caracteres na sequência

PHP, 84 bytes * .7 = 58,8 (bases 2 a 36)

for(;($v=$argv)[2]>$a=$v[1]++;)$n+=substr_count(base_convert($a,10,$v[3]),0);echo$n;

ou

for(;($v=$argv)[2]>$v[1];)$n+=substr_count(base_convert($v[1]++,10,$v[3]),0);echo$n;

recebe entrada decimal dos argumentos da linha de comando; corra com -r.

PowerShell, 56 54 51 48 42 bytes

param($i,$k)(-join($i..$k)-split0).count-1

Toma entrada, cria um intervalo com $i..$k, em seguida, -joiné que em conjunto numa cadeia de caracteres, seguido por uma expressão regular -splitde comando que separa a cadeia numa matriz de corte nos 0s. Encapsulamos isso com ().count-1para medir quantos zeros. Isso é deixado no pipeline e a produção está implícita.

Guardado 6 bytes graças a @ConnorLSW

Experimente online!

O manuseio de base no PowerShell é limitado e não suporta bases arbitrárias, portanto, não vou pedir o bônus.

Java 8, 102 bytes - 30% = 71,4

Por que não.

(i,k,b)->{int j=0;for(;i<=k;i++)for(char c:Integer.toString(i,b).toCharArray())if(c==48)j++;return j;}

Sem o bônus, 96 bytes (então o bônus realmente melhora minha pontuação!):

(i,k)->{int j=0;for(;i<=k;i++)for(char c:String.valueOf(i).toCharArray())if(c==48)j++;return j;}

Isso implementa o seguinte:

interface Function {
    public int apply(int i, int k, int b);
}

Clojure, 50 49 bytes

#(count(re-seq #"0"(apply str(range %(inc %2)))))

Oh regex é mais curto que a filtragem. Original:

#(count(filter #{\0}(apply str(range %(inc %2)))))

Muito básico, usa o conjunto de caracteres \0para remover outros e conta quantos foram encontrados.