질문에 기초하여 1,000,000 미만의 양의 정수는 숫자 2를 포함합니까? . 나는에서 모든 정수를 계산하는 가장 창조적 인 솔루션을 찾고 있어요 X에 Y정수를 포함 Z. Z0에서 사이 일 수 있습니다 Y.

발견 된 모든 정수는 정수 Z가 더 자주 나타나는 경우에도 한 번만 계산 합니다. 예를 들면 다음과 같습니다.

Z = 2
123 counts 1
22222 also counts 1

Java로 작성된 매우 간단한 알고리즘부터 시작하겠습니다 (모든 사람이 사랑하기 때문에).

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

이걸로 실행하면

java -jar Count.jar 0 1000000 2

결과로 이것을 얻습니다.

468559

이 문제는 해결하기 어렵지 않기 때문에 인기 콘테스트 입니다. 2 월 28 일에 게시 된 가장 많이 투표 된 답변이 승리합니다!

배쉬 (20)

seq $1 $2|grep -c $3

용법

$ bash count.sh 0 1000000 2
468559

펀시 턴

평상시처럼 StackExchange에서 추가 한 줄 높이가 줄을 나누 $('pre').css('line-height',1)므로 브라우저 콘솔에서 실행 하여 문제를 해결하십시오.

다른 Funciton 답변과 달리이 함수는 함수 선언을 사용하지 않습니다. 프로그램 일뿐입니다. 그러나 람다 식을 사용합니다. 12 월에 Funciton에 추가 한 기능입니다. :)

공백으로 구분 된 3 개의 10 진수 (음수 일 수 있음)로 입력을 예상합니다 (예 :) x y z. 실제로, z임의의 문자열이 될 수 있습니다. 예를 들어, −간격에서 음수의 수를 세는 것은 빼기 부호 ( , U + 2212) 일 수 있습니다. :)

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

씨#

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])));
    }
}

예

count.exe 0 1000000 2
468559

APL (29)

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

이것은 Z왼쪽 인수로 사용하고 간격 [X,Y]을 오른쪽 인수로 사용하는 함수입니다.

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

파이썬 2.7

속도 필요

설명

이행

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

데모

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

비교

@ 데니스

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

아리따움

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

파이썬 2.7

정규식을 사용하는 솔루션 :

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

배쉬- 32 31 17 14 자 + X, Y 및 Z 길이

제안 해 주신 devnull에게 감사드립니다 seq!

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

예 : X = 100, Y = 200, Z = 20

$ seq 100 200|grep -c 20
2

예 : X = 100, Y = 200, Z = 10

$ seq 100 200|grep -c 10
11

예 : X = 0, Y = 1000000, Z = 2

$ seq 0 1000000|grep -c 2
468559

PHP

여기에 첫 번째 게시물을 축하하는 독창적 인 것은 없습니다.

<?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;

?>

입력

php script.php 0 1000000 2

산출

468559

스칼라 :

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

루비

이것은 reduce를 사용하는 좋은 예입니다!

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

입력:

ruby script.rb 0 1000000 2

산출:

468559

파이썬 골프-61

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

파이썬 비 골프

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

자바 8

새로운 IntStream 기능을 사용하면 필수 Java Framework 기능을 무시하면 기본적으로 하나의 라이너가됩니다.

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());
  }
}

값을 하드 코딩해야했지만 여기 에서 실행할 수 있습니다 .

에프#

이 솔루션은 IndexOf문자열을 검색 한 다음 발견 된 경우 결과를 1로, 찾지 않은 경우 0으로 변환하기 위해 약간의 숫자를 검색 한 다음 결과를 합산합니다.

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

그리고 이것은 다음과 같이 불릴 수 있습니다 :

count 0 1000000 "2" // 468559

정규식

다음은 1의 자릿수를 최대 49까지 계산합니다.

#!/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 27문자

작업에 적합한 도구를 얻으십시오. R에서 grep을 간단하게 사용하면 멋진 것은 아닙니다.

이것이하는 일 입니다. 벡터 grep의 모든 인스턴스는 까지 를 사용하여 결과 수를 계산합니다 .2010e6length

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

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

결과: [1] 468559

물론 예제에 표시된 것처럼 숫자를 입력으로 사용하는 함수를 작성할 수 있습니다.

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

이제 countx, y 및 z를 사용하여 호출 할 수 있습니다 (설정되지 않은 경우 (기본적으로)). x, y 및 z의 값은 각각 0, 1000000 및 2입니다. 몇 가지 예 :

count()
[1] 468559

또는

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

또는

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

여기서 일부 사람들은 R에서이 기능을 사용하는 데 약 1 초가 걸린다고 생각합니다.

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

자바 스크립트 (ES6), 63

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

용법:

f(0, 1e6, 2)
> 468559

언 골프 :

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
}

루비

기본적으로 Pablo의 대답 과 세미 골프 (필요한 공백을 삭제하면 38 자)를 사용하여 그다지 사용하지 않는 좋은 예로 만들었습니다 select.

이 (x .. y)포함 된 범위의 모든 인덱스를 선택합니다 z. 이 중간 결과는 불행히도 배열에 저장되어 크기가 반환됩니다.

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

문법적으로나 의미 적으로 깔끔하게 보이지만 i[z]실제로는 의미가없는 것 같습니다.

이 때문에 작동 x하고 y실제로 문자열이 아닌 숫자입니다! 따라서 각각 i은 i[z]문자열 z이며 문자열 이에 포함되어 있는지 확인합니다 i.

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

파이썬 2.7, 70 표지판

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

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

더 짧은, 65 개의 표시

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

루비 사용하기 Enumerable#grep:

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

T-SQL

나는 변수를 가정 할 경우 @X, @Y및 @Z사용할 수 있습니다

(임의로 큰;) 기존 숫자 테이블-65

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

재귀 CTE 사용-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)

변수를 명시 적으로 정의해야하는 경우 :

두 답변에 모두 58 추가-숫자 표 : 123, 재귀 CTE : 185

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

재귀 CTE가 얼마나 많은 메모리를 사용할 수 있는지는 모르겠지만 속도 경쟁에서 이길 수는 없습니다. 0에서 1000000까지 2를 검색하는 예는 시스템에서 8 초가 걸립니다.

여기의 SQL 바이올린은 사람이 그것으로 놀고 싶어합니다. 1000000 쿼리는 30 초 이상 걸립니다.

레볼

; 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]]]
]

REPL (Rebol Console)의 사용 예 :

>> count 0 1000000 2
== 468559

PowerShell

두 개의 솔루션, 모두 40 37 자

모든 버전의 PowerShell :

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

PowerShell V3 이상에는에 대한 sls별칭이 Select-String있습니다. @단 하나의 값만 파이프 라인을 통해 배열을 만드는 경우 배열을 강제로 실행해야합니다 .

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

일괄

@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

좀 더 읽기 쉬운-

@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!

좋고 간단합니다. 문자열 조작을 사용하여 변수 !b!가 세 번째 사용자 입력 %3( !b:%3=!) 없이 자체 변수 와 동일한 지 확인합니다 .

매스 매 티카

첫 번째 방법 : 문자열

x, y, z문자열로 변환됩니다. string-integer가없는 경우 z계산됩니다.

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

예

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

20
468559

두 번째 방법 : 자릿수 목록

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

예

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

20
468559

GolfScript

저는 GolfScript 기술을 향상시키기 위해 노력해 왔으므로이 질문에 대한 답변을 드리겠습니다. 내가 생각해 낸 것은 다음과 같습니다.

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

다음과 같이 분류 할 수 있습니다.

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이지만 목표는 컴팩트하기보다는 상대적으로 효율적으로 만드는 것이 더 낫기 때문에 누군가가 이것을 개선 할 수있는 다양한 방법을 지적 할 수 있다고 확신합니다.

데모 : 데모에서 Y를 줄여 5 초 내에 완료 할 수 있습니다.

PHP-112

눈에 보이는 루프는 없지만 메모리가 약간 무겁습니다!

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

용법 php script.php 0 1000000 2

ECMAScript 3 ~ 6

정규식 사용 :

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

고장:

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를 사용하여 :

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

고장:

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
}

^{이 함수-바디는 하나의 문자보다 작습니다. ES6 =>함수 표기법을 사용할 때 총 문자는 62 자입니다.}

호출 예 : f(0,1e6,2)
사용 예 :alert( f(0,1e6,2) );

여기 JSFiddle

추신 : 위의 두 함수는 모두 로컬 변수를 반환 합니다 r.
따라서 결과 변수 r를 전역 범위로 유출하면 다시 10자를 저장할 수 있습니다.

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

사용 예 : alert( f(0,1e6,2)||r );

델파이-120

내 취향에 맞게 조금만 더 먹어도 될까요?

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 자

기존 Python 답변을 절약합니다.

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

다음 트릭 사용하기 :

• len과 달리 Sum은 생성기에 적용될 수 있으므로 len ([n ...]) 대신 sum (1 ...)을 사용하십시오.
• str () 대신``를 사용하십시오.
• 모든 공백을 제거하십시오- '1for'및 'if z+xin n'
• 0에서 시작하여 오프셋을 테스트하여 첫 번째 range () arg를 제거하십시오 (실제로 ... 아무것도 절약하지만 모양이 더 좋습니다 :))

행동 :

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 자]

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

용법

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