Su tarea es escribir una función o programa que tome dos enteros no negativos iy k( i≤ k), y calcule cuántos ceros escribiría si escribiera todos los números enteros desde ihasta k(inclusive) en su base de elección en una pieza de papel. Genere este número entero, el número de ceros, en stdout o similar.

-30%si también acepta un tercer argumento b, la base entera para anotar los números. Se deben manejar al menos dos bases para lograr este bono.

• Puede aceptar la entrada en cualquier base que desee, y puede cambiar la base entre casos de prueba.
• Puede aceptar los argumentos y i, kopcionalmente, ben el orden que desee.
• Las respuestas deben manejar al menos una base que no sea unaria.

Casos de prueba (en base 10):

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

Este es el código de golf; menos bytes ganan.

Jalea, 1 byte

¬

Esto usa base k+2, en cuyo caso hay un solo 0 iff ies 0. Toma dos argumentos, pero aplica el NOT lógico solo al primero.

Si no queremos hacer trampa:

7 bytes - 30% = 4.9

-1.1 puntos por @Dennis

rb⁵$¬SS

Esto recibe la bonificación.

             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 a muddyfish por el `` truco.

05AB1E , 3 1 byte

Utiliza la base k+2como la respuesta Jelly, Código:

_

Explicación:

_  # Logical NOT operator

Versión de 3 bytes sin trampa:

Código:

Ÿ0¢

Explicación:

Ÿ    # Inclusive range
 0¢  # Count zeroes

El bono me da 3.5 bytes debido a un error:

ŸB)0¢

Explicación:

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

Utiliza la codificación CP-1252.

Japt, 3 bytes

+!U

Utiliza base k+2, como responde la gelatina. Hay un cero iff i==0.¡Pruébalo en línea!

Mejor versión, 10 8 bytes

UòV ¬è'0

Este usa la base 10. Pruébelo en línea!

Versión de bonificación, 14 12 bytes - 30% = 8.4

UòV msW ¬è'0

Lamentablemente, con el golf que hice, el bono ya no vale la pena ... Pruébelo en línea!

Cómo 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

O guarde 3 (2.1) bytes si b no necesita tener un valor predeterminado de 10.

La mejor versión sin bonificación que pude hacer fue 65 bytes:

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

Editar: guardado 5 bytes usando el truco de conteo cero de @ edc65.

En serio, 10 bytes

'0,,u@xεjc

Explicación:

'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

Pruébalo en línea!

Con bonificación: 11.9 bytes

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

Pruébalo en línea!

Explicación:

'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!

Esto usa el atajo que hace @ThomasKwa.

Si esto no está permitido, entonces aquí hay una respuesta de 10 bytes.

q~),>s'0e=

Agradable y corto! Funciona como la respuesta seria de @Mego.

Gracias @ Dennis!

¡Me divertí escribiendo mi primera respuesta de CJam!

Pruébalo aquí!

T-SQL, 394 bytes (sin bonificación)

Me imagino 'por qué no ', ¿verdad?

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)

Y el amigable:

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

Probablemente podría jugar más, pero al menos obtengo el 30% de bonificación.

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

... o sin la bonificación (27 bytes).

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

Los consejos son bienvenidos, todavía estoy aprendiendo todo este asunto de "Ruby".

Brachylog , 26 bytes

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

Toma la entrada como una lista [i,k].

Explicación

,{    }?: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 es una función que acepta tres enteros y devuelve un entero. Uno de los argumentos especifica la base, por lo que califica para la bonificación.

Sin golf:

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

Implementar el bono produce una puntuación apenas mejor que no implementarlo (34 bytes):

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

En serio, 2 bytes

Esto podría llevar el truco de respuesta Jelly al límite, pero aquí hay una respuesta simple de 2 bytes en serio.

,Y

Pruébalo en línea!

Pyth, 6.3 bytes, con bonificación (9 bytes - 30%)

/sjRQ}EE0

Explicación:

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

Pruébalo aquí

O 7 bytes sin la bonificación:

/`}EE\0

Explicación:

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

Pruébalo aquí

O use una suite de prueba

PHP, 50 bytes

solo admite decimales

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

admite decimal y binario con Bonus 63

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

admite decimal, hexadecimal, octal y binario con Bonus 77.7

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

admite base 2 - 36 con Bonus 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

Sin bonificación, la base k + 2 es de 10 bytes(i,k)=>+!i

Sin bonificación, unario es de 8 bytes(i,k)=>0

PRUEBA

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

Reemplazar ♂con \x11. Pruébalo aquí!

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)

Tiene que haber una forma más efectiva de hacer esto ...

Pensé que realmente estaba en algo aquí:

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)

But alas... It keeps getting longer and longer as I realize there's more and more zeroes I forgot about...

APL, 22 bytes

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

This is a monadic function that accepts the range boundaries on the left and right and returns an integer.

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

Try it here

Haskell, 29 bytes

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

I'm using base 10.

Usage example: 100 # 200 -> 22

How it works: turn each element in the list from i to k into it's string representation, concatenate into a single string, take a 1 for every char '0' and sum those 1s.

MATL, 7 (10 bytes − 30% bonus)

2$:i:qYA~z

Try it online!

This works in release 11.0.2, which is earlier than this challenge.

Explanation

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)

creates a vector from lower number to larger one, then converts all numbers to string and counts all the '0' symbols.

Python 3, 52.

Tried to implement the bonus, but it doesn't seem to be worth it.

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

With test cases:

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. creates a Range ( $^i..$^k )
2. joins the values with spaces implicitly ( .comb is a Str method )
3. creates a list of just the zeros ( .comb(/0/) )
4. returns the number of elems in that list ( + )

Usage:

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 with bonus

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. Create a string with numbers from the first number up to the last number
2. Count the zero characters in the string

PHP, 84 bytes *.7=58.8 (bases 2 to 36)

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

or

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

takes decimal input from command line arguments; run with -r.

PowerShell, 56 54 51 48 42 bytes

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

Takes input, creates a range with $i..$k then -joins that together into a string, followed by a regex -split command that separates the string into an array by slicing at the 0s. We encapsulate that with ().count-1 to measure how many zeros. That's left on the pipeline, and output is implicit.

Saved 6 bytes thanks to @ConnorLSW

Try it online!

Base-handling in PowerShell is limited and doesn't support arbitrary bases, so I'm not going for the bonus.

Java 8, 102 bytes - 30% = 71.4

Why not.

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

Without the bonus, 96 bytes (so the bonus actually improves my score!):

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

This implements the following:

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 is shorter than filtering. Original:

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

Very basic, uses the set of character \0 to remove others and counts how many were found.