您的任务是编写一个包含两个非负整数i和k（i≤ k）的函数或程序，并弄清楚如果您在选择的基础上将所有整数从i写入k（包括在内），您将写入多少个零。纸 将这个整数（零的个数）输出到stdout或类似值。

-30%如果您还接受第三个参数b，则为整数基数以记下数字。必须处理至少两个基数才能获得此加成。

• 您可以接受任何喜欢的基础输入，也可以在测试用例之间更改基础。
• 您可以接受参数i，k并且可以选择b按任意顺序接受。
• 答案必须处理至少一个不是一元的基数。

测试案例（以10为基础）：

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

这是代码高尔夫球；最少的字节数获胜。

果冻，1个字节

¬

这使用基础 k+2，在这种情况下，只有一个0且iff i是0。它接受两个参数，但仅将逻辑NOT应用于第一个。

如果我们不想作弊：

7个字节-30％= 4.9

-Dennis的-1.1分

rb⁵$¬SS

这得到奖金。

             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个字节

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

将泥泞归功于 ``招数。

05AB1E，3 1字节

使用k+2Jelly答案之类的基础，代码：

_

说明：

_  # Logical NOT operator

3字节非作弊版本：

码：

Ÿ0¢

说明：

Ÿ    # Inclusive range
 0¢  # Count zeroes

由于存在错误，奖金给了我3.5个字节：

ŸB)0¢

说明：

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

使用CP-1252编码。

Japt，3个字节

+!U

使用base k+2作为果冻答案。iff为零i==0。在线测试！

更好的版本，10 8字节

UòV ¬è'0

这个使用base10。在线测试！

奖励版本，14 12字节-30％= 8.4

UòV msW ¬è'0

不幸的是，随着我打高尔夫球，奖金不再值得了…… 在线测试！

怎么运行的

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

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

如果b不需要默认为10，则保存3（2.1）字节。

我能做的最好的非奖金版本是65个字节：

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

编辑：使用@ edc65的零计数技巧保存了5个字节。

认真地，10个字节

'0,,u@xεjc

说明：

'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

在线尝试！

带奖金：11.9字节

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

在线尝试！

说明：

'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个字节

li!

这使用了@ThomasKwa的快捷方式。

如果不允许这样做，那么这是一个10字节的答案。

q~),>s'0e=

好又短！像@Mego的认真回答一样工作。

谢谢@丹尼斯！

很高兴写我的第一个CJam答案！

在这里尝试！

T-SQL，394字节（无奖励）

我想'为什么不 '，对吗？

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)

和友好的：

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

您可能可以打更多的高尔夫球，但至少我可以获得30％的奖金！

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

...或没有奖金（27个字节）。

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

欢迎技巧，仍然学习整个“ Ruby”知识。

Brachylog，26个字节

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

将输入作为列表 [i,k]。

说明

,{    }?: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.

朱莉娅，48字节-30％= 33.6

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

该函数接受三个整数并返回一个整数。其中一个参数指定了基数，因此有资格获得奖金。

取消高尔夫：

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

实施奖金产生的分数仅比不实施奖金（34字节）好一点：

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

认真地，2个字节

这可能使Jelly答案技巧达到了极限，但这是一个简单的2字节认真回答。

,Y

在线尝试！

Pyth，6.3个字节，带奖励（9个字节-30％）

/sjRQ}EE0

说明：

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

在这里尝试

或无额外奖励的7个字节：

/`}EE\0

说明：

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

在这里尝试

或使用测试套件

PHP，50字节

仅支持小数

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

支持奖金63的十进制和二进制

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

supports decimal,hexadecimal, octal and binary with Bonus 77.7

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

supports base 2 - 36 with 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

No bonus, base k+2 is 10 bytes (i,k)=>+!i

No bonus, unary is 8 bytes (i,k)=>0

TEST

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.