Na podstawie pytania Ile dodatnich liczb całkowitych <1 000 000 zawiera cyfrę 2? . Szukam najbardziej kreatywne rozwiązania, aby policzyć wszystkie liczby całkowite od Xdo Yzawierający Integer Z. Zmoże wynosić od 0 do Y.

Każda znaleziona liczba całkowita liczy się tylko raz, nawet jeśli liczba całkowita Zpojawia się częściej. Na przykład:

Z = 2
123 counts 1
22222 also counts 1

Zacznę od bardzo prostego algorytmu napisanego w Javie (ponieważ wszyscy go kochają):

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

jeśli uruchomisz to z

java -jar Count.jar 0 1000000 2

otrzymujesz to w wyniku:

468559

Ponieważ ten problem nie jest trudny do rozwiązania, to tylko konkurs popularności . Najpopularniejsza odpowiedź opublikowana do 28 lutego wygrywa!

bash (20)

seq $1 $2|grep -c $3

Stosowanie

$ bash count.sh 0 1000000 2
468559

Funciton

Jak zwykle, ponieważ wysokość linii dodana przez StackExchange rozkłada linie, rozważ uruchomienie $('pre').css('line-height',1)w konsoli przeglądarki, aby to naprawić.

W przeciwieństwie do moich innych odpowiedzi Funciton, ta nie używa deklaracji funkcji. To tylko program. Wykorzystuje jednak wyrażenie lambda - funkcję, którą dodałem do Funciton w grudniu :)

Oczekuje danych wejściowych w postaci trzech liczb całkowitych dziesiętnych (może być ujemnych) oddzielonych spacjami (tj x y z.). W rzeczywistości zmoże być dowolnym ciągiem; na przykład może być tylko znak minus ( −, U + 2212), aby policzyć liczbę liczb ujemnych w przedziale :)

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

DO#

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

Przykład

count.exe 0 1000000 2
468559

APL (29)

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

Jest to funkcja, która przyjmuje Zjako lewy argument, a interwał [X,Y]jako prawy argument:

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

Python 2.7

Potrzeba prędkości

Wyjaśnienie

Realizacja

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

Próbny

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

Porównanie

@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

Rozwiązanie wykorzystujące wyrażenia regularne:

>>> 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 znaków + długość X, Y i Z

Dzięki devnull za sugestie seq!

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

np. X = 100, Y = 200, Z = 20

$ seq 100 200|grep -c 20
2

np. X = 100, Y = 200, Z = 10

$ seq 100 200|grep -c 10
11

np. X = 0, Y = 1000000, Z = 2

$ seq 0 1000000|grep -c 2
468559

PHP

Nic oryginalnego, właśnie świętuje mój pierwszy post tutaj.

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

?>

Wejście

php script.php 0 1000000 2

Wynik

468559

Scala:

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

Rubin

To świetny przykład zastosowania redukcji!

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

Wejście:

ruby script.rb 0 1000000 2

Wynik:

468559

Python golf - 61

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

Python non-golf

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

Java8

Korzystając z nowych rzeczy IntStream, staje się to zasadniczo jedna linijka, jeśli zignorujesz obowiązkowe rzeczy 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());
  }
}

Można go uruchomić tutaj , chociaż musiałem zakodować wartości.

FA#

To rozwiązanie używa IndexOfdo przeszukiwania ciągu, a następnie odrobiny szarpania liczb, aby przekonwertować wynik na 1, jeśli znaleziono, i 0, jeśli nie znaleziono, a następnie sumuje wynik:

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

I można to nazwać tak:

count 0 1000000 "2" // 468559

Wyrażenie regularne

Poniższe policzą cyfry 1 do 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 27znaki

Po prostu wybierz odpowiednie narzędzie do pracy. Proste użycie grep w R, nic szczególnego.

Oto, co robi: grepwszystkie wystąpienia 2w wektorze 0do 10e6i policz liczbę wyników za pomocą length.

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

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

Wynik: [1] 468559

Z trasy można napisać funkcję, która przyjmuje liczby jako dane wejściowe, tak jak pokazano w przykładzie.

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

Teraz możesz wywoływać countza pomocą x, y i z, jeśli nie jest ustawione (to jest domyślnie), wartości dla x, y i z wynoszą odpowiednio 0, 1000000 i 2. Kilka przykładów:

count()
[1] 468559

lub

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

lub

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

Niektórzy uważają, że czas ma znaczenie, użycie tej funkcji w R zajmuje około 1 sekundy.

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}

Stosowanie:

f(0, 1e6, 2)
> 468559

Bez golfa:

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
}

Rubin

Zasadniczo wziąłem odpowiedź Pabla i częściowo zagrałem w golfa (38 znaków, jeśli upuścisz niepotrzebne białe znaki), co jest niezbyt dobrym przykładem użycia select.

Wybiera każdy indeks w zakresie, (x .. y)który zawiera z. Ten wynik pośredni jest niestety przechowywany w tablicy, której rozmiar jest następnie zwracany.

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

Wygląda całkiem nieźle zarówno pod względem składniowym, jak i semantycznym, chociaż ta i[z]część nie wydaje się mieć sensu.

Działa, ponieważ xi ytak naprawdę są łańcuchami, a nie liczbami! Tak więc każdy ijest również łańcuchem i i[z]oczywiście sprawdza, czy łańcuch zjest zawarty w i.

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

Python 2.7, 70 znaków

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

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

Krótszy, 65 znaków

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

Korzystanie z Ruby Enumerable#grep:

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

T-SQL

Jeśli mogę założyć, zmienne @X, @Yi @Zsą dostępne:

Z (dowolnie dużą;) istniejącą tabelą liczb - 65

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

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

Jeśli zmienne należy zdefiniować jawnie:

Dodaj 58 do obu odpowiedzi - Tabela liczb: 123, Rekurencyjna CTE: 185

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

Nie mam pojęcia, ile pamięci może zużywać rekurencyjne CTE, ale z pewnością nie wygra żadnych konkursów prędkości. Przykład wyszukiwania 2 w 0 do 1000000 zajmuje 8 sekund w moim systemie.

Oto SQL Fiddle, jeśli ktoś chce się nim bawić. Uruchomienie zapytania 1000000 trwa ponad 30 sekund.

Rebol

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

Przykład użycia w konsoli Rebol (REPL):

>> count 0 1000000 2
== 468559

PowerShell

Dwa rozwiązania, oba 40 37 znaków.

Dla wszystkich wersji PowerShell:

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

PowerShell V3 i nowsze mają slsalias dla Select-String. Wymaga @to wymuszenia tablicy, jeśli tylko jedna wartość przejdzie przez potok.

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

Partia

@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

Trochę bardziej czytelny -

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

Ładne i proste. Używa manipulacji ciągiem, aby sprawdzić, czy zmienna !b!jest taka sama jak sama bez danych wejściowych trzeciego użytkownika, %3( !b:%3=!).

Matematyka

Pierwszy sposób: ciągi znaków

x, y, zsą konwertowane na ciągi. Jeśli ciąg liczb całkowitych nie jest wolny z, jest liczony.

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

Przykłady

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

20
468559

Drugi sposób: listy cyfr

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

Przykłady

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

20
468559

GolfScript

Próbowałem poprawić swoje umiejętności gry w golfa, więc pomyślałem, że spróbuję tego z tym pytaniem. Oto, co wymyśliłem:

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

Można to podzielić w następujący sposób:

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

Mimo że jest to GolfScript, celem było raczej uczynienie go stosunkowo wydajnym, a nie kompaktowym, więc jestem pewien, że ktoś może wskazać różne sposoby jego poprawy.

Demonstracja : Zauważ, że zmniejszyłem Y w wersji demo, aby mogła zakończyć się w <5 sekund.

PHP - 112

Brak widocznych pętli, ale trochę obciążająca pamięć!

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

Stosowanie php script.php 0 1000000 2

ECMAScript od 3 do 6

za pomocą wyrażenia regularnego:

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

awaria:

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
}

using indexOf:

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

awaria:

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
}

^{to ciało funkcyjne jest o jeden znak mniejsze niż florenta, więc przy użyciu =>notacji funkcji ES6 suma wyniesie 62 znaki}

Przykładowe wywołanie: f(0,1e6,2)
Przykład użycia:alert( f(0,1e6,2) );

JSFiddle tutaj

PS: obie powyższe funkcje zwracają zmienną lokalnąr .
Dlatego przeciekając zmienną wynikową rdo zasięgu globalnego, można ponownie zapisać 10 znaków:

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

Przykładowe zastosowanie: alert( f(0,1e6,2)||r );

Delfy - 120

Trochę za dużo jak na mój gust, sprawdzę, czy uda mi się trochę oderwać.

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 znaków

Trochę oszczędności na istniejących odpowiedziach w języku Python.

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

Korzystanie z następujących sztuczek:

• Suma może być zastosowana do generatora, w przeciwieństwie do len, więc użyj sumy (1 ...) zamiast len ​​([n ...])
• Użyj `` zamiast str (), co pozwala również ...
• Zabij wszystkie spacje - patrz „1for” i „if z+xin n”
• Usuń arg z pierwszego zakresu (), zaczynając od 0 i testując przesunięcie (właściwie ... nic mnie nie oszczędza, ale bardziej podoba mi się jego wygląd :))

W akcji:

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 znaków]

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

Stosowanie

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