Il tuo compito è quello di scrivere una funzione o un programma che accetta due numeri interi non negativi ie k( i≤ k) e capire quanti zeri scriveresti se scrivessi tutti i numeri interi da ia k(compreso) nella tua base di scelta su un pezzo di carta. Invia questo numero intero, il numero di zero, a stdout o simile.

-30%se accetti anche un terzo argomento b, la base intera per annotare i numeri. Almeno due basi devono essere gestite per ottenere questo bonus.

• È possibile accettare l'input in qualsiasi base desiderata e modificare la base tra i casi di test.
• Puoi accettare gli argomenti e i, kfacoltativamente, bnell'ordine che preferisci.
• Le risposte devono gestire almeno una base non unaria.

Casi di prova (nella base 10):

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

Questo è code-golf; vincono meno byte.

Gelatina, 1 byte

¬

Questo utilizza base k+2, nel qual caso c'è un solo 0 iffi è 0. Prende due argomenti, ma applica il NOT logico solo al primo.

Se non vogliamo imbrogliare:

7 byte - 30% = 4,9

-1.1 punti di @Dennis

rb⁵$¬SS

Questo ottiene il 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 byte

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

Ringraziamo il pesce fangoso per il `` trucco.

05AB1E , 3 1 byte

Utilizza la base k+2come la risposta Jelly, codice:

_

Spiegazione:

_  # Logical NOT operator

Versione non cheat di 3 byte:

Codice:

Ÿ0¢

Spiegazione:

Ÿ    # Inclusive range
 0¢  # Count zeroes

Il bonus mi dà 3,5 byte a causa di un bug:

ŸB)0¢

Spiegazione:

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

Utilizza la codifica CP-1252.

Japt, 3 byte

+!U

Usa la base k+2, come risposta della gelatina. C'è un iff zero i==0. Provalo online!

Versione migliore, 10 8 byte

UòV ¬è'0

Questo utilizza la base 10. Provalo online!

Versione bonus, 14 12 byte - 30% = 8.4

UòV msW ¬è'0

Purtroppo, con il golf che ho fatto, il bonus non vale più la pena ... Provalo online!

Come funziona

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 byte

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

Oppure salva 3 (2.1) byte se b non deve essere impostato automaticamente su 10.

La migliore versione non bonus che potevo fare era di 65 byte:

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

Modifica: salvato 5 byte usando il trucco di conteggio zero di @ edc65.

Scherzi a parte, 10 byte

'0,,u@xεjc

Spiegazione:

'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

Provalo online!

Con bonus: 11,9 byte

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

Provalo online!

Spiegazione:

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

li!

Questo utilizza la scorciatoia che fa @ThomasKwa.

Se ciò non è consentito, ecco una risposta da 10 byte.

q~),>s'0e=

Bello e breve! Funziona come la risposta seria di @ Mego.

Grazie @Dennis!

Mi sono divertito a scrivere la mia prima risposta CJam!

Provalo qui!

T-SQL, 394 byte (nessun bonus)

Immagino "perché no ", giusto?

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 quello amichevole:

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

Rubino, 46-30% = 32,2 byte

Probabilmente potresti giocare ancora a golf, ma almeno ottengo il bonus del 30%!

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

... o senza il bonus (27 byte.)

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

I suggerimenti sono ben accetti, sto ancora imparando tutta questa faccenda "Ruby".

Brachylog , 26 byte

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

Accetta input come elenco [i,k] .

Spiegazione

,{    }?: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 byte - 30% = 33.6

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

Questa è una funzione che accetta tre numeri interi e restituisce un numero intero. Uno degli argomenti specifica la base, quindi questo si qualifica per il bonus.

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

L'implementazione del bonus produce un punteggio appena migliore rispetto al non implementarlo (34 byte):

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

Scherzi a parte, 2 byte

Questo potrebbe portare il trucco della risposta Jelly al limite, ma ecco una semplice risposta seriamente da 2 byte.

,Y

Provalo online!

Pyth, 6.3 bytes, with bonus (9 bytes - 30%)

/sjRQ}EE0

Explanation:

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

Try it here

Or 7 bytes without the bonus:

/`}EE\0

Explanation:

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

Try it here

Or use a test suite

PHP, 50 Bytes

supports decimal only

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

supports decimal and binary with Bonus 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.