Votre tâche consiste à écrire une fonction ou un programme qui prend deux entiers non négatifs iet k( i≤ k), et à déterminer combien de zéros vous écririez si vous écriviez tous les nombres entiers de ià k(inclus) dans votre base de choix sur une pièce de papier. Sortez cet entier, le nombre de zéros, vers stdout ou similaire.

-30%si vous acceptez également un troisième argument b, la base entière pour écrire les nombres. Au moins deux bases doivent être manipulées pour obtenir ce bonus.

• Vous pouvez accepter l'entrée dans n'importe quelle base de votre choix, et vous pouvez changer la base entre les cas de test.
• Vous pouvez accepter les arguments i, ket éventuellement bdans l'ordre que vous souhaitez.
• Les réponses doivent gérer au moins une base qui n'est pas unaire.

Cas de test (en base 10):

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

C'est du code-golf; le moins d'octets gagne.

Gelée, 1 octet

¬

Ceci utilise la base k+2, auquel cas il y a un seul 0 si siffle iest 0. Il prend deux arguments, mais applique le NON logique uniquement au premier.

Si nous ne voulons pas tricher:

7 octets - 30% = 4,9

-1,1 points par @Dennis

rb⁵$¬SS

Cela obtient le bonus.

             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 octets

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

Crédit muddyfish pour le tour ``.

05AB1E , 3 1 octet

Utilise une base k+2comme la réponse Jelly, Code:

_

Explication:

_  # Logical NOT operator

Version 3 octets sans triche:

Code:

Ÿ0¢

Explication:

Ÿ    # Inclusive range
 0¢  # Count zeroes

Le bonus me donne 3,5 octets en raison d'un bug:

ŸB)0¢

Explication:

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

Utilise l'encodage CP-1252.

Japt, 3 octets

+!U

Utilise la base k+2, comme la réponse de Jelly. Il y a un zéro ssi i==0. Testez-le en ligne!

Meilleure version, 10 8 octets

UòV ¬è'0

Celui-ci utilise la base 10. Testez-le en ligne!

Version bonus, 14 12 octets - 30% = 8,4

UòV msW ¬è'0

Malheureusement, avec le golf que j'ai fait, le bonus n'en vaut plus la peine ... Testez-le en ligne!

Comment ça fonctionne

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 octets

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

Ou économisez 3 (2,1) octets si b n'a pas besoin d'être réglé par défaut sur 10.

La meilleure version non bonus que je pouvais faire était de 65 octets:

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

Edit: économisé 5 octets en utilisant l'astuce de comptage zéro de @ edc65.

Sérieusement, 10 octets

'0,,u@xεjc

Explication:

'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

Essayez-le en ligne!

Avec bonus: 11,9 octets

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

Essayez-le en ligne!

Explication:

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

li!

Cela utilise le raccourci que fait @ThomasKwa.

Si cela n'est pas autorisé, voici une réponse de 10 octets.

q~),>s'0e=

Agréable et court! Fonctionne comme la réponse Serious de @ Mego.

Merci @Dennis!

Je me suis amusé à écrire ma première réponse CJam!

Essayez-le ici!

T-SQL, 394 octets (sans bonus)

Je me dis «pourquoi pas », non?

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)

Et le sympathique:

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

Vous pourriez probablement jouer au golf plus, mais au moins, j'obtiens le bonus de 30%!

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

... ou sans bonus (27 octets.)

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

Les conseils sont les bienvenus, tout en apprenant toute cette chose "Ruby".

Brachylog , 26 octets

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

Prend la saisie sous forme de liste [i,k] .

Explication

,{    }?: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 octets - 30% = 33,6

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

Il s'agit d'une fonction qui accepte trois entiers et renvoie un entier. L'un des arguments spécifie la base, donc cela donne droit au bonus.

Non 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

La mise en œuvre du bonus donne un score à peine meilleur que la non mise en œuvre (34 octets):

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

Sérieusement, 2 octets

Cela pourrait amener la réponse Jelly à la limite, mais voici une réponse sérieuse simple de 2 octets.

,Y

Essayez-le en ligne!

Pyth, 6,3 octets, avec bonus (9 octets - 30%)

/sjRQ}EE0

Explication:

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

Essayez-le ici

Ou 7 octets sans le bonus:

/`}EE\0

Explication:

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

Essayez-le ici

Ou utilisez une suite de tests

PHP, 50 octets

prend en charge les décimales uniquement

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

prend en charge décimal et binaire avec Bonus 63

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

prend en charge décimal, hexadécimal, octal et binaire avec Bonus 77.7

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

prend en charge la base 2-36 avec 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

Pas de bonus, la base k + 2 est de 10 octets(i,k)=>+!i

Pas de bonus, unaire fait 8 octets(i,k)=>0

TESTER

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

Replace ♂ with \x11. Try it here!

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)

There's gotta be a more effective way to do this...

I thought I was really onto something here:

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.