पूर्णांक के घटित होने की गणना [बंद]

Question

प्रश्न के आधार पर कितने धनात्मक पूर्णांक <1,000,000 में अंक 2 होते हैं? । मैं सबसे रचनात्मक समाधान के लिए देख रहा हूँ से सभी पूर्णांकों की गिनती करने के Xलिए Yपूर्णांक युक्त Z। Z0 से हो सकता है Y।

हर पाया गया इंटीजर केवल एक बार गिना जाता है, भले ही पूर्णांक Zअधिक बार दिखाई देता हो। उदाहरण के लिए:

Z = 2
123 counts 1
22222 also counts 1

मैं जावा में लिखे एक बहुत ही सरल एल्गोरिथ्म के साथ शुरू करूँगा (क्योंकि यह सभी के लिए प्रिय है):

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

यदि आप इस के साथ चलाते हैं

java -jar Count.jar 0 1000000 2

आपको यह परिणाम के रूप में मिलता है:

468559

क्योंकि यह समस्या केवल एक लोकप्रियता-प्रतियोगिता को हल करने के लिए कठिन नहीं है । 28 फरवरी की जीत से पोस्ट किया गया सबसे उत्कीर्ण उत्तर!

Comments

यह आपके पोस्ट से पूरी तरह से स्पष्ट नहीं है, लेकिन मुझे लगता है कि Z 0 और inf के बीच हो सकता है? या सिर्फ 0 और 9 के बीच?

— mmumboss

Z 0 और Y के बीच हो सकता है। इससे कोई मतलब नहीं है कि Z Y से बड़ा हो सकता है।

— Obl Tobl

@OblTobl क्या आप वास्तव में Z> Y मामले को स्पष्ट रूप से बाहर करना चाहते हैं? क्यों न केवल उस मामले में अपेक्षित आउटपुट 0 हो?

— क्रंचर

@ क्रंचर मुझे कोई आपत्ति नहीं है! लेकिन मुझे लगता है कि यह थोड़ा बेकार है; ;-)

— Obl Tobl

क्या इसका मतलब यह है कि यह Nहो सकता है 123और यह केवल तभी मेल खाएगा जब विकल्प 123 मौजूद है?

— पॉपुलस

Answer 1

बैश (20)

seq $1 $2|grep -c $3

प्रयोग

$ bash count.sh 0 1000000 2
468559

Comments

यह मजेदार है अगर कॉल कार्यक्रम से अधिक लंबा है ;-)

— Obl Tobl

Answer 2

funciton

हमेशा की तरह, चूंकि StackExchange द्वारा जोड़ी गई लाइन ऊंचाई टूट जाती है, इसे $('pre').css('line-height',1)ठीक करने के लिए अपने ब्राउज़र कंसोल में चलने पर विचार करें।

मेरे अन्य Funciton उत्तरों के विपरीत, यह कोई भी फ़ंक्शन घोषणाओं का उपयोग नहीं करता है। यह सिर्फ एक कार्यक्रम है। यह एक मेमने की अभिव्यक्ति का उपयोग करता है, हालांकि - एक विशेषता जिसे मैंने दिसंबर में फंसीटोन में जोड़ा :)

इनपुट को तीन दशमलव पूर्णांक (नकारात्मक हो सकता है) के रूप में रिक्त स्थान (यानी x y z) द्वारा अलग किया जाता है । वास्तव में, zकोई भी स्ट्रिंग हो सकती है; उदाहरण के लिए, यह −अंतराल में ऋणात्मक संख्याओं की गणना करने के लिए सिर्फ ऋण चिह्न ( , U + 2212) हो सकता है :)

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

Comments

यह बहुत मजेदार है! एक भाषा का उपयोग करके आपने खुद को बनाया

— pcnThird

@ pcnThird: मुझे लगता है कि टिमवी अपना सारा समय या तो गोल्फिंग में बिताते हैं या फिर ऐसी भाषाएं बनाते हैं, जिसमें गोल्फ (स्केपलिंग भी देखें)!

— गाबे

Answer 3

सी#

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

उदाहरण

count.exe 0 1000000 2
468559

Comments

चतुर समाधान! मुझे यह पसंद है कि आपने इसे बिना लूप के किया।

— ओबेल टोबेल

एक दृश्य लूप के बिना @OblTobl ।

— जस्टिन

बेशक, अच्छा वैसे भी

— Obl Tobl

यह एक बग है, .Rangeस्वीकार करता है (int start, int count), नहीं (start, end)। मैं हमेशा इस फंदे में खुद

— गिरता

मुझे जल्दी से नोटपैड में दस्तक देने के लिए सही काम करता है ... मैंने कोड को बदल दिया है इसलिए यह अब सही है!

— मो डी

Answer 4

एपीएल (29)

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

यह एक फ़ंक्शन है जो Zबाएं तर्क के रूप में और अंतराल [X,Y]सही तर्क के रूप में लेता है:

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

Comments

वास्तव में स्पष्ट नहीं है ... लेकिन वास्तव में अच्छा है!

— ओबल टोबेल

Answer 5

पायथन 2.7

तेजी की जरूरत

व्याख्या

कार्यान्वयन

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

डेमो

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

तुलना

@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

Comments

यह निश्चित रूप से बहुत तेज है, लेकिन यह प्रश्न की आवश्यकताओं को पूरा नहीं करता है। keyकोई भी पूर्णांक हो सकता है , अंक नहीं, बीच loऔर hi।

— डेनिस

वहाँ अभी भी एक गणितीय समाधान है, हालांकि यह और भी लंबा होगा ...

— लाल चेतावनी

Answer 6

पायथन 2.7

नियमित अभिव्यक्ति का उपयोग कर एक समाधान:

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

Comments

आप re.findallएक लाइनर का उपयोग करके कर सकते हैं__import__('re').findall('\d...

— सिमोन

Answer 7

दे घुमा के - 32 31 17 X, Y और Z के 14 अक्षर + लंबाई

सुझाव के लिए devnull के लिए धन्यवाद seq!

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

जैसे X = 100, Y = 200, Z = 20

$ seq 100 200|grep -c 20
2

जैसे X = 100, Y = 200, Z = 10

$ seq 100 200|grep -c 10
11

जैसे X = 0, Y = 1000000, Z = 2

$ seq 0 1000000|grep -c 2
468559

Comments

अच्छा और स्पष्ट एक!

— ओबेल टोबेल

echoजब आप seq4 वर्णों की लंबाई का उपयोग और कम कर सकते हैं तो उपयोग क्यों करें ? (कमांड की लंबाई के लिए, 2 घुंघराले ब्रेसिज़ को छोड़ने में सक्षम होने के लिए 2 और ..एक स्थान के साथ 1 के लिए )

— devnull

@देवनुल - धन्यवाद, और इससे छुटकारा भी मिल सकता है xargsऔर wc- और यह बहुत तेजी से चलता है!

Answer 8

पीएचपी

मूल कुछ भी नहीं, बस अपनी पहली पोस्ट यहाँ मना रहा हूँ।

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

?>

इनपुट

php script.php 0 1000000 2

उत्पादन

468559

Answer 9

स्काला:

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

Answer 10

माणिक

कम करने के लिए यह एक बेहतरीन उदाहरण है!

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

इनपुट:

ruby script.rb 0 1000000 2

आउटपुट:

468559

Answer 11

पायथन गोल्फ - 61

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

पायथन नॉन-गोल्फ

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

Answer 12

Java8

नए IntStream सामान का उपयोग करते हुए, यह अनिवार्य रूप से एक लाइनर बन जाता है, यदि आप अनिवार्य जावा फ्रेमवर्क सामान को अनदेखा करते हैं:

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

यह यहां चलाया जा सकता है , हालांकि मुझे मूल्यों को हार्डकोड करना था।

Comments

वास्तव में दिलचस्प जावा समाधान

— Obl Tobl

Answer 13

एफ #

यह समाधान IndexOfस्ट्रिंग को खोजने के लिए उपयोग करता है, फिर परिणाम को 1 में बदलने के लिए थोड़ी संख्या में फ़िडलिंग होता है, और यदि नहीं मिला, तो 0 परिणाम प्राप्त करता है:

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

और इसे इस तरह कहा जा सकता है:

count 0 1000000 "2" // 468559

Answer 14

नियमित अभिव्यक्ति

निम्नलिखित 49 तक 1 अंक गिनेंगे।

#!/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"

Answer 15

आर 23 25 27घर का काम

बस काम के लिए सही उपकरण प्राप्त करें। आर में grep का सरल उपयोग, कुछ भी नहीं फैंसी।

यह वही करता है: जब तक वेक्टर में grepसभी उदाहरण हैं और उपयोग करने वाले परिणामों की संख्या की गणना करते हैं ।2010e6length

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

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

परिणाम: [1] 468559

---

ऑफ़कोर्स आप एक फ़ंक्शन लिख सकते हैं जो संख्याओं को इनपुट के रूप में लेता है, जैसे कि इसे उदाहरण में दिखाया गया है।

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

अब आप countx, y और z के साथ कॉल कर सकते हैं , यदि unset (जो कि डिफ़ॉल्ट रूप से है), क्रमशः x, y और z के मान 0, 1000000 और 2 हैं। कुछ उदाहरण:

count()
[1] 468559

या

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

या

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

कुछ लोग सोचते हैं कि समय का महत्व है, आर में इस फ़ंक्शन का उपयोग करने में लगभग 1 सेकंड लगता है।

system.time(count())
user  system elapsed 
0.979   0.003   0.981

Comments

शायद यह बहुत छोटा है ;-)

— ओबल टोबेल

खैर, यह वैसे भी कोड-गोल्फ नहीं है :) मुझे आश्चर्य है: यदि प्रोग्राम को इनपुट के रूप में संख्याओं को लेना है (बजाय उन्हें हार्डकोड करने के) तो क्या होगा?

— टिमवी

अकल्पनीय के लिए एक समारोह बनाया;)

— CousinCocaine

Answer 16

जावास्क्रिप्ट (ईएस 6), 63

f=(i,j,n)=>{for(c=0;i<=j;!~(''+i++).indexOf(n)?0:c++);return c}

उपयोग:

f(0, 1e6, 2)
> 468559

संयुक्त राष्ट्र के golfed:

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
}

Answer 17

माणिक

मूल रूप से मैंने पाब्लो के उत्तर और अर्ध-गोल्फ (38 वर्ण यदि आप अनावश्यक व्हाट्सएप को छोड़ते हैं) लिया तो इसका उपयोग करने का एक महान उदाहरण नहीं है select।

यह उस सीमा के प्रत्येक सूचकांक का चयन करता (x .. y)है जिसमें सम्‍मिलित है z। यह मध्यवर्ती परिणाम दुर्भाग्य से एक सरणी में संग्रहीत किया जाता है, जिसका आकार तब वापस आ जाता है।

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

यह दोनों वाक्यात्मक और शब्दार्थ रूप से काफी साफ-सुथरा दिखता है, हालांकि यह i[z]हिस्सा वास्तव में समझ में नहीं आता है।

यह काम करता है क्योंकि xऔर yवास्तव में तार हैं, संख्या नहीं! इस प्रकार प्रत्येक iभी एक स्ट्रिंग है, और i[z]यदि स्ट्रिंग zमें निहित है , तो निश्चित रूप से जांचता है i।

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

Answer 18

पायथन 2.7, 70 संकेत

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

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

कम, 65 संकेत

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

Comments

मुझे नहीं लगता कि range(0,y+1)अगर आपको range(y+1)एक ही चीज़ की ज़रूरत है। इसके अलावा, आप उन जगहों को हटा सकते हैं, अगर आप गोल्फ कर रहे हैं ...

— साइमनट

Answer 19

रूबी का उपयोग करना Enumerable#grep:

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

Answer 20

T-SQL

मैं चर मान सकते हैं तो @X, @Yहै, और @Zउपलब्ध हैं:

एक (मनमाने ढंग से बड़े के साथ) मौजूदा संख्या तालिका - 65

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

एक पुनरावर्ती 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)

---

यदि चर को स्पष्ट रूप से परिभाषित करने की आवश्यकता है:

दोनों उत्तरों में 58 जोड़ो - संख्या तालिका: 123, पुनरावर्ती CTE: 185

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

---

मुझे नहीं पता कि पुनरावर्ती CTE कितनी मेमोरी का उपयोग कर सकता है, लेकिन यह निश्चित रूप से किसी भी गति प्रतियोगिता को जीतने वाला नहीं है। 0 से 1000000 में 2 की खोज का उदाहरण मेरे सिस्टम पर 8 सेकंड लेता है।

अगर कोई इसके साथ खेलना चाहता है तो यहां SQL Fiddle है। 1000000 क्वेरी को चलने में 30+ सेकंड लगते हैं।

Comments

तेजी से नहीं, लेकिन बहुत रचनात्मक!

— ओबेल टोबेल

Answer 21

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

Rebol कंसोल (REPL) में उपयोग उदाहरण:

>> count 0 1000000 2
== 468559

Answer 22

शक्ति कोशिका

दो समाधान, दोनों 40 37 चार्ट।

PowerShell के सभी संस्करणों के लिए:

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

PowerShell V3 और अप के लिए slsउपनाम है Select-String। इसके लिए @एक सरणी को बाध्य करने की आवश्यकता होती है यदि केवल एक मूल्य इसे पाइपलाइन के माध्यम से बनाता है।

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

Answer 23

जत्था

@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

थोड़ा और पठनीय -

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

अच्छा और सरल। यह जाँचने के लिए स्ट्रिंग हेरफेर का उपयोग करता है कि क्या चर !b!तीसरे उपयोगकर्ता इनपुट के बिना समान है, %3( !b:%3=!)।

Answer 24

मेथेमेटिका

पहला तरीका: तार

x, y, zस्ट्रिंग्स में परिवर्तित हो जाते हैं। यदि एक स्ट्रिंग-पूर्णांक मुक्त नहीं है z, तो इसे गिना जाता है।

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

उदाहरण

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

20
468559

---

दूसरा तरीका: अंकों की सूची

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

उदाहरण

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

20
468559

Comments

गणितज्ञ हमेशा आकर्षक होता है, यहां तक ​​कि साधारण समस्याओं के लिए भी

— Obl Tobl

Answer 25

GolfScript

मैं अपने गोल्फस्क्रिप्ट कौशल में सुधार करने की कोशिश कर रहा हूं, इसलिए मैंने सोचा कि मैं इस प्रश्न के साथ एक शॉट दूंगा। यहाँ मैं क्या लेकर आया हूँ:

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

इसे इस तरह तोड़ा जा सकता है:

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

भले ही यह गोल्फस्क्रिप्ट है, लक्ष्य से अधिक कॉम्पैक्ट के बजाय इसे अपेक्षाकृत कुशल बनाने की कोशिश करने के लिए अधिक था, इसलिए मुझे यकीन है कि कोई इसे सुधारने के विभिन्न तरीकों को इंगित कर सकता है।

प्रदर्शन : ध्यान दें कि मैंने Y को डेमो में कम कर दिया है ताकि यह 5 सेकंड में पूरा हो सके।

Answer 26

PHP - 112

कोई दृश्यमान छोरियां नहीं, लेकिन स्मृति पर भारी!

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

प्रयोग php script.php 0 1000000 2

Answer 27

ECMAScript 3 से 6

(जावास्क्रिप्ट, JScript आदि)

रेगेक्स का उपयोग करना:

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

टूट - फूट:

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
}

indexOf का उपयोग करना:

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

टूट - फूट:

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
}

^{यह फ़ंक्शन-बॉडी एक चार्ट कम है, तो फ़्लोरेंट का है, इसलिए ES6 =>फ़ंक्शन नोटेशन का उपयोग करते समय कुल 62 चार्ट होगा}

उदाहरण कॉल: f(0,1e6,2)
उदाहरण उपयोग:alert( f(0,1e6,2) );

यहाँ JSFiddle

पुनश्च: उपरोक्त दोनों फ़ंक्शन अपने स्थानीय चर को वापस करते हैं r।
इसलिए जब परिणाम चर rको वैश्विक दायरे में लीक किया जाता है, तो कोई फिर से 10 वर्णों को बचा सकता है:

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

उदाहरण का उपयोग करें: alert( f(0,1e6,2)||r );

Answer 28

डेल्फी - 120

मेरे स्वाद के लिए बहुत कुछ, यह देखने के लिए कि क्या मैं कुछ बंद कर सकता हूं।

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.

Comments

लंबाई के लिए बुरा मत मानना, मुझे डेल्फी सॉल्यूशन देखना बहुत पसंद है ;-)

— Obl Tobl

पी: @OblTobl महान है, लेकिन इसकी बहुत मजेदार यह कम कर प्रयास करने के लिए

— टुन PRONK

Answer 29

पायथन 2.7 - 50 चार्ट

मौजूदा पायथन जवाबों पर बचत का एक सा।

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

निम्नलिखित ट्रिक्स का उपयोग करना:

• सम जेन पर लागू किया जा सकता है, लेन के विपरीत, इसलिए len ([n ...]) के बजाय sum (1 ...) का उपयोग करें
• Str के बजाय `` का प्रयोग करें (), जो अनुमति देता है ...
• सभी रिक्त स्थान को मारने - '1for' देख सकते हैं और 'अगर z+xमें n'
• 0 से शुरू करके और ऑफसेट का परीक्षण करके पहली श्रेणी () आर्ग निकालें (वास्तव में ... मुझे कुछ भी नहीं बचाता है लेकिन मुझे यह बेहतर लग रहा है :)

कार्रवाई में:

In [694]: (lambda x,y,z:sum(1for n in range(y-x)if`z+x`in`n`))(0,1000000,2)
Out[694]: 468559

Answer 30

k [28 वर्ण]

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

प्रयोग

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

Comments

आप के $:[z]साथ बदलकर एक चरित्र को बचा सकते हैं ($z)।

— मोलमेक्स

हालाँकि, आपके समाधान की ऊपरी सीमा गलत है। यह x से x + y-1 की गणना करता है, x से y की ओर नहीं।

— मोलमेक्स