Dựa vào câu hỏi Có bao nhiêu số nguyên dương <1.000.000 chứa chữ số 2? . Tôi đang tìm giải pháp sáng tạo nhất để đếm tất cả các Số nguyên từ Xđể Ychứa Số nguyên Z. Zcó thể từ 0 đến Y.

Mỗi số nguyên tìm thấy chỉ được tính một lần, ngay cả khi số nguyên Zxuất hiện thường xuyên hơn. Ví dụ:

Z = 2
123 counts 1
22222 also counts 1

Tôi sẽ bắt đầu với một thuật toán thực sự đơn giản được viết bằng Java (bởi vì nó được mọi người yêu thích):

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

nếu bạn chạy cái này với

java -jar Count.jar 0 1000000 2

bạn nhận được điều này là kết quả:

468559

Bởi vì vấn đề này không khó để giải quyết nó chỉ là một cuộc thi phổ biến . Câu trả lời được đánh giá cao nhất được đăng vào ngày 28 tháng 2!

bash (20)

seq $1 $2|grep -c $3

Sử dụng

$ bash count.sh 0 1000000 2
468559

Chức năng

Như thường lệ, vì chiều cao dòng được thêm bởi StackExchange phá vỡ các dòng, hãy xem xét việc chạy $('pre').css('line-height',1)trong bảng điều khiển trình duyệt của bạn để khắc phục điều đó.

Không giống như các câu trả lời Funciton khác của tôi, câu trả lời này không sử dụng bất kỳ khai báo hàm nào. Nó chỉ là một chương trình. Tuy nhiên, nó sử dụng biểu thức lambda - một tính năng tôi đã thêm vào Funciton vào tháng 12 :)

Yêu cầu đầu vào là ba số nguyên thập phân (có thể âm) được phân tách bằng dấu cách (nghĩa là x y z). Trong thực tế, zcó thể là bất kỳ chuỗi; ví dụ, nó có thể chỉ là dấu trừ ( −, U + 2212) để đếm số lượng số âm trong khoảng :)

           ┌───╖
     ┌───┬─┤ ♯ ╟──────────┐
     │   │ ╘═══╝ ╔════╗ ┌─┴─╖             ┌────╖ ╔═══╗
   ┌─┴─╖ └────┐  ║ 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])));
    }
}

Thí dụ

count.exe 0 1000000 2
468559

APL (29)

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

Đây là một hàm lấy Zđối số bên trái và khoảng [X,Y]là đối số bên phải:

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

Python 2.7

Cần tốc độ

Giải trình

Thực hiện

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

Bản giới thiệu

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

So sánh

@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

Một giải pháp sử dụng biểu thức chính quy:

>>> 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 ký tự + độ dài của X, Y và Z

Cảm ơn devnull đã gợi ý seq!

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

ví dụ: X = 100, Y = 200, Z = 20

$ seq 100 200|grep -c 20
2

ví dụ: X = 100, Y = 200, Z = 10

$ seq 100 200|grep -c 10
11

ví dụ: X = 0, Y = 1000000, Z = 2

$ seq 0 1000000|grep -c 2
468559

PHP

Không có gì nguyên bản, chỉ kỷ niệm bài viết đầu tiên của tôi ở đây.

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

?>

Đầu vào

php script.php 0 1000000 2

Đầu ra

468559

Scala:

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

Hồng ngọc

Đây là một ví dụ tuyệt vời để sử dụng giảm!

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

Đầu vào:

ruby script.rb 0 1000000 2

Đầu ra:

468559

Golf Python - 61

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

Python không chơi gôn

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

Java8

Sử dụng công cụ IntStream mới, về cơ bản nó sẽ trở thành một lớp lót, nếu bạn bỏ qua các công cụ Java Framework bắt buộc:

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

Nó có thể được chạy ở đây , mặc dù tôi đã phải mã hóa các giá trị.

F #

Giải pháp này sử dụng IndexOfđể tìm kiếm chuỗi, sau đó một chút số nhỏ để chuyển đổi kết quả thành 1 nếu tìm thấy và 0 nếu không tìm thấy, sau đó tính tổng kết quả:

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

Và nó có thể được gọi như thế này:

count 0 1000000 "2" // 468559

Biểu hiện thông thường

Sau đây sẽ đếm 1 chữ số lên đến 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 27ký tự

Chỉ cần có được công cụ phù hợp cho công việc. Sử dụng grep đơn giản trong R, không có gì lạ mắt.

Đây là những gì nó làm: greptất cả các trường hợp 2trong vectơ 0cho đến khi 10e6và đếm số lượng kết quả sử dụng length.

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

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

Kết quả: [1] 468559

Bạn có thể viết một hàm lấy các số làm đầu vào, giống như nó được hiển thị trong ví dụ.

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

Bây giờ bạn có thể gọi countbằng x, y và z, nếu không đặt (theo mặc định), các giá trị cho x, y và z lần lượt là 0, 1000000 và 2. Vài ví dụ:

count()
[1] 468559

hoặc là

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

hoặc là

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

Một số người ở đây nghĩ rằng thời gian là quan trọng, sử dụng chức năng này trong R mất khoảng 1 giây.

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}

Sử dụng:

f(0, 1e6, 2)
> 468559

Chưa chơi gôn:

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
}

Hồng ngọc

Về cơ bản tôi đã lấy câu trả lời của Pablo và bán gôn (38 ký tự nếu bạn bỏ khoảng trắng không cần thiết) nó thành một ví dụ không hay về việc sử dụngselect .

Nó chọn mọi chỉ mục trong phạm vi (x .. y)có chứa z. Kết quả trung gian này không may được lưu trữ trong một mảng, sau đó kích thước được trả về.

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

Nó trông khá gọn gàng cả về mặt cú pháp và ngữ nghĩa, mặc dù i[z]phần này dường như không thực sự có ý nghĩa.

Nó hoạt động bởi vì xvà ythực sự là các chuỗi, không phải số! Do đó, mỗi ichuỗi cũng là một chuỗi và i[z]tất nhiên sẽ kiểm tra xem chuỗi zcó được chứa trong đó không i.

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

Python 2.7, 70 dấu hiệu

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

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

Ngắn hơn, 65 dấu hiệu

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

Sử dụng Ruby Enumerable#grep:

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

T-SQL

Nếu tôi có thể giả định các biến @X, @Yvà @Zcó sẵn:

Với bảng số hiện có (lớn tùy ý;) - 65

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

Với CTE đệ quy - 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)

Nếu các biến cần được xác định rõ ràng:

Thêm 58 vào cả hai câu trả lời - Bảng số: 123, CTE đệ quy: 185

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

Tôi không biết CTE đệ quy có thể sử dụng bao nhiêu bộ nhớ, nhưng chắc chắn sẽ không chiến thắng bất kỳ cuộc thi tốc độ nào. Ví dụ về tìm kiếm 2 trong 0 đến 1000000 mất 8 giây trên hệ thống của tôi.

Đây là một Fiddle SQL nếu bất cứ ai muốn chơi với nó. Truy vấn 1000000 mất hơn 30 giây để chạy.

Nổi loạn

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

Ví dụ sử dụng trong bảng điều khiển Rebol (REPL):

>> count 0 1000000 2
== 468559

PowerShell

Hai giải pháp, cả 40 37 ký tự.

Đối với tất cả các phiên bản PowerShell:

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

PowerShell V3 trở lên có slsbí danh cho Select-String. Điều này đòi hỏi @phải buộc một mảng nếu chỉ có một giá trị làm cho nó đi qua đường ống.

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

Lô hàng

@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

Dễ đọc hơn một chút -

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

Đẹp và đơn giản. Sử dụng thao tác chuỗi để kiểm tra xem biến !b!có giống với chính nó không mà không có đầu vào của người dùng thứ ba, %3( !b:%3=!).

Toán học

Cách thứ nhất: chuỗi

x, y, zđược chuyển đổi thành chuỗi. Nếu một số nguyên chuỗi không miễn phí z, nó được tính.

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

Ví dụ

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

20
468559

Cách thứ hai: danh sách các chữ số

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

Ví dụ

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

20
468559

GolfScript

Tôi đã cố gắng cải thiện các kỹ năng GolfScript của mình vì vậy tôi nghĩ rằng tôi nên thử với câu hỏi này. Đây là những gì tôi nghĩ ra:

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

Điều này có thể được chia nhỏ như thế này:

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

Mặc dù đó là GolfScript, nhưng mục tiêu là cố gắng làm cho nó tương đối hiệu quả hơn là nhỏ gọn, vì vậy tôi chắc chắn rằng ai đó có thể chỉ ra nhiều cách khác nhau để cải thiện điều này.

Trình diễn : Lưu ý rằng tôi đã giảm Y trong bản demo để có thể hoàn thành trong <5 giây.

PHP - 112

Không có vòng lặp có thể nhìn thấy, nhưng một chút nặng về bộ nhớ!

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

Sử dụng php script.php 0 1000000 2

ECMAScript 3 đến 6

sử dụng regex:

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

phá vỡ:

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
}

sử dụng indexOf:

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

phá vỡ:

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
}

^{cơ thể chức năng này là một char ít hơn florent, vì vậy khi sử dụng =>ký hiệu chức năng ES6 , tổng số sẽ là 62 char}

Cuộc gọi ví dụ: f(0,1e6,2)
Ví dụ sử dụng:alert( f(0,1e6,2) );

JSFiddle ở đây

PS: cả hai hàm trên trả về biến cục bộ của chúng r.
Vì vậy, khi rò rỉ biến kết quả rvào phạm vi toàn cầu, một lần nữa có thể lưu 10 ký tự:

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

Ví dụ sử dụng: alert( f(0,1e6,2)||r );

Delphi - 120

Bit nhiều cho hương vị của tôi, để xem nếu tôi có thể nhận được một số.

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 ký tự

Một chút tiết kiệm cho các câu trả lời Python hiện có.

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

Sử dụng các thủ thuật sau:

• Tổng có thể được áp dụng cho trình tạo, không giống như len, vì vậy hãy sử dụng tổng (1 ...) thay vì len ([n ...])
• Sử dụng `` thay vì str (), cũng cho phép ...
• Giết tất cả các khoảng trắng - xem '1for' và 'if z+xin n'
• Xóa phạm vi đầu tiên () arg bằng cách bắt đầu từ 0 và kiểm tra phần bù (thực ra ... không tiết kiệm cho tôi nhưng tôi thích giao diện của nó hơn :))

Trong hành động:

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 ký tự]

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

Sử dụng

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