당신의 임무는 음수가 아닌 두 개의 정수 i와 k( i≤ k) 를 취하는 함수 또는 프로그램을 작성하고 모든 정수를 쓴다면 얼마나 많은 0을 쓸지 알아내는 것입니다.ik 선택한 기준에 따라 를 (포함)에 종이 이 정수 (0의 수)를 stdout 또는 이와 유사한 형식으로 출력하십시오.

-30% 세 번째 주장도 받아들이면 b 숫자를 적을 정수형 정수입니다.이 보너스를 달성하려면 최소 2 개의 염기를 처리해야합니다.

• 원하는베이스에서 입력을 수락 할 수 있으며 테스트 케이스간에베이스를 변경할 수 있습니다.
• 당신은 인수를 사용할 수 있습니다 i, k선택적b 당신이 좋아하는 임의의 순서로.
• 답은 단항이 아닌 하나 이상의 염기를 처리해야합니다.

테스트 사례 (기본 10 개) :

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

이것은 코드 골프입니다. 가장 적은 바이트가 이깁니다.

젤리, 1 바이트

¬

이것은 base를 사용하며 k+2,이 경우 단일 0iff가 있습니다.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

파이썬 2, 36 바이트

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

``트릭을위한 진흙 투성이의 신용 .

05AB1E , 3 1 바이트

베이스를 사용 k+2젤리 응답, 코드 같은 :

_

설명:

_  # 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 인코딩을 사용합니다.

apt, 3 바이트

+!U

k+2젤리 답변으로 base를 사용합니다 . iff가 0 i==0입니다.온라인으로 테스트하십시오!

더 나은 버전, 10 8 바이트

UòV ¬è'0

이것은 기초 10을 사용합니다. 온라인으로 테스트하십시오!

보너스 버전, 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의 심각하게 답변처럼 작동합니다.

감사합니다 @Dennis!

첫 번째 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)

루비, 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}

이 "루비"전체를 배우면서 팁을 환영합니다.

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 바이트

이것은 젤리 답변 트릭을 한계로 가져 가고 있지만 간단한 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);

보너스 77.7과 함께 십진, 16 진, 8 진 및 이진 지원

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

보너스 78.4로 기본 2-36 지원

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

자바 스크립트 (ES6), 50 (71-30 %)

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

보너스 없음, 기본 k + 2 는 10 바이트입니다(i,k)=>+!i

보너스 없음, 단항 은 8 바이트입니다(i,k)=>0

테스트

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>

줄프, 7 바이트

교체 ♂와 함께 \x11. 여기 사용해보십시오!

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

루아 74 바이트

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

이 작업을 수행하는 데 더 효과적인 방법이 있어야합니다.

나는 내가 정말로 여기 뭔가 있다고 생각했다.

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)

그러나 아아 ... 내가 잊어 버린 점점 더 많은 제로가 있다는 것을 깨달으면 점점 길어지고 있습니다 ...

APL, 22 바이트

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

이것은 왼쪽과 오른쪽의 범위 경계를 받아들이고 정수를 반환하는 모나드 함수입니다.

언 골프 드 :

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

여기 사용해보십시오

하스켈, 29 바이트

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

기본 10을 사용하고 있습니다 .

사용 예 : 100 # 200->22

작동 원리 :에서 목록의 각 요소를 회전 i에 k그것의 문자열 표현으로, 하나의 문자열로 합칠 수는을 1모든 문자에 대해 '0'그 합계 1들.

MATL , 7 (10 바이트-30 % 보너스)

2$:i:qYA~z

온라인으로 사용해보십시오!

이 문제보다 빠른 릴리스 11.0.2 에서 작동합니다 .

설명

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 바이트

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

낮은 숫자에서 큰 숫자로 벡터를 만든 다음 모든 숫자를 문자열로 변환하고 모든 '0'기호를 계산합니다.

파이썬 3, 52.

보너스를 구현하려고 시도했지만 그만한 가치가없는 것 같습니다.

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

테스트 사례 :

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

펄 6 , 23 바이트

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

1. 범위를 만듭니다 ( $^i..$^k )
2. 값을 공백으로 암시 적으로 결합합니다 ( .combStr 메소드 임).
3. 0으로 만 목록을 만듭니다 ( .comb(/0/))
4. 해당 목록의 요소 수를 반환합니다 ( +).

용법:

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.