Basé sur la question Combien d’entiers positifs <1 000 000 contiennent le chiffre 2? . Je cherche la solution la plus créative pour compter tous les Entiers de Xla Ycontenant l'entier Z. Zpeut aller de 0 à Y.

Chaque entier trouvé ne compte qu'une seule fois, même si l'entier Zapparaît plus souvent. Par exemple:

Z = 2
123 counts 1
22222 also counts 1

Je vais commencer par un algorithme très simple écrit en Java (car il est apprécié de tous):

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

si vous exécutez cela avec

java -jar Count.jar 0 1000000 2

vous obtenez ceci comme résultat:

468559

Parce que ce problème n'est pas difficile à résoudre, c'est juste un concours de popularité . La réponse la plus votée publiée le 28 février gagne!

bash (20)

seq $1 $2|grep -c $3

Usage

$ bash count.sh 0 1000000 2
468559

Funciton

Comme d'habitude, étant donné que la hauteur de ligne ajoutée par StackExchange rompt les lignes, pensez à exécuter $('pre').css('line-height',1)dans la console de votre navigateur pour résoudre ce problème.

Contrairement à mes autres réponses Funciton, celle-ci n'utilise aucune déclaration de fonction. C'est juste un programme. Il utilise cependant une expression lambda - une fonctionnalité que j'ai ajoutée à Funciton en décembre :)

Attend l'entrée comme trois entiers décimaux (peuvent être négatifs) séparés par des espaces (ie x y z). En fait, zpeut être n'importe quelle chaîne; par exemple, ce pourrait être juste le signe moins ( −, U + 2212) pour compter le nombre de nombres négatifs dans l'intervalle :)

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

Exemple

count.exe 0 1000000 2
468559

APL (29)

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

C'est une fonction qui prend Zcomme argument de gauche et l'intervalle [X,Y]comme argument de droite:

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

Python 2.7

Besoin de vitesse

Explication

la mise en oeuvre

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

Démo

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

Comparaison

@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

Une solution utilisant des expressions régulières:

>>> 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 caractères + longueur de X, Y et Z

Merci à devnull d'avoir suggéré seq!

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

par exemple X = 100, Y = 200, Z = 20

$ seq 100 200|grep -c 20
2

par exemple X = 100, Y = 200, Z = 10

$ seq 100 200|grep -c 10
11

par exemple X = 0, Y = 1000000, Z = 2

$ seq 0 1000000|grep -c 2
468559

PHP

Rien d'original, juste célébrer mon premier post ici.

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

?>

Contribution

php script.php 0 1000000 2

Production

468559

Scala:

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

Rubis

Ceci est un excellent exemple pour utiliser réduire!

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

Contribution:

ruby script.rb 0 1000000 2

Production:

468559

Golf de Python - 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

En utilisant les nouveaux trucs IntStream, cela devient essentiellement une ligne unique, si vous ignorez les trucs Java Framework obligatoires:

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

Il peut être exécuté ici , même si j'ai dû coder en dur les valeurs.

F#

Cette solution utilise IndexOfpour rechercher la chaîne, puis un peu de tripotage pour convertir le résultat en 1 s'il est trouvé, et 0 s'il n'est pas trouvé, puis résume le résultat:

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

Et cela peut être appelé comme ceci:

count 0 1000000 "2" // 468559

Expression régulière

La suite comptera les chiffres de 1 jusqu'à 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 27caractères

Obtenez juste le bon outil pour le travail. Utilisation simple de grep dans R, rien d'extraordinaire.

C'est ce qu'il fait: greptoutes les instances de 2dans le vecteur 0jusqu'à 10e6et compter le nombre de résultats en utilisant length.

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

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

Résultat: [1] 468559

Offcourse, vous pouvez écrire une fonction qui prend les nombres en entrée, tout comme cela est illustré dans l'exemple.

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

Vous pouvez maintenant appeler countavec avec x, y et z, si non défini (c'est-à-dire par défaut), les valeurs de x, y et z sont respectivement 0, 1000000 et 2. Quelques exemples:

count()
[1] 468559

ou

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

ou

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

Certains pensent que le temps est important, l'utilisation de cette fonction dans R prend environ 1 seconde.

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}

Usage:

f(0, 1e6, 2)
> 468559

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

Rubis

Fondamentalement, j'ai pris la réponse de Pablo et semi-golfé (38 caractères si vous laissez des espaces inutiles) dans un exemple pas si génial d'utiliserselect .

Il sélectionne chaque index de la plage (x .. y)qui contient z. Ce résultat intermédiaire est malheureusement stocké dans un tableau, dont la taille est ensuite renvoyée.

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

Cela semble assez soigné à la fois syntaxiquement et sémantiquement, bien que la i[z]partie ne semble pas vraiment logique.

Cela fonctionne parce xque ce ysont des chaînes et non des nombres! Ainsi, chacun iest également une chaîne et i[z]vérifie bien sûr si la chaîne zest contenue dans i.

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

Python 2.7, 70 signes

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

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

Plus court, 65 signes

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

Utilisation de Ruby Enumerable#grep:

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

T-SQL

Si je peux prendre des variables @X, @Yet @Zsont disponibles:

Avec un tableau de nombres (arbitrairement grand;) - 65

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

Avec un CTE récursif - 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)

Si les variables doivent être définies explicitement:

Ajoutez 58 aux deux réponses - Tableau des nombres: 123, CTE récursif: 185

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

Je n'ai aucune idée de la quantité de mémoire que le CTE récursif peut utiliser, mais cela ne gagnera certainement pas de concours de vitesse. L'exemple de recherche de 2 en 0 à 1000000 prend 8 secondes sur mon système.

Voici un SQL Fiddle si quelqu'un veut jouer avec. La requête 1000000 prend plus de 30 secondes pour s'exécuter.

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

Exemple d'utilisation dans la console Rebol (REPL):

>> count 0 1000000 2
== 468559

PowerShell

Deux solutions, les deux 40 37 caractères.

Pour toutes les versions de PowerShell:

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

PowerShell V3 et versions ultérieures ont l' slsalias pour Select-String. Cela nécessite @de forcer un tableau si une seule valeur traverse le pipeline.

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

Lot

@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 peu plus lisible -

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

Agréable et simple. Utilise la manipulation de chaînes pour vérifier si la variable !b!est identique à elle-même sans la troisième entrée utilisateur, %3( !b:%3=!).

Mathematica

Première façon: les cordes

x, y, zsont convertis en chaînes. Si un entier de chaîne n'est pas exempt de z, il est compté.

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

Exemples

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

20
468559

Deuxième voie: listes de chiffres

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

Exemples

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

20
468559

GolfScript

J'ai essayé d'améliorer mes compétences GolfScript, donc j'ai pensé que je pourrais essayer cette question. Voici ce que j'ai trouvé:

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

Cela peut être décomposé comme ceci:

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ême s'il s'agit de GolfScript, l'objectif était plus d'essayer de le rendre relativement efficace plutôt que compact, donc je suis sûr que quelqu'un peut indiquer différentes façons d'améliorer cela.

Démonstration : Notez que j'ai réduit Y dans la démo pour qu'elle puisse se terminer en <5 secondes.

PHP - 112

Pas de boucles visibles, mais un peu lourd en mémoire!

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

Usage php script.php 0 1000000 2

ECMAScript 3 à 6

en utilisant regex:

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

panne:

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
}

en utilisant indexOf:

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

panne:

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
}

^{ce corps de fonction est un caractère de moins que celui de florent, donc lorsque vous utilisez la =>notation de fonction ES6 , le total serait de 62 caractères}

Exemple d'appel: f(0,1e6,2)
Exemple d'utilisation:alert( f(0,1e6,2) );

JSFiddle ici

PS: les deux fonctions ci-dessus renvoient leur variable localer .
Ainsi, lors de la fuite de la variable de résultat rdans la portée globale, on peut à nouveau enregistrer 10 caractères:

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

Exemple d'utilisation: alert( f(0,1e6,2)||r );

Delphi - 120

Un peu trop à mon goût, je vais voir si je peux en retirer.

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 caractères

Un peu d'économie sur les réponses Python existantes.

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

En utilisant les astuces suivantes:

• La somme peut être appliquée à un générateur, contrairement à len, utilisez donc sum (1 ...) au lieu de len ([n ...])
• Utilisez `` au lieu de str (), ce qui permet également ...
• Tuez tous les espaces - voir «1 pour» et «si z+xdansn »
• Supprimez le premier argument range () en commençant à 0 et en testant le décalage (en fait ... ne me sauve rien mais j'aime mieux son apparence :))

En 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 caractères]

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

Usage

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