2.000.000'dan küçük pozitif tamsayı kaç basamak içeriyor? . Ben tüm Tamsayılar saymak en yaratıcı çözüm arıyorum Xiçin Ytamsayı içeren Z. Z0 ile arasında olabilir Y.

Bulunan her Tamsayı, bir tamsayı Zdaha sık görünse bile yalnızca bir kez sayılır . Örneğin:

Z = 2
123 counts 1
22222 also counts 1

Java ile yazılmış gerçekten basit bir algoritma ile başlayacağım (çünkü herkes tarafından sevilir):

public class Count {
    public static void main(String[] args) {
        int count = 0;
        for (int i = Integer.parseInt(args[0]); i <= Integer.parseInt(args[1]); i++) {
            if (Integer.toString(i).contains(args[2])) {
                count++;
            }
        }
        System.out.println(count);
    }
}

eğer bunu

java -jar Count.jar 0 1000000 2

bunu sonuç olarak alırsınız:

468559

Bu sorunu çözmek zor olmadığı için sadece popülerlik yarışması . En çok oylanan cevap 28 Şubat kazanır!

bash (20)

seq $1 $2|grep -c $3

kullanım

$ bash count.sh 0 1000000 2
468559

funciton

Her zaman olduğu gibi, StackExchange tarafından eklenen satır yüksekliği satırları ayırdığından, $('pre').css('line-height',1)bunu düzeltmek için tarayıcı konsolunuzda çalışmayı düşünün .

Diğer Funciton cevaplarımın aksine, bu herhangi bir işlev bildirimi kullanmaz. Bu sadece bir program. Yine de bir lambda ifadesi kullanıyor - Aralık ayında Funciton'a eklediğim bir özellik :)

Girdinin boşlukla (yani x y z) ayrılmış üç ondalık tam sayı (negatif olabilir) olmasını bekler . Aslında, zherhangi bir dize olabilir; örneğin, −aralıktaki negatif sayıların sayısını saymak sadece eksi işareti ( , U + 2212) olabilir :)

           ┌───╖
     ┌───┬─┤ ♯ ╟──────────┐
     │   │ ╘═══╝ ╔════╗ ┌─┴─╖             ┌────╖ ╔═══╗
   ┌─┴─╖ └────┐  ║ 21 ║ │ × ╟─────────────┤ >> ╟─╢   ║
 ┌─┤ ʃ ╟───┐  │  ╚══╤═╝ ╘═╤═╝             ╘═╤══╝ ╚═══╝
 │ ╘═╤═╝   │  └──┐  └─────┘   ┌───────────┐ │
 │ ╔═╧═╗ ┌─┴─╖ ┌─┴─╖ ╔════╗ ┌─┴─╖   ┌───╖ ├─┴────────┐
 │ ║   ╟─┤ · ╟─┤ ʘ ╟─╢ 32 ╟─┤ · ╟───┤ ʘ ╟─┘          │
 │ ╚═══╝ ╘═╤═╝ ╘═══╝ ╚════╝ ╘═╤═╝   ╘═╤═╝ ┌─────┐    │
 │         └───────┐  ╔═══╗ ┌─┴─╖     │ ┌─┴─╖   │    │
 │ ┌───────────┐   └──╢ 0 ╟─┤ ʃ ╟─┐   │ │ ♯ ║   │    │
 │ │   ┌───╖ ┌─┴─╖    ╚═══╝ ╘═╤═╝ │   │ ╘═╤═╝ ┌─┴─╖  │
 │ │ ┌─┤ ♯ ╟─┤   ╟─┬─┐ ╔════╗ │ ┌─┴─╖ │   │ ┌─┤ × ║  │
 │ │ │ ╘═══╝ └─┬─╜ └─┘ ║ −1 ║ └─┤ · ╟─┴───┘ │ ╘═╤═╝  │
 │ │ │    ┌────┴────┐  ╚══╤═╝   ╘═╤═╝       │ ╔═╧══╗ │
 │ │ │    │ ┌───╖ ┌─┴─╖ ┌─┴─╖ ┌───┴─────╖   │ ║ 21 ║ │
 │ │ │    └─┤ ♯ ╟─┤ ? ╟─┤ = ║ │ str→int ║   │ ╚════╝ │
 │ │ │      ╘═══╝ ╘═╤═╝ ╘═╤═╝ ╘═╤═══════╝   │ ┌────╖ │
 │ │ │      ╔═══╗ ┌─┴─╖   └─┐ ┌─┴─╖         └─┤ >> ╟─┘
 │ │ │      ║ 0 ╟─┤ ? ╟─┐   └─┤ · ╟───┐       ╘═╤══╝
 │ │ │      ╚═══╝ ╘═╤═╝ └─┐   ╘═╤═╝   └───┐   ┌─┴─╖
 │ │ │            ┌─┴─╖   └─┐ ┌─┴─╖       └───┤ ʘ ║
 │ │ └────────────┤ · ╟─┐   └─┤ ≤ ║           ╘═╤═╝
 │ │              ╘═╤═╝ │     ╘═╤═╝ ┌─────────╖ │
 │ │        ╔═══╗ ╔═╧═╕ │       └─┬─┤ int→str ╟─┘
 │ │        ║ 0 ╟─╢   ├─┤         │ ╘═════════╝
 │ │        ╚═══╝ ╚═╤═╛ └─────────┘
 │ └────────────────┴─┐              │
 │    ┌─────────╖   ┌─┴─╖ ┌─┐   ┌────┴────╖
 └────┤ str→int ╟───┤   ╟─┴─┘   │ int→str ║
      ╘═════════╝   └─┬─╜       ╘════╤════╝
                      └──────────────┘

C #

public class Program
{
    public static void Main(string[] args)
    {
        Console.WriteLine(Enumerable.Range(Convert.ToInt32(args[0]), (Convert.ToInt32(args[1]) + 1) - Convert.ToInt32(args[0])).Count(x => x.ToString().Contains(args[2])));
    }
}

Misal

count.exe 0 1000000 2
468559

APL (29)

{+/∨/¨(⍕⍺)∘⍷¨⍕¨⊃{⍺+0,⍳⍵-⍺}/⍵}

Bu, Zsol argüman olarak ve aralık [X,Y]sağ argüman olarak alan bir işlevdir :

      2 {+/∨/¨(⍕⍺)∘⍷¨⍕¨⊃{⍺+0,⍳⍵-⍺}/⍵} 0 1e6
468559
      0 {+/∨/¨(⍕⍺)∘⍷¨⍕¨⊃{⍺+0,⍳⍵-⍺}/⍵} 0 1e6
402131
      42 {+/∨/¨(⍕⍺)∘⍷¨⍕¨⊃{⍺+0,⍳⍵-⍺}/⍵} 0 1e6
49401

Python 2.7

Hız İhtiyacı

açıklama

uygulama

def Count(lo,hi,key):
    if hi == 0: return 0
    # Count(lo,hi,key) = Count(0,hi,key) - Count(0,lo - 1,key)
    if lo != 0: return Count(0, hi, key) - Count(0, lo - 1, key)
    # Calculate no of digits in the number to search
    # LOG10(hi) may be a descent trick but because of float approximation
    # this would not be reliable
    n = len(str(hi)) - 1
    # find the most significant digit
    a_n = hi/10**n
    if a_n < key:
        count = a_n*(10**n - 9**n)
    elif a_n > key:
        count = (a_n - 1)*(10**n - 9**n) + 10**n
    else:
        count = a_n*(10**n - 9**n) + 1
    if hi % 10**n != 0:
        if a_n != key:
            return count + Count(0, hi%10**n, key)
        else:
            return count + hi%10**n
    else:
        return count

gösteri

In [2]: %timeit Count(0,123456789987654321,2)
100000 loops, best of 3: 13.2 us per loop

karşılaştırma

@Dennis

$ \time -f%e bash count.sh 0 1234567 2
585029
11.45

@arshajii

In [6]: %timeit count(0,1234567,2)
1 loops, best of 3: 550 ms per loop

Python 2.7

Düzenli ifadeler kullanan bir çözüm:

>>> from re import findall as f
>>> count=lambda x,y,z:len(f('\d*%d\d*'%z,str(range(x,y+1))))
>>>
>>> count(0,1000000,2)
468559

bash - 32 31 17 14 karakter + X, Y ve Z uzunluğu

Önerdiği için devnull teşekkürler seq!

seq [X] [Y]|grep -c [Z]

örneğin X = 100, Y = 200, Z = 20

$ seq 100 200|grep -c 20
2

örneğin X = 100, Y = 200, Z = 10

$ seq 100 200|grep -c 10
11

örneğin X = 0, Y = 1000000, Z = 2

$ seq 0 1000000|grep -c 2
468559

PHP

Orijinal bir şey yok, sadece ilk yazımı burada kutluyorum.

<?php

    $x = $argv[1];
    $y = $argv[2];
    $z = $argv[3];
    $count = 0;

    do
    {
        if (!(strpos($x, $z) === false))
            $count++;
        $x++;
    } while ($x <= $y);

    echo $count;

?>

Giriş

php script.php 0 1000000 2

Çıktı

468559

Scala:

args(0).toInt to args(1).toInt count (_.toString contains args(2))

Yakut

Bu azaltmak için harika bir örnek!

puts (ARGV[0]..ARGV[1]).reduce(0) { |c, n| n.to_s.include?(ARGV[2].to_s) ? c + 1 : c }

Giriş:

ruby script.rb 0 1000000 2

Çıktı:

468559

Python golf - 61

f=lambda x,y,z:len([i for i in range(x,y)if str(z)in str(i)])

Python golf dışı

def f(x, y, z):
    c = 0
    for i in range(x, y):
        c += str(z) in str(i)
    return c

Java8

Yeni IntStream öğelerini kullanarak, zorunlu Java Framework öğelerini yoksayarsanız, bu aslında tek bir astar olur:

import java.util.stream.IntStream;
public class A{
  public static void main(String[] args){
    System.out.println(IntStream.rangeClosed(Integer.parseInt(args[0], Integer.parseInt(args[1])).filter(x -> ((Integer)x).toString().contains(args[2])).count());
  }
}

Değerleri sabit kodlamak zorunda kalmama rağmen burada çalıştırılabilir .

F #

Bu çözüm IndexOf, dizeyi aramak için kullanır , ardından sonucu bulursanız 1'e ve bulunamazsa 0'a dönüştürmek için biraz sayı kıpırdanır, ardından sonucu toplar:

let count x y (z : string) = 
    [ x .. y ] |> Seq.sumBy(fun n -> min 1 (n.ToString().IndexOf z + 1))

Ve şöyle de adlandırılabilir:

count 0 1000000 "2" // 468559

Düzenli ifade

Aşağıda 49'a kadar 1'in rakamları sayılır.

#!/bin/bash

echo "12313451231241241111111111111111111111111111111111111"  |\  
sed "s/[^1]//g;s/11111/5/g;s/1111/4/g;s/111/3/g;s/11/2/g;s/555555555/45/g;s/55555555/40/g;s/5555555/35/g;s/555555/30/g;s/55555/25/g;s/5555/20/g;s/555/15/g;s/55/10/g;s/54/9/g;s/53/8/g;s/52/7/g;s/51/6/g;s/50/5
/g;s/40/4/g;s/30/3/g;s/20/2/g;s/10/1/g"

R 23 25 27karakter

Sadece iş için doğru aleti al. R'de grep basit kullanımı, hiçbir şey fantezi.

Yaptığı şey budur: vektördeki greptüm örnekler kadar ve kullanarak sonuç sayısını sayın .2010e6length

length(grep(2,0:100000,value=TRUE))

length(grep(2,0:10e6))

Sonuç: [1] 468559

Offcourse, sayıları örnekte gösterildiği gibi giriş olarak alan bir işlev yazabilirsiniz.

count = function(x=0, y=1000000, z=2){
  length(grep(z,x:y))
}

Şimdi countx, y ve z ile çağrı yapabilirsiniz , eğer ayarlanmamışsa (varsayılan olarak), x, y ve z değerleri sırasıyla 0, 1000000 ve 2'dir. Bazı örnekler:

count()
[1] 468559

veya

count(20, 222, 2)
[1] 59

veya

count(0, 100, 10)
[1] 2

Burada bazıları zamanın önemli olduğunu düşünüyor, bu işlevi R'de kullanmak yaklaşık 1 saniye sürüyor.

system.time(count())
user  system elapsed 
0.979   0.003   0.981

JavaScript (ES6), 63

f=(i,j,n)=>{for(c=0;i<=j;!~(''+i++).indexOf(n)?0:c++);return c}

Kullanımı:

f(0, 1e6, 2)
> 468559

Un-golfed:

f = (i,j,n) => {
  for(
    // Initialize the counter.
    c=0;
    // Iterate through all integers.
    i<=j;
    // Convert current number into string then increment it.
    // Check if the digit appears into the current number.
    !~(''+i++).indexOf(n)
      // Occurence not found.
      ? 0
      // Occurence found.
      // Add 1 to the counter.
      : c++
  );
  return c
}

Yakut

Temelde Pablo'nun cevabını aldım ve yarı golf oynadım (gereksiz boşluk bırakırsanız 38 karakter) bunu çok büyük olmayan bir örnek haline getirdim select.

Bu serideki tüm indeksini seçer (x .. y)içerir z. Bu ara sonuç maalesef boyutu daha sonra döndürülen bir dizide saklanır.

x,y,z = $*
p (x..y).select{ |i| i[z] }.size

i[z]Parça gerçekten anlamlı görünmese de hem sözdizimsel hem de anlamsal olarak oldukça düzgün görünüyor.

Çünkü çalışır xve yaslında sayıları değil, dizeleri vardır! Böylece her ibiri bir dizedir ve i[z]elbette dizenin ziçerip içermediğini kontrol eder i.

$ ruby count-digits.rb 100 200 20
2
$ ruby count-digits.rb 0 1000000 2
468559

Python 2.7, 70 işaretler

f = lambda x,y,z: sum(map(lambda x: str(z) in str(x), range(0, y+1)))

>>> f(0, 1000000, 2)
468559

Daha kısa, 65 işaret

g = lambda x, y, z: sum(str(z) in str(i) for i in range(0, y+1))
>>> g(0, 1000000, 2)
468559

Ruby'nin kullanımı Enumerable#grep:

start, stop, target = $*
p (start..stop).grep(Regexp.new target).size

T-SQL

Ben değişkenleri varsayabiliriz ise @X, @Yve @Zkullanılabilir:

Mevcut sayı tablosuyla (keyfi olarak büyük;) 65

select count(*)from n where n>=@X and n<=@Y and n like '%'+@Z+'%'

Özyinelemeli CTE ile - 127

with n(n)as(select @X union all select n+1 from n where n<@Y)select count(*)from n where n like'%'+@Z+'%'option(MAXRECURSION 0)

Değişkenlerin açıkça tanımlanması gerekiyorsa:

Her iki yanıta 58 ekleyin - Sayılar tablosu: 123, Yinelemeli CTE: 185

declare @X int=0;declare @Y int=100;declare @Z varchar(30)='2';

Özyinelemeli CTE'nin ne kadar bellek kullanabileceğine dair hiçbir fikrim yok, ancak kesinlikle herhangi bir hız yarışması kazanmayacak. Sistemimde 0 ile 1000000 arasında 2 arama örneği 8 saniye sürüyor.

Herkes oynamak isterse bir SQL Fiddle . 1000000 sorgusunun çalışması 30 saniyeden fazla sürer.

Rebol'un

; version 1 (simple loop counting)

count: func [x [integer!] y [integer!] z [integer!] /local total] [
    total: 0
    for n x y 1 [if found? find to-string n z [++ total]]
    total
]


; version 2 (build series/list and get length)

count: func [x [integer!] y [integer!] z [integer!]] [
    length? collect [for n x y 1 [if find to-string n z [keep true]]]
]

Rebol konsolundaki (REPL) kullanım örneği:

>> count 0 1000000 2
== 468559

Güç kalkanı

İki çözüm, her ikisi de 40 37 karakter.

PowerShell'in tüm sürümleri için:

$a,$b,$c=$args;($a..$b-match$c).count

PowerShell V3 ve üstü için slstakma ad var Select-String. Bunun için, @yalnızca bir değer ardışık düzenden geçiyorsa bir diziyi zorlamak gerekir .

$a,$b,$c=$args;@($a..$b|sls $c).count

yığın

@setLocal enableDelayedExpansion&@set a=0&@for /L %%a in (%1,1,%2) do @set b=%%a&@if "!b:%3=!" NEQ "!b!" @set/aa+=1
@echo !a!

H:\uprof>count 0 1000000 2
468559

H:\uprof>count 1 2 3
0

Biraz daha okunabilir -

@setLocal enableDelayedExpansion
@set a=0
@for /L %%a in (%1,1,%2) do (
    @set b=%%a
    @if "!b:%3=!" NEQ "!b!" @set/aa+=1
)
@echo !a!

Güzel ve basit. Değişkenin !b!üçüncü kullanıcı girişi olmadan kendisiyle aynı olup olmadığını kontrol etmek için dize manipülasyonunu kullanır %3( !b:%3=!).

Mathematica

İlk yol: dizeler

x, y, zdizelere dönüştürülür. Bir string-integer tam değilse z, sayılır.

f[{x_,y_},z_] :=Length[Select[ToString/@Range[Max[x, z], y], !StringFreeQ[#, ToString@z] &]]

Örnekler

f[{22, 1000}, 23]
f[{0, 10^6}, 2]

20
468559

İkinci yol: rakam listeleri

g[{x_,y_},z_]:=(t=Sequence@@ IntegerDigits@z;Length@Cases[IntegerDigits@Range[190], 
{s___,t,e___}])

Örnekler

g[{22, 1000}, 23]
g[{0, 10^6}, 2]

20
468559

GolfScript

GolfScript becerilerimi geliştirmeye çalışıyorum, bu yüzden bu soruyla bir şans vereceğimi düşündüm. İşte ben geldim:

`@@0\{.3$>}{.`4$?-1>@+\(}while@;;\;

Bu şu şekilde parçalanabilir:

0 1000000 2    # parameters

`@@            # convert Z to string and put at bottom of stack
0\             # init counter and swap
{.3$>}         # loop condition: Y > X
{              # loop body
  .`           # convert to string
  4$?          # search for substring
  -1>@+        # if found add to counter
  \(           # decrement Y
}              # end loop body
while          # perform loop
@;;\;          # cleanup

GolfScript olsa da, amaç kompakt değil de nispeten verimli hale getirmek için daha fazla şeydi, bu yüzden birinin bunun geliştirilebileceği çeşitli yollara işaret edebileceğinden eminim.

Gösteri : Demodaki Y değerini 5 saniyede tamamlayabilmesi için azalttığımı unutmayın.

PHP - 112

Görünür döngü yok, ancak bellekte biraz ağır!

<?=count(array_filter(range($argv[1],$argv[2]),function($i)use($argv){return strpos($i,$argv[3].'')!==false;}));

kullanım php script.php 0 1000000 2

ECMAScript 3 ila 6

regex kullanarak:

function f(x,y,z,r){for(r=0,z=RegExp(z);x<y;r+=+z.test(''+x++));return r}

Yıkmak:

function f(x,y,z,r){        // note argument `r`, eliminating the need for `var `
  for( r=0, z=RegExp(z)     // omitting `new` since ES will add it if omitted
     ; x<y                  // 
     ; r+=+z.test(''+x++)   // `x++` == post increment
                            // `''+Number` == convert Number to string
                            // `test` gives true | false
                            // `+Boolean` converts boolean to 1 | 0
                            // `r+=Number` incrementing r (were Number is always 1 or 0)
     );                     // no body thus semicolon is mandatory!
  return r;                 // returning r
}

indexOf kullanarak:

function f(x,y,z,r){for(r=0;x<y;r+=+!!~(''+x++).indexOf(z));return r}

Yıkmak:

function f(x,y,z,r){                // note argument `r`, eliminating the need for `var `
  for( r=0                          // omitting `new` since ES will add it if omitted
     ; x<y                          // 
     ; r+=+!!~(''+x++).indexOf(z)   // `x++` == post increment
                                    // `''+Number` == convert Number to string
                                    // `indexOf` returns index or `-1` when not found
                                    // `!!~ indexOf` converts sentinel value to boolean
                                    // `+Boolean` converts boolean to 1 | 0
                                    // `r+=Number` incrementing r (were Number is 1 or 0)
     );                             // no body thus semicolon is mandatory!
  return r;                         // returning r
}

^{Bu işlev gövdesi florentlerden bir karakter daha azdır, bu nedenle ES6 =>işlev gösterimini kullanırken toplam 62 karakter olur}

Örnek çağrı: f(0,1e6,2)
Örnek kullanım:alert( f(0,1e6,2) );

JSBurada oyna

PS: yukarıdaki her iki işlev de yerel değişkenlerini döndürür r.
Sonuç değişkenini rglobal kapsama katarken, yine 10 karakter kaydedilebilir:

function f(x,y,z){for(r=0;i<=j;r+=+!!~(''+i++).indexOf(z));}

Örnek kullanım: alert( f(0,1e6,2)||r );

Delphi - 120

Benim zevkime göre biraz, biraz kurtulmak görmek için gidiyor.

var x,y,z,i,c:int16;begin readLn(x,y,z);for i:=x to y do if inttostr(i).contains(inttostr(z))then inc(c);writeln(c);end.

Python 2.7-50 karakter

Mevcut Python cevaplarında biraz tasarruf.

lambda x,y,z:sum(1for n in range(y-x)if`z+x`in`n`)

Aşağıdaki hileleri kullanma:

• Toplam, bir jeneratöre len'den farklı olarak uygulanabilir, bu nedenle len ([n ...]) yerine sum (1 ...) kullanın
• Ayrıca izin veren str () yerine `` kullanın ...
• Tüm boşlukları öldür - 'eğer '1for' görmek ve z+xiçinde n'
• 0'dan başlayıp ofseti test ederek ilk range () argümanını kaldırın (aslında ... bana hiçbir şey kaydetmiyor ama daha iyi görünmesini seviyorum :))

Eylemde:

In [694]: (lambda x,y,z:sum(1for n in range(y-x)if`z+x`in`n`))(0,1000000,2)
Out[694]: 468559

k [28 karakter]

{+/($x+!y)like"*",$:[z],"*"}

kullanım

{+/($x+!y)like"*",$:[z],"*"}[0;1000000;2]
468559