Basierend auf der Frage Wie viele positive ganze Zahlen <1.000.000 enthalten die Ziffer 2? . Ich bin auf der Suche nach der kreativsten Lösung, um alle Ganzzahlen von Xbis Yzur Ganzzahl zu zählen Z. Zkann von 0 bis sein Y.

Jede gefundene Ganzzahl zählt nur einmal, auch wenn die Ganzzahl Zhäufiger vorkommt. Beispielsweise:

Z = 2
123 counts 1
22222 also counts 1

Ich werde mit einem wirklich einfachen Algorithmus beginnen, der in Java geschrieben ist (weil er von allen geliebt wird):

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

Wenn Sie dies mit ausführen

java -jar Count.jar 0 1000000 2

Sie erhalten dies als Ergebnis:

468559

Da dieses Problem nicht schwer zu lösen ist, handelt es sich nur um einen Beliebtheitswettbewerb . Die am besten bewertete Antwort, die bis zum 28. Februar veröffentlicht wurde, gewinnt!

Bash (20)

seq $1 $2|grep -c $3

Verwendung

$ bash count.sh 0 1000000 2
468559

Funktion

Da die von StackExchange hinzugefügte Zeilenhöhe die Zeilen aufteilt, sollten Sie dies wie gewohnt $('pre').css('line-height',1)in Ihrer Browserkonsole beheben.

Im Gegensatz zu meinen anderen Funciton-Antworten werden hier keine Funktionsdeklarationen verwendet. Es ist nur ein Programm. Es wird jedoch ein Lambda-Ausdruck verwendet - eine Funktion, die ich im Dezember zu Funciton hinzugefügt habe :)

Erwartet die Eingabe als drei Dezimalzahlen (kann negativ sein), die durch Leerzeichen (dh x y z) getrennt sind. Tatsächlich zkann es sich um eine beliebige Zeichenfolge handeln. Zum Beispiel könnte es nur das Minuszeichen ( −, U + 2212) sein, um die Anzahl der negativen Zahlen im Intervall zu zählen :)

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

Beispiel

count.exe 0 1000000 2
468559

APL (29)

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

Dies ist eine Funktion, die Zdas linke Argument und das Intervall [X,Y]als rechtes Argument verwendet:

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

Python 2.7

Need for Speed

Erläuterung

Implementierung

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

Demo

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

Vergleich

@ Tennis

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

Eine Lösung mit regulären Ausdrücken:

>>> 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 Zeichen + Länge von X, Y und Z.

Vielen Dank an devnull für den Vorschlag seq!

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

zB X = 100, Y = 200, Z = 20

$ seq 100 200|grep -c 20
2

zB X = 100, Y = 200, Z = 10

$ seq 100 200|grep -c 10
11

zB X = 0, Y = 1000000, Z = 2

$ seq 0 1000000|grep -c 2
468559

PHP

Nichts Originelles, ich feiere gerade meinen ersten Post hier.

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

?>

Eingang

php script.php 0 1000000 2

Ausgabe

468559

Scala:

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

Rubin

Dies ist ein großartiges Beispiel für die Verwendung von redu!

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

Eingang:

ruby script.rb 0 1000000 2

Ausgabe:

468559

Python Golf - 61

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

Python nicht Golf

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

Java8

Bei Verwendung des neuen IntStream-Materials handelt es sich im Wesentlichen um einen Einzeiler, wenn Sie das obligatorische Java Framework-Material ignorieren:

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

Es kann hier ausgeführt werden , obwohl ich die Werte hart codieren musste.

F #

Diese Lösung IndexOfdurchsucht den String und konvertiert das Ergebnis mit ein wenig Zahlenfummel in 1, wenn es gefunden wird, und 0, wenn es nicht gefunden wird, und summiert das Ergebnis:

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

Und so kann es heißen:

count 0 1000000 "2" // 468559

Regulären Ausdruck

Im Folgenden werden die Ziffern von 1 bis 49 gezählt.

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

Holen Sie sich einfach das richtige Werkzeug für den Job. Einfache Verwendung von grep in R, nichts Besonderes.

Dies ist, was es tut: grepAlle Instanzen von 2im Vektor 0bis 10e6und zählen die Anzahl der Ergebnisse mit length.

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

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

Ergebnis: [1] 468559

Natürlich können Sie eine Funktion schreiben, die die Zahlen als Eingabe verwendet, so wie es im Beispiel gezeigt wird.

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

Jetzt können Sie countmit x, y und z aufrufen , wenn nicht gesetzt (dh standardmäßig), sind die Werte für x, y und z 0, 1000000 bzw. 2. Einige Beispiele:

count()
[1] 468559

oder

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

oder

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

Einige hier denken, Zeit ist von Bedeutung, die Verwendung dieser Funktion in R dauert etwa 1 Sekunde.

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}

Verwendung:

f(0, 1e6, 2)
> 468559

Nicht golfen:

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

Grundsätzlich habe ich Pablos Antwort als nicht so gutes Anwendungsbeispiel genommen und halbgolfen (38 Zeichen, wenn Sie unnötiges Leerzeichen einfügen) select.

Es wählt jeden Index in dem Bereich aus (x .. y), der enthält z. Dieses Zwischenergebnis wird leider in einem Array gespeichert, dessen Größe dann zurückgegeben wird.

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

Es sieht sowohl syntaktisch als auch semantisch ziemlich ordentlich aus, obwohl der i[z]Teil nicht wirklich sinnvoll zu sein scheint.

Es funktioniert, weil xund yeigentlich sind Zeichenfolgen, keine Zahlen! Somit ist jedes iauch eine Zeichenkette und i[z]prüft natürlich, ob die Zeichenkette zenthalten ist i.

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

Python 2.7, 70 Zeichen

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

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

Kürzere, 65 Zeichen

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

Ruby's verwenden Enumerable#grep:

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

T-SQL

Wenn ich Variablen annehmen können @X, @Yund @Zstehen zur Verfügung:

Mit einer (beliebig großen;) vorhandenen Nummerntabelle - 65

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

Mit einem rekursiven 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)

Wenn die Variablen explizit definiert werden müssen:

Addiere 58 zu beiden Antworten - Zahlentabelle: 123, Rekursiver CTE: 185

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

Ich habe keine Ahnung, wie viel Speicher der rekursive CTE verwenden kann, aber er wird sicherlich keine Geschwindigkeitswettbewerbe gewinnen. Das Beispiel für die Suche nach 2 in 0 bis 1000000 dauert auf meinem System 8 Sekunden.

Hier ist eine SQL-Geige, wenn jemand damit spielen möchte. Die 1000000-Abfrage dauert mehr als 30 Sekunden.

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

Anwendungsbeispiel in der Rebol-Konsole (REPL):

>> count 0 1000000 2
== 468559

Power Shell

Zwei Lösungen, beide 40 bis 37 Zeichen.

Für alle Versionen von PowerShell:

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

PowerShell V3 und höher haben den slsAlias ​​für Select-String. Dies erfordert das @Erzwingen eines Arrays, wenn nur ein Wert die Pipeline durchläuft.

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

Stapel

@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

Etwas besser lesbar -

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

Schön und einfach. Verwendet die Zeichenfolgenmanipulation, um zu überprüfen, ob die Variable !b!dieselbe ist wie sie selbst, ohne die dritte Benutzereingabe %3( !b:%3=!).

Mathematica

Erster Weg: Streicher

x, y, zwerden in Zeichenfolgen konvertiert. Wenn eine String-Ganzzahl nicht frei ist z, wird sie gezählt.

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

Beispiele

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

20
468559

Zweiter Weg: Ziffernlisten

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

Beispiele

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

20
468559

GolfScript

Ich habe versucht, meine GolfScript-Kenntnisse zu verbessern, also dachte ich, ich würde es mit dieser Frage versuchen. Folgendes habe ich mir ausgedacht:

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

Dies kann wie folgt aufgeteilt werden:

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

Obwohl es sich um GolfScript handelt, bestand das Ziel eher darin, es relativ effizient als kompakt zu gestalten. Ich bin mir also sicher, dass jemand verschiedene Möglichkeiten aufzeigen kann, wie dies verbessert werden kann.

Demonstration : Beachten Sie, dass ich Y in der Demo reduziert habe, damit sie in weniger als 5 Sekunden abgeschlossen werden kann.

PHP - 112

Keine sichtbaren Schleifen, aber etwas speicherintensiv!

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

Verwendung php script.php 0 1000000 2

ECMAScript 3 bis 6

mit Regex:

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

Nervenzusammenbruch:

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}

Nervenzusammenbruch:

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
}

^{Dieser Funktionskörper ist ein Zeichen weniger als der von Florent. Wenn Sie also die ES6- =>Funktionsnotation verwenden, beträgt die Gesamtsumme 62 Zeichen}

Beispielaufruf: f(0,1e6,2)
Beispielanwendung:alert( f(0,1e6,2) );

JSFiddle hier

PS: Die beiden obigen Funktionen geben ihre lokale Variable zurück r.
Wenn Sie also die Ergebnisvariable rin den globalen Bereich verschieben, können Sie erneut 10 Zeichen speichern:

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

Beispiel Verwendung: alert( f(0,1e6,2)||r );

Delphi - 120

Für meinen Geschmack ein bisschen zu viel, um zu sehen, ob ich was davon kriegen kann.

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 Zeichen

Eine kleine Ersparnis bei den vorhandenen Python-Antworten.

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

Mit den folgenden Tricks:

• Im Gegensatz zu len kann sum auf einen Generator angewendet werden. Verwenden Sie also sum (1 ...) anstelle von len ([n ...]).
• Verwenden Sie `` anstelle von str (), wodurch auch ...
• Töte alle Leerzeichen - siehe '1for' und 'if z+xin n'
• Entfernen Sie das erste range () arg, indem Sie bei 0 beginnen und den Offset testen (eigentlich ... spart mir nichts, aber ich mag das Aussehen besser :))

In Aktion:

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

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

Verwendung

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