Sulla base della domanda Quanti numeri interi positivi <1.000.000 contengono la cifra 2? . Sto cercando la soluzione più creativa per contare tutti i numeri interi da Xa Yche contiene il numero intero Z. Zpuò essere compreso tra 0 e Y.

Ogni numero intero trovato viene conteggiato una sola volta, anche se il numero intero Zappare più spesso. Per esempio:

Z = 2
123 counts 1
22222 also counts 1

Inizierò con un algoritmo davvero semplice scritto in Java (perché è amato da tutti):

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

se esegui questo con

java -jar Count.jar 0 1000000 2

ottieni questo come risultato:

468559

Perché questo problema non è difficile da risolvere, è solo un concorso di popolarità . Vince la risposta più votata pubblicata entro il 28 febbraio!

bash (20)

seq $1 $2|grep -c $3

uso

$ bash count.sh 0 1000000 2
468559

funciton

Come al solito, poiché l'altezza della linea aggiunta da StackExchange interrompe le linee, considera di correre $('pre').css('line-height',1)nella console del browser per risolvere il problema.

A differenza delle altre mie risposte di Funciton, questa non usa alcuna dichiarazione di funzione. È solo un programma. Usa un'espressione lambda, però - una caratteristica che ho aggiunto a Funciton a dicembre :)

Prevede l'input come tre numeri decimali (può essere negativo) separati da spazi (cioè x y z). In effetti, zpuò essere qualsiasi stringa; ad esempio, potrebbe essere solo il segno meno ( −, U + 2212) per contare il numero di numeri negativi nell'intervallo :)

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

Esempio

count.exe 0 1000000 2
468559

APL (29)

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

Questa è una funzione che assume Zcome argomento sinistro e l'intervallo [X,Y]come argomento destro:

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

Python 2.7

Need for Speed

Spiegazione

Implementazione

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

dimostrazione

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

Confronto

@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

Una soluzione che utilizza espressioni regolari:

>>> 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 caratteri + lunghezza di X, Y e Z

Grazie a devnull per aver suggerito seq!

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

ad es. X = 100, Y = 200, Z = 20

$ seq 100 200|grep -c 20
2

ad es. X = 100, Y = 200, Z = 10

$ seq 100 200|grep -c 10
11

ad es. X = 0, Y = 1000000, Z = 2

$ seq 0 1000000|grep -c 2
468559

PHP

Niente di originale, sto solo celebrando il mio primo post qui.

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

?>

Ingresso

php script.php 0 1000000 2

Produzione

468559

Scala:

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

Rubino

Questo è un ottimo esempio da usare per ridurre!

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

Ingresso:

ruby script.rb 0 1000000 2

Produzione:

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

Utilizzando la nuova roba IntStream, questa diventa essenzialmente una linea, se si ignora la roba obbligatoria di 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());
  }
}

Può essere eseguito qui , anche se ho dovuto codificare i valori.

F #

Questa soluzione utilizza IndexOfper cercare la stringa, quindi un po 'di numero giocherellando per convertire il risultato in 1 se trovato e 0 se non trovato, quindi somma il risultato:

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

E può essere chiamato così:

count 0 1000000 "2" // 468559

Espressione regolare

Di seguito conterrà le cifre di 1 fino a 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 27caratteri

Ottieni lo strumento giusto per il lavoro. Semplice utilizzo di grep in R, niente di speciale.

Questo è ciò che fa: greptutte le istanze di 2nel vettore 0fino a quando 10e6contano il numero di risultati usando length.

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

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

Risultato: [1] 468559

Fuori dal campo puoi scrivere una funzione che accetta i numeri come input, proprio come mostrato nell'esempio.

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

Ora puoi chiamare countcon con x, ye z, se non impostato (ovvero per impostazione predefinita), i valori per x, ye z sono rispettivamente 0, 1000000 e 2. Qualche esempio:

count()
[1] 468559

o

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

o

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

Alcuni qui pensano che il tempo sia importante, l'uso di questa funzione in R richiede circa 1 secondo.

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}

Uso:

f(0, 1e6, 2)
> 468559

Un-giocato a golf:

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
}

Rubino

Fondamentalmente ho preso la risposta di Pablo e ho giocato a semi-golf (38 caratteri se hai lasciato spazio bianco non necessario) in un esempio non così eccezionale di utilizzo select.

Seleziona ogni indice nell'intervallo (x .. y)che contiene z. Questo risultato intermedio è purtroppo memorizzato in un array, la cui dimensione viene quindi restituita.

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

Sembra abbastanza pulito sia sintatticamente che semanticamente, anche se la i[z]parte non sembra avere davvero senso.

Funziona perché xe yin realtà sono stringhe, non numeri! Quindi ognuno iè anche una stringa e i[z]ovviamente controlla se la stringa zè contenuta in i.

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

Python 2.7, 70 segni

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

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

Più breve, 65 segni

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

Utilizzando Ruby Enumerable#grep:

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

T-SQL

Se posso assumere le variabili @X, @Ye @Zsono disponibili:

Con una tabella dei numeri (arbitrariamente grande;) esistente - 65

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

Con un CTE ricorsivo - 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)

Se le variabili devono essere definite esplicitamente:

Aggiungi 58 a entrambe le risposte - Tabella dei numeri: 123, CTE ricorsivo: 185

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

Non ho idea di quanta memoria possa usare il CTE ricorsivo, ma sicuramente non vincerà alcun contest di velocità. L'esempio della ricerca di 2 in 0 a 1000000 richiede 8 secondi sul mio sistema.

Ecco un violino SQL se qualcuno vuole giocarci. L'esecuzione della query 1000000 richiede oltre 30 secondi.

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

Esempio di utilizzo nella console di Rebol (REPL):

>> count 0 1000000 2
== 468559

PowerShell

Due soluzioni, entrambe 40 37 caratteri.

Per tutte le versioni di PowerShell:

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

PowerShell V3 e versioni successive hanno l' slsalias per Select-String. Ciò richiede @di forzare un array se solo un valore riesce a passare attraverso la pipeline.

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

Lotto

@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

Un po 'più leggibile -

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

Bello e semplice. Utilizza la manipolazione di stringhe per verificare se la variabile !b!è uguale a se stessa senza l'input del terzo utente, %3( !b:%3=!).

matematica

Primo modo: stringhe

x, y, zvengono convertiti in stringhe. Se un intero di stringa non è privo di z, viene conteggiato.

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

Esempi

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

20
468559

Secondo modo: elenchi di cifre

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

Esempi

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

20
468559

GolfScript

Ho cercato di migliorare le mie abilità su GolfScript, quindi ho pensato di provarlo con questa domanda. Ecco cosa mi è venuto in mente:

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

Questo può essere suddiviso in questo modo:

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

Anche se è GolfScript, per obiettivo era più cercare di renderlo relativamente efficiente piuttosto che compatto, quindi sono sicuro che qualcuno può indicare vari modi in cui questo può essere migliorato.

Dimostrazione : nota che ho ridotto Y nella demo in modo che possa essere completato in <5 secondi.

PHP - 112

Nessun loop visibile, ma un po 'pesante nella memoria!

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

uso php script.php 0 1000000 2

ECMAScript da 3 a 6

usando regex:

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

abbattersi:

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
}

utilizzando indexOf:

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

abbattersi:

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
}

^{questo corpo-funzione è un carattere in meno di quello di Florent, quindi quando si usa la =>notazione della funzione ES6 il totale sarebbe 62 caratteri}

Esempio di chiamata: f(0,1e6,2)
esempio di utilizzo:alert( f(0,1e6,2) );

JSFiddle qui

PS: entrambe le funzioni sopra restituiscono la loro variabile localer .
Pertanto, quando si perde la variabile del risultato rnell'ambito globale, è possibile salvare nuovamente 10 caratteri:

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

Esempio di utilizzo: alert( f(0,1e6,2)||r );

Delphi - 120

Bit to much for my taste, going to see if i can get some off.

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 chars

Bit of a saving on the existing Python answers.

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

Using the following tricks:

• Sum can be applied to a generator, unlike len, so use sum(1...) instead of len([n...])
• Use `` instead of str(), which also allows...
• Kill all spaces - see '1for' and 'ifz+xinn'
• Remove the first range() arg by starting at 0 and testing the offset (actually...saves me nothing but I like the look of it better :) )

In action:

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

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

Usage

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