38

सवाल :

आपको एक अनुक्रम के शुरुआती और अंत पूर्णांक दिए जाएंगे और इसके भीतर पूर्णांकों की संख्या को वापस करना चाहिए जिसमें अंक शामिल नहीं हैं 5। प्रारंभ और अंत संख्या शामिल होनी चाहिए!

उदाहरण:

1,9 → 1,2,3,4,6,7,8,9 → परिणाम 8

4,17 → 4,6,7,8,9,10,11,12,13,14,16,17 → परिणाम 12

50,60 → 60 → परिणाम 1

-59, -50 → → परिणाम 0

परिणाम में पाँच हो सकते हैं।

प्रारंभ संख्या हमेशा अंतिम संख्या से छोटी होगी। दोनों संख्याएँ नकारात्मक भी हो सकती हैं!

मैं आपके समाधानों और आपके समाधान के तरीके के लिए बहुत उत्सुक हूं। हो सकता है कि आप में से कोई एक आसान शुद्ध गणित समाधान पा ले।

संपादित करें यह एक कोड गोल्फ चुनौती है, तो कम से कम कोड जीतता है।

code-golf math

— Arasuvel
स्रोत

3

@ बेत्सेक: वह करीब है; लेकिन इसकी एक चर रेंज है (और इसके लिए कोई मोडुलो की आवश्यकता नहीं है)।

— टाइटस

4

मैं जीतने की कसौटी और कोड-गोल्फ टैग के रूप में सबसे छोटा कोड सुझाता हूं (मुझे यह भी पता नहीं था कि यह नहीं था!)। इसके अलावा, आपको शायद एक परीक्षण मामला रखना चाहिए जो 50 या 500 तक फैला हो; शायद यह भी कि एक स्पैन्स -50, और एक स्पैन ० एक अच्छा विचार होगा।

— जोनाथन एलन

1

@JonathanAllan: मैं उदाहरणों को अपडेट करूंगा।

— अरसुवेल

4

टेस्ट मामला: 50, 59 -> 0।

— जर्गब

14

आप कहते हैं: "आरंभ संख्या हमेशा अंतिम संख्या से छोटी होगी।" लेकिन आपका एक उदाहरण (-50, -59) सीधे इस बात का खंडन करता है

— Theonlygusti

21

जावास्क्रिप्ट (ईएस 6), 36 33 बाइट्स

करी सिंटैक्स के साथ इनपुट लेता है (a)(b)।

a=>F=b=>b<a?0:!/5/.test(b)+F(b-1)

प्रारूपित और टिप्पणी की गई

a =>                 // outer function: takes 'a' as argument, returns F
  F = b =>           // inner function F: takes 'b' as argument, returns the final result
    b < a ?          // if b is less than a
      0              //   return 0
    :                // else
      !/5/.test(b) + //   add 1 if the decimal representation of b does not contain any '5'
      F(b - 1)       //   and do a recursive call to F with b - 1

परीक्षण के मामलों

कोड स्निपेट दिखाएं

let f =

a=>F=b=>b<a?0:!/5/.test(b)+F(b-1)

console.log(f(1)(9))
console.log(f(4)(17))
console.log(f(50)(60))
console.log(f(-50)(-59))

स्निपेट का विस्तार करें

— Arnauld
स्रोत

(मैं आमतौर testपर execतब पसंद करता हूं जब आपको केवल बूलियन की आवश्यकता होती है।)

— नील

@ नील वास्तव में अधिक समझ में आता है। अपडेट किया गया।

— अरनौलद

NB: मैं ES6 करी वाक्यविन्यास के बारे में कोई टिप नहीं पा सका, इसलिए मैंने एक लिखा ।

— अरनौलद

5

@ TheLethalCoder b<aसे सभी नंबरों के माध्यम से गिनती के बाद पुनरावृत्ति को रोकने के bलिए है a, इसलिए इसे हटाने से बस एक अनंत पुनरावृत्ति होगी।

— ETHproductions

1

@HristiyanDodov अनाम बाहरी फ़ंक्शन aतर्क के रूप में लेता है और Fफ़ंक्शन को लौटाता है , जो बदले bमें तर्क के रूप में लेता है और - जैसा कि आपने देखा - से इसे पुनरावृति करने के लिए पुनरावर्ती कहा जाता bहै a, सभी पूर्णांकों के लिए एक काउंटर बढ़ाते हैं जिसमें 5उनके दशमलव शामिल नहीं होते हैं प्रतिनिधित्व।

— अरनौलद

17

जेली , 8 7 बाइट्स

डेनिस के लिए -1 बाइट

rAw€5¬S

TryItOnline!

कैसे?

rAw€5¬S - Main link: from, to    e.g. -51, -44
r       - range(from, to)        e.g. [-51,-50,-49,-48,-47,-46,-45,-44]
 A      - absolute value         e.g. [51,50,49,48,47,46,45,44]
  w€    - first index of... for €ach (0 if not present)
    5   - five                   e.g. [1,1,0,0,0,0,2,0]
     ¬  - logical not            e.g. [0,0,1,1,1,1,0,1]
      S - sum                    e.g. 5

* निरपेक्ष मान परमाणु, Aएक दशमलव सूची में नकारात्मक संख्या डाली गई नकारात्मक प्रविष्टियों के बाद से आवश्यक है, जिनमें से कोई भी कभी भी एक नहीं होगा 5(दिए गए उदाहरण दो के बजाय सभी आठ की गिनती करेंगे)।

— जोनाथन एलन
स्रोत

rAw€5¬Sएक बाइट बचाता है।

— डेनिस

@ डेनिस धन्यवाद! क्या मेरा विवरण "उस संख्या को दशमलव सूची के रूप में मानता है" सटीक?

— जोनाथन एलन

2

बहुत ज्यादा। wअपने दशमलव अंकों में पूर्णांक तर्क देता है।

— डेनिस

13

बैश + जीआरपी, 17 बाइट्स

seq $@|grep -cv 5

इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत

13

2sable , 6 5 बाइट्स

अदनान को बाइट देकर धन्यवाद दिया

Ÿ5¢_O

इसे ऑनलाइन आज़माएं!

व्याख्या

 Ÿ      # inclusive range
  5¢    # count 5's in each element of the range
    _   # negate
     O  # sum

नोट: यह कार्य ¢सूची में मिलान तत्वों को गिनने के बजाय फ़ंक्शन को प्रत्येक तत्व पर लागू करने के लिए बग के कारण काम करता है ।

— Emigna
स्रोत

आप `एरेज़ पर समान व्यवहार करने पर इसे हटा सकते हैं: p।

— अदनान

@ अदनान: धन्यवाद! मैं परीक्षण करने वाला था लेकिन भूल गया था;)

— एमिग्ना

9

पायथन 2, 59 55 52 51 47 43 42 बाइट्स

f=lambda a,b:a<=b and-(`5`in`a`)-~f(a+1,b)

एक पुनरावर्ती समाधान। तार्किक संचालकों का उपयोग करके समाधान खोजने के लिए मुझे प्रेरणा देने के लिए @xnor को धन्यवाद ! इसके अलावा, @JonathanAllan और @xnor को मेरा मार्गदर्शन करने और 43 से 42 तक की बाइट काटने के लिए धन्यवाद !

43 बाइट्स में अन्य प्रयास

f=lambda a,b:a<=b and-~-(`5`in`a`)+f(a+1,b)
f=lambda a,b:a<=b and 1-(`5`in`a`)+f(a+1,b)

— Yytsi
स्रोत

चाहेंगे if!`x`.count('5')काम करते हैं?

— टाइटस

2

@ टिट्स पायथन में notऑपरेटर है !जो सी- लाइक भाषाओं में है, लेकिन इसमें 3 बाइट्स हैं :(

— यति

1

के साथ तार्किक शॉर्ट-सर्किटिंग का उपयोग करने के बारे में सोचें andऔर or।

— xnor

1

हाँ, अच्छी तरह से किया! अब इसे छोटा करने के बारे में सोचें not।

— xnor

1

तुम सच में करीब हो! सामान रखने की कोशिश करें।

— xnor

6

बैश / यूनिक्स उपयोगिताओं, 21 बाइट्स

seq $*|sed /5/d|wc -l

इसे ऑनलाइन आज़माएं!

— मिशेल स्पेक्टर
स्रोत

6

05AB1E , 8 7 6 बाइट्स

अदनान को बाइट देकर धन्यवाद दिया

Ÿ5.å_O

इसे ऑनलाइन आज़माएं!

व्याख्या

Ÿ         # inclusive range
 5.å      # map 5 in y for each y in the list
    _     # logical negation 
     O    # sum

— Emigna
स्रोत

05AB1E ने भी वेक्टर किया है å, जो कि 6 बाइट्स के लिए .åकर सकते हैं Ÿ5.å_O।

— अदनान

negateअर्थ -n, या n==0?1:0?

— ETHproductions

@ETHproductions: क्षमा करें, यह अस्पष्ट था। मेरा मतलब था कि नकारात्मक नकार, इसलिएn==0?1:0

— इमीना २०'१

6

अजगर, ९ 9 बाइट्स

FryAmTheEggman के लिए एक बाइट धन्यवाद बचा लिया!

lf-\5T}E

स्पष्टीकरण:

        Q # Input
      }E  # Form an inclusive range starting from another input
          #   order is reversed, but doesn't matter
 f-\5T    # Filter by absence of '5'
l         # Count the number of elements left

इसे ऑनलाइन आज़माएं!

— busukxuan
स्रोत

5

पर्ल 6 , 23 बाइट्स

{+grep {!/5/},$^a..$^b}

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

{                     }  # A lambda.
              $^a..$^b   # Range between the two lambda arguments.
  grep {!/5/},           # Get those whose string representation doesn't match the regex /5/.
 +                       # Return the size of this list.

— SMLS
स्रोत

5

हास्केल , 39 बाइट्स

s!e=sum[1|x<-[s..e],notElem '5'$show x]

इसे ऑनलाइन आज़माएं! उपयोग:

Prelude> 4 ! 17
12

स्पष्टीकरण:

             [s..e]                     -- yields the range from s to e inclusive
          x<-[s..e]                     -- for each x in this range
          x<-[s..e],notElem '5'$show x  -- if the char '5' is not in the string representation of x
       [1|x<-[s..e],notElem '5'$show x] -- then add a 1 to the resulting list      
s!e=sum[1|x<-[s..e],notElem '5'$show x] -- take the sum of the list

— Laikoni
स्रोत

4

आर, 33 बाइट्स

f=function(x,y)sum(!grepl(5,x:y))

उपयोग:

> f=function(x,y)sum(!grepl(5,x:y))
> f(40,60)
[1] 10
> f(1,9)
[1] 8
> f(4,17)
[1] 12

— plannapus
स्रोत

4

ऑक्टेव , 36 बाइट्स

@(m,n)sum(all(dec2base(m:n,10)'-52))

इसे ऑनलाइन आज़माएं!

— लुइस मेंडो
स्रोत

4

ग्रोवी, 47 45 43 40 बाइट्स

{a,b->(a..b).findAll{!(it=~/5/)}.size()}

यह एक अनाम क्लोजर है। अजगर में एक सूची में एक शर्त findAllजोड़ने के समान है if।

इसे ऑनलाइन आज़माएं!

— गुरुपाद ममदापुर
स्रोत

4

PHP 7.1, 57 55 बाइट्स

for([,$a,$b]=$argv;$a<=$b;)$n+=!strstr($a++,53);echo$n;

साथ दौड़ो php -r '<code>' <a> <b>

— टाइटस
स्रोत

क्या यह PHP7.1 वाक्यविन्यास नहीं है?

— सकल

@ सकल: यह है। लेकिन PHP 7.1 5 घंटे ( दिसंबर, 1 को प्राप्त ) से अधिक पुराना है

— टाइटस

1

बेशक, मैंने सिर्फ इसलिए पूछा क्योंकि मैं संस्करण को निर्दिष्ट करने के लिए उपयोग किया जाता हूं अगर यह 7 या ऊपर है। यह भी अजगर के लिए एक तरह का सम्मेलन है

— सकल'

1

PHP के लिए कन्वेंशन - जहां तक मैंने देखा है - सबसे हाल के संस्करण का उपयोग करना है जब तक कि अन्यथा निर्दिष्ट न हो।

— टाइटस

मुझे नहीं लगता कि कई लोगों के पास नवीनतम मामूली संस्करण है। इस समय कम से कम आम भाजक संभवतः 5.5 होगा। व्यक्तिगत रूप से मैं एफसी 25 का उपयोग कर रहा हूं (जिसे सुंदर अत्याधुनिक माना जाता है), जो वर्तमान में PHP 7.0 वितरित करता है। यदि आप विंडोज पर हैं तो आपको मैन्युअल रूप से अपडेट करने की आवश्यकता है।

— मध्याह्न

4

मैथेमेटिका, 46 44 42 बाइट्स

2 बाइट्स की बचत के लिए एलेफाल्फा और डेविडसी का धन्यवाद!

Tr@Boole[FreeQ@5/@IntegerDigits@Range@##]&

दो पूर्णांक तर्क देने और पूर्णांक वापस करने का कार्य करें। IntegerDigits@Range@##अंकों की सूचियों में इनपुट के बीच सभी संख्याओं को परिवर्तित करता है; FreeQ@5उन सूचियों का परीक्षण करने के लिए जो कोई भी शामिल नहीं है 5। फिर Booleबुलियन को शून्य और लोगों में परिवर्तित करता है, और Trपरिणाम प्रस्तुत करता है।

अन्य समाधान (44 और 47 बाइट्स):

Count[Range@##,x_/;IntegerDigits@x~FreeQ~5]&

IntegerDigits@x~FreeQ~5यह निर्धारित करता है कि किसी संख्या के अंकों की सूची 5s से मुक्त है, और Count[Range@##,x_/;...]&गिना जाता है कि इनपुट के बीच कितने नंबर उस परीक्षण से गुजरते हैं।

Tr[Sign[1##&@@IntegerDigits@#-5]^2&/@Range@##]&

1##&@@IntegerDigits@#-5एक संख्या के अंकों की सूची लेता है, उन सभी से 5 घटाता है, और एक साथ उत्तरों को गुणा करता है; Sign[...]^2फिर सभी गैर-संख्याओं को 1 में परिवर्तित करता है।

— ग्रेग मार्टिन
स्रोत

1

Count[Range@##,x_/;IntegerDigits@x~FreeQ~5]&

— डेविड जेएन

1

Tr@Boole[FreeQ@5/@IntegerDigits@Range@##]&

— एलेफाल्फा

3

रूबी, 36 35 बाइट्स

->a,b{(a..b).count{|x|!x.to_s[?5]}}

Thx IMP1 -1 बाइट के लिए

— जीबी
स्रोत

1

क्या यह उस सूची के आकार के बजाय 5 की संख्या के बिना सूची वापस नहीं करता है?

— आईएमपी 1

आप सही हैं, मेरे पास गलत संस्करण कॉपी / पेस्ट है।

— जीबी

1

आप बाइट को बचाने के लिए खोज में / के बजाय ?5( '5'चरित्र) का उपयोग कर सकते हैं /5।

— आईएमपी 1

3

जावा 7, 80 78 बाइट्स

int c(int a,int b){int r=0;for(;a<=b;)r+=(""+a++).contains("5")?0:1;return r;}

Ungolfed:

int c(int a, int b){
  int r = 0;
  for (; a <= b; ) {
    r += ("" + a++).contains("5")
          ? 0
          : 1;
  }
  return r;
}

टेस्ट कोड:

इसे यहाँ आज़माएँ।

class M{
  static int c(int a,int b){int r=0;for(;a<=b;)r+=(""+a++).contains("5")?0:1;return r;}

  public static void main(String[] a){
    System.out.println(c(1, 9));
    System.out.println(c(4, 17));
  }
}

आउटपुट:

8
12

— केविन क्रूज़सेन
स्रोत

3

पॉवरशेल, 42 41 बाइट्स

param($a,$b)$a..$b|%{$z+=!($_-match5)};$z

कमांड लाइन से इस रूप में कॉल किया जाता है। \ no5s.ps1 1 20

— मैक्मुर्डो
स्रोत

1

आप एक बाइट को बचाने के लिए जगह छोड़ सकते हैं। कड़ाई से संख्यात्मक रेगेक्स पैटर्न के साथ, आपको एक सीमांकक (जैसे, -replace3या -split1या -notmatch5) की आवश्यकता नहीं है ।

— AdmBorkBork

आह, अच्छा, धन्यवाद @AdmBorkBork

— mcmurdo

2

पायथन 2, 61 56 बाइट्स

lambda a,b:len([n for n in range(a,b+1) if not"5"in`n`])

-5 बाइट्स tukkaaX के लिए धन्यवाद

— sagiksp
स्रोत

निराश मत हो! मज़ा लेना और खुद को चुनौती देना यही मायने रखता है। आप दो not "5" inव्हाट्सएप को हटा सकते हैं :) इसके अलावा, यदि आप पायथन 2 का उपयोग कर रहे हैं, तो आप xकरने के बजाय `` उद्धरण के साथ घेर सकते हैं str(x)।

— यति

@TuukkaX धन्यवाद! के बीच की जगह को भी हटा दिया और `x`

— sagiksp

आप निकाल सकते हैं []। आपको पहले भी स्थान की आवश्यकता नहीं है if।

— डेनिस

@ डेनिस मैंने कोशिश की कि पहले से ही, लेकिन यह शिकायत करता है कि "प्रकार की वस्तु 'जनरेटर' में कोई लेन () नहीं है।

— यति

@TuukkaX राइट। lambda a,b:sum(not"5"in`n`for n in range(a,b+1))हालांकि काम करता है। tio.run/nexus/…

— डेनिस

2

स्विफ्ट 52 बाइट्स

($0...$1).filter { !String($0).contains("5") }.count

— Arasuvel
स्रोत

चूंकि आपकी चुनौती एक कोडगॉल्फ चुनौती है, इसलिए आपको अपने बायटेकाउंट को शामिल करना चाहिए। इसके अलावा, कोडगॉल्फ में (कम से कम यहां), यह एक आवश्यकता है कि सभी प्रोग्राम म्यूज वास्तव में कंटेस्ट हो रहे हैं (जैसे कि आपका फंक्शन का नाम सिर्फ एक कैरेक्टर हो सकता है, आपका वास्तविक फंक्शन शायद सिंगल लाइन तक कम हो सकता है)। मैं स्विफ्ट नहीं जानता, आपको सामान पर मुझे सही करना पड़ सकता है।

— ५

2

बैच, 95 बाइट्स

@set/an=0,i=%1
:g
@if "%i%"=="%i:5=%" set/an+=1
@set/ai+=1
@if %i% leq %2 goto g
@echo %n%

मैन्युअल रूप से लूपिंग कुछ बाइट्स को बचाता है क्योंकि मुझे एक चर में वैसे भी लूप काउंटर की आवश्यकता है।

— नील
स्रोत

2

PHP, 56 बाइट्स

for($i=$argv[1];$i<=$argv[2];)trim(5,$i++)&&$x++;echo$x;

इस तरह से चलाएं:

php -r 'for($i=$argv[1];$i<=$argv[2];)trim(5,$i++)&&$x++;echo$x;' 1 9 2>/dev/null;echo
> 8

PHP 7.1 का एक संस्करण 53 बाइट्स (टाइटस को क्रेडिट) होगा:

for([,$i,$e]=$argv;$i<=$e;)trim(5,$i++)&&$x++;echo$x;

व्याख्या

for(
  $i=$argv[1];          # Set iterator to first input.
  $i<=$argv[2];         # Loop until second input is reached.
)
  trim(5,$i++) && $x++; # Trim string "5" with the characters in the
                        # current number; results in empty string when
                        # `5` is present in the number. If that is not
                        # the case, increment `$x`

echo$x;                 # Output `$x`

— aross
स्रोत

आह खतरा मैं दूसरे trimपैरामीटर के बारे में फिर से भूल गया ।

— टाइटस

2

सीजेम "आसान शुद्ध गणित समाधान", 60

{{Ab5+_,\_5#)<\9e]);_4f>.m9b}%}:F;q~_:z$\:*0>{((+F:-}{F:+)}?

इसे ऑनलाइन आज़माएं

यह किसी भी क्रम में, एक सरणी में संख्याओं को लेता है।

स्पष्टीकरण:

एक मुख्य समस्या किसी भी सकारात्मक n के लिए f (n) = 1 से n (समावेशी) की गैर-5 संख्याओं की गणना करना है। और इसका उत्तर है: n के दशमलव अंकों को लीजिए, पहले 5 के बाद सभी अंकों को प्रतिस्थापित करें (यदि कोई हो) 9 के साथ, तो सभी अंकों को 5..9 के साथ 4..8 (घटाव) के साथ बदलें, और आधार से परिवर्तित करें 9. उदाहरण 1752 → 1759 → 1648 → 1 * 9 ^ 3 + 6 * 9 ^ 2 + 4 * 9 + 8 = 1259। मूल रूप से, प्रत्येक अंक की स्थिति में 9 स्वीकार्य मूल्य होते हैं, और एक 5xxxx 49999 के बराबर होता है क्योंकि उनके बीच अधिक वैध संख्या नहीं होती है।

एक बार जब हम इसे हल कर लेते हैं, तो हमारे पास कुछ मामले होते हैं: यदि इनपुट नंबर (a और b, <b) कहते हैं (सख्ती से) सकारात्मक हैं, तो परिणाम f (b) -f (a-1) है। यदि वे नकारात्मक हैं, तो हम पूर्ण मूल्यों को ले सकते हैं, उन्हें फिर से व्यवस्थित कर सकते हैं और उसी गणना का उपयोग कर सकते हैं। और अगर एक <= 0 <= b तो परिणाम f (-a) + f (b) +1 है।

कार्यक्रम पहले फ़ंक्शन एफ को ऊपर वर्णित के रूप में लागू करता है (लेकिन एक सरणी में प्रत्येक संख्या पर लागू होता है), फिर इनपुट पढ़ता है, संख्याओं को पूर्ण मान में परिवर्तित करता है और उन्हें फिर से व्यवस्थित करता है, और ऊपर दिए गए 2 गणनाओं में से एक का उपयोग करता है, चाहे वह एक पर आधारित हो * b> 0 शुरू में।

— aditsu
स्रोत

"शुद्ध" नहीं बल्कि अच्छी विधि। यहाँ, एक +1 :)

— मैथ्यू रो

@MatthewRoh धन्यवाद, लेकिन आपका क्या मतलब है जो शुद्ध नहीं है? यह एक ऐसा समाधान है जो सीमा के माध्यम से पुनरावृत्ति किए बिना, इनपुट संख्याओं पर काफी प्रत्यक्ष गणितीय गणना करता है। आप और क्या उम्मीद कर रहे थे?

— aditsu

2

पायथन 2 , 54 बाइट्स

i,j=input();k=0
while i<=j:k+=not"5"in`i`;i+=1
print k

इसे ऑनलाइन आज़माएं!

कम से कम पायथन का जवाब एक ही एल्गोरिदम का उपयोग नहीं करता है लेकिन थोड़ी देर के लूप के साथ लागू करने का एक अलग तरीका है और एक लंबो फ़ंक्शन नहीं है।

— ElPedro
स्रोत

यह एक कार्यक्रम है और फ़ंक्शन नहीं है और यह इसके बजाय उपयोग करता है। क्या अलग नहीं है? ठीक है, यह अभी भी बढ़े हुए इनपुट के अंदर एक स्ट्रिंग "5" की तलाश कर रहा है, सहमत है। क्या कोई बेहतर तरीका है?

— ElPedro

यह वास्तव में यही है और इसलिए यह स्थगित है। क्षमा करें, शायद मेरी टिप्पणी अलग होनी चाहिए।

— एलपीड्रो

समान एल्गोरिथ्म, लागू करने का अलग तरीका। आपकी टिप्पणियों से कोई समस्या नहीं है। क्या यह बेहतर शब्द है?

— एलपीड्रो

यह है, हाँ :) मैं टिप्पणी अनुभाग को साफ दिखने के लिए इन टिप्पणियों को हटा दूंगा।

— यति

1

जावा 7, 77 बाइट्स

यह केविन्स उत्तर का सुधार है , लेकिन चूंकि मेरे पास अभी तक टिप्पणी करने की प्रतिष्ठा नहीं है, इसलिए इस नए उत्तर को करना होगा।

तो मैंने क्या किया:

indexOfबयानों को बदलें contains(-1 बाइट)
सशर्त विवरण (-2 बाइट्स) के लिए लूप के बढ़ते हिस्से को ले जाएं

लूप के लिए ( 77 बाइट्स ):

int c(int a,int b){int r=1;for(;a++<b;)r+=(""+a).contains("5")?0:1;return r;}

पुनरावर्ती ( 79 बाइट्स ):

int d(int r,int a,int b){r+=(""+a).contains("5")?0:1;return a!=b?d(r,a+1,b):r;}

आउटपुट:

इसे यहाँ टेस्ट करें !

— टोबियास मिस्टर
स्रोत

PPCG में आपका स्वागत है! पहले से ही काफी अच्छी तरह से जवाब गोल्फ में अच्छा निष्कर्ष। मैं जावा के बारे में इतना नहीं जानता, लेकिन (""+a).contains("5")?0:1इसके द्वारा बदली नहीं जा सकती !(""+a).contains("5")?

— क्रिस्टोफ

1

@ क्रिस्टोफ उदास रूप से नहीं, क्योंकि जावा में एक बूलियन वास्तव में सिर्फ एक बूलियन है। तो एक टर्नरी ऑपरेशन ही एकमात्र रास्ता है।

— टोबियास मिस्टर

हम्म वह उदास। किस बारे में (""+a).contains("5")||r++?

— क्रिस्टोफ

1

@Christoph जो या तो काम नहीं करेगा, क्योंकि आपके पास अपने आप पर बूलियन अभिव्यक्ति नहीं हो सकती है। मैं इसे अन्य स्थानों (जैसे कि लूप डिक्लेरेशन) में काम करने की कोशिश कर रहा हूं, लेकिन ज्यादा सफलता के साथ नहीं। अच्छा विचार थो;)

— तोबियास मिस्टर

1

सी #, 67 बाइट्स

a=>b=>{int c=0;for(;a<=b;)c+=(a+++"").Contains("5")?0:1;return c;};

— TheLethalCoder
स्रोत

मैं उपयोग करने की उम्मीद कर रहा था, for(int c=0;...)लेकिन फिर इसे संकलित करने में विफल रहता है क्योंकि वापसी के दायरे से बाहर हैc

— TheLethalCoder

1

जावास्क्रिप्ट (ईएस 6), 58 56 49 बाइट्स

let f =

(s,e)=>{for(c=0;s<=e;)c+=!/5/.test(s++);return c}

console.log(f(1, 9));
console.log(f(4, 17));
console.log(f(-9, -1));

स्निपेट का विस्तार करें

Golfed करने के लिए 7 बाइट्स धन्यवाद ETHproductions ।

— हिस्टिरियन डोडोव
स्रोत

1

आप c+=!/5/.test(s++)कुछ बाइट्स बचाने के लिए उपयोग कर सकते हैं :-)

— ETHproductions

आपका बहुत बहुत धन्यवाद! मुझे अपने गोल्फ को हटाना था, हालाँकि। मुझे उन पर बहुत गर्व था। :(

— हिस्टीरियन डोडोव

मुझे लगता है कि आप करीने का उपयोग कर सकते हैं अर्थात `s => e =>`

— TheLethalCoder

शीर्ष जवाब वाक्य रचना currying उपयोग करता है। मैं अपना संपादन नहीं करूंगा क्योंकि यह लगभग समान हो जाएगा। हालांकि, यह इंगित करने के लिए धन्यवाद!

— हिस्टीरियन डोडोव

1

MATL , 10 बाइट्स

&:!V53-!As

इसे ऑनलाइन आज़माएं!

व्याख्या

        % Implicitly grab two input arguments
&:      % Create an array from [input1....input2]
!V      % Convert to a string where each number is it's own row
53-     % Subtract ASCII '5' from each character.
!A      % Detect which rows have no false values (no 5's). Returns a logical array
s       % Sum the logical array to get the # numbers without 5's
        % Implicitly display the result

— Suever
स्रोत

1

सी #, 77 बाइट्स

(n,m)=>{var g=0;for(var i=n;i<m+1;i++)g+=(i+"").Contains("5")?0:1;return g;};

अनाम लम्बा कॉल।

उपयोग n(पहले नंबर) और m(पिछले संख्या) इनपुट के रूप में है, तो जाँच करता है स्ट्रिंग रोकथाम के माध्यम से ( "".Contains(""))।

— devRicher
स्रोत

मैं एक नीच नहीं हूं, लेकिन ओपी द्वारा दी गई चुनौती के लिए मोडुलो 5 सही समाधान नहीं है। इसे 5अपनी संख्या में अंक वाले किसी भी चीज़ को बाहर करना चाहिए , इसलिए 10(जो आपका उत्तर नहीं गिना जाएगा) को गिना जाना चाहिए।

— केविन क्रूज़सेन

@ केविनक्रूजसेन फिक्स्ड।

— devRicher

यह संकलित नहीं किया gजाना चाहिए जैसा कि तब बताया गया है जब इसे नाम दिया गया हो, varइसलिए आपको इसकी आवश्यकता है var g="";और आप करीने का उपयोग कर सकते हैंn=>m=>

— TheLethalCoder

इसके अलावा, यह सूची नहीं गिनती

— TheLethalCoder

1

@KevinCruijssen आपके संपादन के साथ यह अनिवार्य रूप से मेरा उत्तर है ...

— TheLethalCoder

1

दरअसल , 13 बाइट्स

u@x`$'5íuY`░l

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

u@x`$'5íuY`░l
u@x            range(a, b+1)
   `$'5íuY`░   take where:
    $            string representation
     '5íuY       does not contain "5"
            l  length

— मेगो
स्रोत

मुझे पाँच मत दो!

जावास्क्रिप्ट (ईएस 6), 36 33 बाइट्स

प्रारूपित और टिप्पणी की गई

परीक्षण के मामलों

जेली , 8 7 बाइट्स

कैसे?

बैश + जीआरपी, 17 बाइट्स

2sable , 6 5 बाइट्स

पायथन 2, 59 55 52 51 47 43 42 बाइट्स

43 बाइट्स में अन्य प्रयास

बैश / यूनिक्स उपयोगिताओं, 21 बाइट्स

05AB1E , 8 7 6 बाइट्स

अजगर, ९ 9 बाइट्स

पर्ल 6 , 23 बाइट्स

यह काम किस प्रकार करता है

हास्केल , 39 बाइट्स

आर, 33 बाइट्स

ऑक्टेव , 36 बाइट्स

ग्रोवी, 47 45 43 40 बाइट्स

PHP 7.1, 57 55 बाइट्स

मैथेमेटिका, 46 44 42 बाइट्स

रूबी, 36 35 बाइट्स

जावा 7, 80 78 बाइट्स

पॉवरशेल, 42 41 बाइट्स

पायथन 2, 61 56 बाइट्स

स्विफ्ट 52 बाइट्स

बैच, 95 बाइट्स

PHP, 56 बाइट्स

व्याख्या

सीजेम "आसान शुद्ध गणित समाधान", 60

पायथन 2 , 54 बाइट्स

जावा 7, 77 बाइट्स

सी #, 67 बाइट्स

जावास्क्रिप्ट (ईएस 6), 58 56 49 बाइट्स

MATL , 10 बाइट्स

सी #, 77 बाइट्स

दरअसल , 13 बाइट्स