44

कई फोंट में (विशेषकर कॉन्सोल फॉन्ट में ), 10 में से 5 दशमलव अंकों में "छेद" होते हैं। हम इन पवित्र अंकों को कहेंगे:

5 अपवित्र अंक इस प्रकार हैं:

पूर्णांक को इस प्रकार "पवित्र" के रूप में वर्गीकृत किया जा सकता है यदि इसमें केवल पवित्र अंक हों, और अन्यथा "अपवित्र"। क्योंकि -अपवित्र है, कोई भी नकारात्मक पूर्णांक पवित्र नहीं हो सकता है।

पवित्र पूर्णांक को आगे वर्गीकृत किया जा सकता है कि उनके पास कितने छेद हैं। उदाहरण के लिए, निम्नलिखित अंकों में 1 की पवित्रता है:

और इन अंकों में 2 की पवित्रता है:

हम कहते हैं कि पूर्णांक की समग्रता इसके अंकों की पवित्रता का योग है। इसलिए, 804 की पवित्रता 99होगी , और 2 की पवित्रता होगी।

चुनौती

दो पूर्णांकों को देखते हुए n > 0और h > 0, उत्पादन nवें पवित्र पूर्णांक जिसका पवित्रता कम से कम है h। आप मान सकते हैं कि इनपुट और आउटपुट आपकी भाषा में अधिकतम प्रतिनिधित्व योग्य पूर्णांक से अधिक नहीं होंगे 2^64 - 1, या जो भी कम हो।

यहाँ h >= 1संदर्भ के लिए पवित्रता के साथ पहले 25 पवित्र पूर्णांकों की सूची दी गई है :

0, 4, 6, 8, 9, 40, 44, 46, 48, 49, 60, 64, 66, 68, 69, 80, 84, 86, 88, 89, 90, 94, 96, 98, 99

पवित्रता के साथ पहले 25 पवित्र पूर्णांक h >= 2हैं:

0, 8, 40, 44, 46, 48, 49, 60, 64, 66, 68, 69, 80, 84, 86, 88, 89, 90, 94, 96, 98, 99, 400, 404, 406

code-golf number sequence

— मेगो
स्रोत

पायथ, 32 बाइट्स

e.fg*g.{`46890J`Z++lJ/J`8/J`0QE0

व्याख्या

                                 - autoassign Q = eval(input())
 .f                           E0 -  first eval(input()) terms of func V starting Z=0

     g.{`46890J`Z                -    Are all the digits in Z in "46890"?
               `Z                -      str(Z)
              J                  -     autoassign J = ^
     g                           -    is_subset(V,^)
      .{`46890                   -     set("46890")

    *                            -   ^*V (Only return non-zero if only contains holy numbers)

                 ++lJ/J`8/J`0    -    Get the holiness of the number
                   lJ            -      len(J)
                  +              -     ^+V
                     /J`8        -      J.count("8") 
                 +               -    ^+V
                         /J`0    -     J.count("0")
   g                         Q   -  ^>=Q (Is the holiness great enough)
e                                - ^[-1]

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

फॉर्म में इनपुट लेता है h \n n

— नीला
स्रोत

12

रूबी, 109 105 95 82 बाइट्स

->n,h{(?0..?9*99).select{|x|x.count('469')+2*x.count('80')>=h&&/[12357]/!~x}[n-1]}

यह भयानक है "0 से 99999999999 तक की गणना ..." दृष्टिकोण जो आलसी समकक्ष की तुलना में 13 बाइट्स का होता है। हालांकि, ब्रह्मांड की गर्मी से पहले इस संस्करण के खत्म होने की संभावना नहीं है। वर्थ 13 बाइट्स, वैसे भी _ \ _ (_) _ /,

आप इसे छोटे मानों के लिए बदल ?9*99सकते हैं, कह सकते हैं, कह सकते हैं '99999'।

यहां पुराना संस्करण (95 बाइट्स, आलसी मूल्यांकन के साथ, जो लगभग-कभी-कभी के बजाय निकटता से चलता है):

->n,h{(?0..?9*99).lazy.select{|x|x.count('469')+2*x.count('80')>=h&&/[12357]/!~x}.first(n)[-1]}

->n,h{
(?0..?9*99)  # range '0' (string) to '9' repeated 99 times, way more than 2**64
.lazy        # make the range lazy, so we can call `select' on it
.select{|x|  # choose only elements such that...
 x.count('469')+2*x.count('80')  # naive holiness calculation
 >=h         # is at least h
 &&/[12357]/!~x                  # naive "is holy" calculation
}
.first(n)    # take the first n elements that satisfy the condition
[-1]         # choose the last one from this array
}

— Doorknob
स्रोत

— गोटी

takeइसके बजाय क्यों नहीं first?

— नहीं कि चार्ल्स

@ नॉचचार्ल्स takeरिटर्न Lazy, जिसे अनुक्रमित नहीं किया जा सकता है।

— दरवाज़े

6

अजगर 3, 103

lambda n,h,l='4698080':[y for y in range(2**64-1)if(sum(l.count(x)-(x not in l)for x in str(y))>=h)][n]

यहां एक समाधान है जो अधिक मेमोरी कुशल दृष्टिकोण का उपयोग करता है, लेकिन यदि आप इसे परीक्षण करना चाहते हैं तो एक ही एल्गोरिदम का उपयोग करता है।

l='4689080'
def f(n,h):
 c=i=0
 while i<n:
  if sum(l.count(x)-(x not in l)for x in str(c))>=h:u=c;i+=1
  c+=1
 return u

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

assert f(3, 1) == 6
assert f(4, 2) == 44

— मॉर्गन थ्राप्प
स्रोत

@ मेगो कूल। यह स्मृति की एक स्थिर राशि का उपयोग करने के लिए लगता है, इसलिए यह स्मृति से बाहर चलने के खतरे में नहीं है। मुझे पहले से ही यकीन नहीं था कि यह मेरी मशीन पर आधे घंटे से चल रहा है।

— मॉर्गन थ्रैप

यह वास्तव में समय की गणना करने के लिए एक अच्छा हिस्सा लेता है 2**64-1; देख stackoverflow.com/questions/34113609/...

— Mego

@ ओह ओह, मैंने उस बारे में सोचा भी नहीं था। हाँ, जब मैं प्रीकम्प्यूटेड कंटीन्यू को कोड में डालता हूं, तो यह थोड़ी सी रैम से चबाने लगता है।

— मॉर्गन थ्रैप

6

पावरशेल, 163 150 141 101 98 96 बाइट्स

param($n,$h)for(--$i;$n){if(++$i-notmatch"[12357]"-and($i-replace"8|0",11).Length-ge$h){$n--}}$i

इनपुट लेता है, फिर $nशून्य होने तक लूप करता है। हम पहले से $i=-1एक पूर्व-प्रसंस्करण चाल का उपयोग करके सेटिंग करते हैं, जो काम करता है $i, क्योंकि पहले घोषित नहीं किया गया है, है $null। फिर हम --इसे, जो PowerShell को इसका मूल्यांकन करने का कारण बनता है $i = $null - 1, जो है $i=-1।

प्रत्येक लूप में हम वृद्धि करते हैं $iऔर फिर एक लंबा ifविवरण निष्पादित करते हैं। सशर्त का पहला भाग सत्यापित करता है कि ऑपरेटर का उपयोग करके , अपवित्र संख्या को फ़िल्टर करने के लिए $iइसमें कोई भी नहीं है ।12357-notmatch

सशर्त का दूसरा भाग छेदों की मात्रा की जांच करता है $i। यह -replaceप्रत्येक 8या के 0साथ बदलने के लिए ऑपरेटर का उपयोग करता है 11, और फिर तुलना करता है कि लंबाई> = है $h। हमें अपवित्र संख्या को अलग करने के बारे में चिंता करने की आवश्यकता नहीं है, क्योंकि यह सशर्त के पहले भाग में है, और एकल-होली की संख्या 1वैसे भी एक ही लंबाई है, इसलिए हमें उन्हें बदलने की आवश्यकता नहीं है, या तो।

यदि वह अभी भी सत्य है, तो हम वृद्धि करते हैं $n(इसका मतलब है कि हमें एक और संख्या मिली है जो इनपुट आवश्यकताओं को पूरा करती है)। इस प्रकार जब forस्थिति की जाँच करने के लिए पुनर्गणना की जाती है यदि $nशून्य है, तो इसका मतलब है कि हमने एनटीटी पाया है , इसलिए हम forलूप से बाहर निकलते हैं , आउटपुट $iऔर समाप्त करते हैं।

_{संपादित करें - स्ट्रिंग के बजाय एक सरणी का उपयोग करके 13 बाइट्स को बचाया $lऔर कैसे $nघटाया / चेक किया गया है}
_{संपादित करें 2 संपादित करें - सशर्त $nमें जांच करके forऔर लूप के बाहर आउटपुट को स्थानांतरित करके अतिरिक्त 9 बाइट्स को}
_{बचाया 3 संपादित करें - एक बचाया मौलिक रूप से बदलते हुए 40 बाइट्स द्वारा हम छेदों की गणना कैसे करते हैं}
_{4 संपादित करें - ++सशर्त}₅_{के पहले भाग पर एक पूर्व-वृद्धि होने}_के_लिए_{अतिरिक्त 3 बाइट्स}
_{बचाकर संपादित करें - TessellatingHckler के लिए धन्यवाद 2 अन्य बाइट्स को बचाया}

— AdmBorkBork
स्रोत

साफ। को बदलकर बाइट्स की एक और जोड़ी सहेजें for(--$i;$n)और -replace"8|0"?

— TessellatingHeckler

@TessellatingHeckler हाँ, धन्यवाद। वह $i=-1मुझे बिल्कुल बोनर्स चला रहा था। मैं अभी भी एक तरह से काम करने की कोशिश कर रहा हूं, इसलिए हमें $iपहले स्थान पर इनिशियलाइज़ करने की ज़रूरत नहीं है , लेकिन मैंने अब तक जिन चीज़ों की कोशिश की है, वे अधिक लंबी हैं (और, अब इसे दिया गया है, संभवतः अभी और अधिक होने की संभावना है)।

— AdmBorkBork

5

CJam, 36 34 बाइट्स

2 बाइट बचाने के लिए aditsu का धन्यवाद।

Wq~:X;{{)_Ab39643Zbf=_:*g*1bX<}g}*

इसका परीक्षण यहां करें।

— मार्टिन एंडर
स्रोत

4

बैश + जीएनयू उपयोगिताओं, 67

20 बाइट्स @TobySpeight की बदौलत बच गए!

seq 0 NaN|sed -r "h;/[12357]/d;s/8|0/&&/g;/^.{$1}/!d;x"|sed $2!d\;q

seqबस 0ऊपर से शुरू होने वाले पूर्णांक उत्पन्न करता है
sed -r:
- h होल्ड स्थान पर इनपुट लाइन की प्रतिलिपि बनाएँ
- /12357/d अपवित्र संख्या हटाएं
- s/8|0/&&/gदो बार खुद से दोगुने पवित्र अंकों को बदलें। इस प्रकार विलक्षण पवित्र अंकों को एक बार गिना जाता है और दोगुने पवित्र अंकों को दो बार गिना जाता है।
- /^.{$1}/!dयदि कम से कम $1छेद मिलान नहीं कर रहे हैं , तो हटाएं और अगली पंक्ति पर जारी रखें
- x पैटर्न स्पेस में मूल संख्या वापस लाएं
- छापना
sed
- $2!dलाइन से पहले किसी भी लाइन पर $2, हटाएं और अगली पंक्ति पर जारी रखें
- qलाइन में होना चाहिए $2- छोड़ दिया (और निहितार्थ प्रिंट)

Ideone।

— डिजिटल आघात
स्रोत

1

दाढ़ी 9 sed -r "h;/[12357]/d;s/8|0/&&/g;/^.{$1}/!d;x":। और दूसरा 4 sed $2!d\;q:। और अगर आप एक ऊपरी सिर्फ 4611686018427387904 के लिए बाध्य के साथ हैं खुश हैं, तो आप दूर के साथ मिल सकता हैseq 0 $[1<<62]

— टोबी स्पीट

1

ऊह, मेरे seqको स्वीकार करता है NaNमैं अब है: एक मूल्य के रूप में seq 0 NaN|sed -r "h;/[12357]/d;s/8|0/&&/g;/^.{$1}/!d;x"|sed $2!d\;q, स्कोरिंग 67.

— टोबी स्पीट

@TobySpeight वाह, यह अद्भुत है!

— डिजिटल ट्रॉमा

: @TobySpeight: पहले एक \ लापता, नहीं तो!-sh: !d\: event not found

— ओलिवर Dulac

1

@OlivierDulac ` before ! `एक स्क्रिप्ट में जरूरत नहीं है । इसे केवल कमांड-लाइन पर सीधे चलाने पर इसकी आवश्यकता होती है, जो मुझे नहीं लगता कि एक आवश्यकता है।

— डिजिटल ट्रामा

3

MATL , 39 40 बाइट्स

x~q`QtV4688900V!=stA*s2G<?T}N1G=?F1$}tT

Inpunt हैं nऔर hउसी क्रम में।

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

हमें दो संख्याओं पर नज़र रखने की आवश्यकता है: वर्तमान उम्मीदवार संख्या (इसकी पवित्रता की जांच करने के लिए) और उन संख्याओं की मात्रा जो पर्याप्त पवित्र हैं। पहला शीर्ष ओडी स्टैक है, और बाद वाले को स्टैक में तत्वों की संख्या के रूप में रखा गया है। जब कार्यक्रम पूरा हो जाता है, केवल शीर्ष को प्रदर्शित करने की आवश्यकता होती है।

x~q          % implicitly take two inputs. Delete one and transform the other into -1
`            % do...while loop
  Q          %   add 1 to current candidate number
  tV         %   duplicate and convert to string
  4688900V!  %   column char array of '4', '6' etc. Note '8' and '0' are repeated 
  =          %   compare all combinations. Gives 2D array
  s          %   sum of each column: holiness of each digit of candidate number
  tA*        %   are all digits holy? Multiply by that
  s          %   sum of holiness of all digits, provided they are all holy
  2G<        %   is that less than second input (h)?
  ?          %   if so: current candidate not valid. We'll try the next
    T        %     push true to be used as loop condition: next iteration
  }          %   else: current candidate valid
    N1G=     %     does stack size equal first input (n)?
    ?        %     if so: we're done
      F1$    %       push false to exit loop. Spec 1 input, to display only top
    }        %     else: make a copy of this number
      tT     %       duplicate number. Push true to continue with next iteration
             %     implicit end if 
             %   implicit end if 
             % implicit end do...while. If top of stack is truthy: next iteration
             % implicit display

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

3

आर, 109 107 बाइट्स

f=function(n,h){m=-1;while(n){m=m+1;if(!grepl("[12357]",m))if(nchar(gsub("([08])","\\1\\1",m))>=h)n=n-1};m}

नई लाइनों और इंडेंटेशन के साथ:

f=function(n,h){
    m=-1
    while(n){
        m=m+1
        if(!grepl("[12357]",m))
            if(nchar(gsub("([08])","\\1\\1",m))>=h)
                n=n-1
    }
    m
}

उपयोग:

> f(4,3)
[1] 68
> f(4,2)
[1] 44
> f(6,2)
[1] 48
> f(10,2)
[1] 66

— plannapus
स्रोत

3

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

f=(n,h,r=[],i=0)=>r.length<n?f(n,h,/[12357]/.test(i)|[...''+i].reduce((t,c)=>t+1+!(c%8),0)<h?r:[...r,i],i+1):r

टेल पुनरावर्ती समाधान जो एक सरणी में पवित्र संख्याओं को जमा करता है।

रुचि से बाहर, संख्या को पूर्ण होने की आवश्यकता नहीं है (!) पवित्रता पवित्रता को अधिक अजीब बनाता है, लेकिन यह अभी भी कुल मिलाकर 10% बचाता है:

f=(n,h,r=[],i=0)=>r.length<n?f(n,h,[...''+i].reduce((t,c)=>+"2000101021"[c]+t,0)<h?r:[...r,i],i+1):r

— नील
स्रोत

@ edc65 वूप्स, मैंने एक बिंदु पर iऔर rमापदंडों की अदला-बदली की , और परिवर्तन को सही ढंग से संपादित करने में विफल रहा।

— नील

1

जावास्क्रिप्ट ईएस 6, 191 बाइट्स

यकीन है, यह सबसे कुशल तरीका नहीं है। लेकिन आप मुझे जानते हैं, मुझे जनरेटर <3 से प्यार है

H=(x,o=x+"")=>(F=/^[46890]+$/).test(o)&&[...o].map(y=>d+=(F.test(y)+/8|0/.test(y)),d=0)&&d;(n,h)=>(a=(function*(h){q=0;while(1){if(H(q)>=h)yield q;q++}})(h),eval("a.next().value;".repeat(n)))

थोड़ा अपराजित:

H = (x, o = x + "") => (F = /^[46890]+$/).test(o) && [...o].map(y => d += (F.test(y) + /8|0/.test(y)), d = 0) && d;
Q = (n, h) => (a = (function*(h) {
    q = 0;
    while (1) {
        if (H(q) >= h) yield q;
        q++
    }
})(h), eval("a.next().value;".repeat(n)))

— कोनोर ओ ब्रायन
स्रोत

1

सी # 6, 168 बाइट्स

(n,h)=>{for(int i=0;i<=int.MaxValue;i++){string d=$"{i}";if(d.Any(y=>"12357".Contains(y)))continue;n-=d.Sum(y=>y=='0'||y=='8'?2:1)>=h?1:0;if(n==0)return i;}return -1;}

यह प्रकार फंक <int, int, int> का लैम्ब्डा एक्सप्रेशन है। यह कोड न्यूनतम आकार (प्रदर्शन नहीं) के लिए ओटिमाइज़ किया गया है।

नीचे, विधि घोषणा में सुशोभित कोड (अधिक प्रदर्शन के साथ):

    int GetHolyNumber(int n, int h)
    {
        for (int i = 0; i <= int.MaxValue; i++)
        {
            string d = $"{i}";
            char[] cs = "12357".ToArray();
            if (d.Any(y => cs.Contains(y))) continue;

            n -= d.Sum(y => y == '0' || y == '8' ? 2 : 1) >= h ? 1 : 0;

            if (n == 0)
                return i;
        }
        return -1;
    }

— पाउलो सेसर बी सिनकोस
स्रोत

हाय बोबसन, माफ करना अगर मैंने गलत समझा, लेकिन उन दोषों का पता नहीं लगाऊँ जो आपने मेरे कोड में बताए थे? यह आवश्यक तत्व को वापस कर देता है, और केवल वह, और शून्य यदि यह मान्य है, तो यह मानते हुए कि इनपुट n = 1 और h <= 2. है, अगर मुझे चुनौती समझ में आती है, तो केवल इस एक तत्व को वापस करना चाहिए और सभी को नहीं। । लेकिन मैंने मुझे गलत समझा और अंग्रेजी में हार गया: डी

— थैंक्स

नहीं, आप पूरी तरह से सही हैं। मुझे सूचियों के संदर्भ से गुमराह किया गया था, और इस तथ्य को याद किया कि यह सिर्फ एनटी अंक के लिए पूछ रहा था । लगे रहो!

— बोबसन

1

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

(n,h)=>eval("for(i=0;[...i+''].map(d=>r-=~!(d%8),r=0),/[12357]/.test(i)|r<h||--n;)++i")

कम गोल्फ वाला

f=(n,h)=>{
  for (i=0;
    // this is the loop condition
    /[12357]/.test(i) // go on if not holy
    ||([...i+''].map(d=>r-=~!(d%8),r=0),r<h) // go on if not holy enough
    ||--n; // ok, found one! go on if we need to find more
  )
    ++i; // loop body - using eval this is the returned value
  return i; // not using eval, an explicit return is needed
}

परीक्षा

f=(n,h)=>eval("for(i=0;[...i+''].map(d=>r-=~!(d%8),r=0),/[12357]/.test(i)|r<h||--n;)++i")

function test() {
  var a,b
  [a,b]=I.value.match(/\d+/g)
  R.textContent = f(a,b)
}

test()

N, H: <input id=I value="25 2" oninput="test()"> >>
<span id=R></span>

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

— edc65
स्रोत

1

लूआ, 169 बाइट्स

function a(n,h)H=0N=0I=-1while N<n do I=I+'1'H=0 if not I:find('[12357]') then _,b=I:gsub('[469]',1)_,c=I:gsub('[08]',1)H=b+2*c end N=H>=h and N+1 or N end print(I) end

Ungolfed:

function a(n,h) -- nth term, holiness
    H=0N=0I=-1 -- Really ugly, but hey, it works. Set up 3 vars
    while N<n do -- While nth term is lower than desired term
        I=''..I+1 -- Convert number to string (can't coerce since it will become a float)
        if not I:find('[12357]') then -- If the number doesn't have those numbers
            _,b=I:gsub('[469]',1) -- _ is the new string, b is the number of changes
            _,c=I:gsub('[08]',1) -- Same as above. Use 1 to replace to save chars
            H=b+2*c -- Increase holiness appropriately
        end
        N=H>=h and N+1 or N -- If current holiness >= desired holiness, increment N
    end 
    print(I) -- Once the loop ends, print the current term
end

— DavisDude
स्रोत

1

लुआ, 155 141 140 बाइट्स

कमांड-लाइन तर्क द्वारा दोनों इनपुट लेता है (पहला तर्क n है, फिर h)

संपादित करें: @DavisDude का धन्यवाद, जिन्होंने मुझे 14 बाइट शेविंग करने में मदद की और याद दिलाया कि मुझे सभी पवित्र संख्याओं को n तक प्रिंट नहीं करना था, लेकिन केवल nth।

a={}x=0while(#a<arg[1])do b,c=(x..""):gsub("[08]","")e,d=b:gsub("[469]","")a[#a+1],x=c*2+d>=arg[2]and #e<1 and x or nil,x+1 end print(a[#a])

अपुष्ट और स्पष्टीकरण

x,a=0,{}                      -- initialise a counter, and the array which 
                              -- contains the holy numbers found
while(#a<arg[1])              -- iterate while we found less holy numbers than n
do
  b,c=(x..""):gsub("[08]","") -- replace [08] by "", b=the new string
                              -- c=the number of subsitution
  e,d=b:gsub("[469]","")      -- same thing for [469]
  a[#a+1]=c*2+d>=arg[2]       -- insert the number into a if:nb[08]*2+nb[469]>h
             and #e<1         -- and e is empty (no unholy numbers)
             and x or nil
      x=x+1                   -- increment x
end
print(a[#a])                  -- print the last element of a

— Katenkyo
स्रोत

आप कुछ print(a[arg[1]])

— करतब

@DavisDude मैं गूंगा था, जब मैंने यह लिखा था, तो मुझे हालांकि अपवित्र संख्या की पूरी सूची को प्रिंट करना था n। दरअसल, print(a[#a])और भी अधिक बाइट बचाता है। टिप्पणी के लिए धन्यवाद !

— काटेंको

आप लिख रहे हैं। किसी कारण से जो मेरे साथ भी नहीं हुआ।

— डेविसड्यूड

आप के x=0a={}बजाय लिखने के द्वारा एक चार ले जा सकते हैं x,a=0,{}।

— लीक नून

1

@ केनीलाऊ वास्तव में, क्योंकि आप 0aएक हेक्साडेसिमल संख्या के रूप में व्याख्या की जाएगी, लेकिन मैं a={}x=0whileएक समस्या के बिना कर सकते हैं :)

— Katenkyo

0

Oracle SQL 11.2, 229 बाइट्स

WITH v(c,p,i,j,n)AS(SELECT 0,-1,0,0,0 FROM DUAL UNION ALL SELECT c+1,c,REGEXP_COUNT(c||'','[4,6,9]'),REGEXP_COUNT(c,'[8,0]'),n+DECODE(LENGTH(p),i+j,DECODE(SIGN(i+j*2-:h),-1,0,1),0)FROM v WHERE p<c AND n<:n)SELECT MAX(p)-1 FROM v;

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

:h -> required min holy value
:n -> nth number 

curv   -> current number
precv  -> previous number
prech1 -> number of holy 1 letters in previous number 
prech2 -> number of holy 2 letters in previous number
n      -> how many numbers with at least the required holy value 

WITH v(curv,precv,prech1,prech2,n)AS 
(
  SELECT 0 curv, -1 precv, 0 prech1, 0 prech2, 0 n FROM DUAL     -- Start with 0
  UNION ALL
  SELECT curv+1,   -- Next number
         curv,     -- Current Number 
         REGEXP_COUNT(curv||'','[4,6,9]'),  -- number of holy 1 letters
         REGEXP_COUNT(curv,'[8,0]'),        -- number of holy 2 letters
         n+DECODE(LENGTH(precv),prech1+prech2,DECODE(SIGN(prech1+prech2*2-:h),-1,0,1),0) -- Is the previous number holy enough ?
  FROM   v 
  WHERE  precv<curv   -- Needed to trick oracle cycle detection 
         AND n<:n     -- Until clause
)
SELECT MAX(precv)-1 FROM v

— Jeto
स्रोत

0

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

f=lambda n,h,k=0,s="0046889":-0**n or-~f(n-(sum(map(s.count,`k`))>=h<set(str(k))<=set(s)),h,k+1)

kद्वारा पवित्रता की स्थिति की जाँच की जाती है

sum(map(s.count,`k`))>=h, जो प्रत्येक वर्ण के लिए मायने रखता है s="0046889", जहां 0और 8दो बार दिखाई देता है , द्वारा संक्षेप में छेद की संख्या को गिना जाता है ।
set(str(k))<=set(s)), जो जांचता है कि संख्या सभी पवित्र हैं। लंबे समय तक strप्रत्यय से बचने के लिए बैकटिक्स के बजाय उपयोग किया जाता है L।

ये पायथन 2 तथ्य का उपयोग करके एकल समानता में जंजीर हैं कि संख्या सेट से छोटी होती है।

फ़ंक्शन को संख्याओं की गणना करने के लिए पुनरावर्ती रूप से परिभाषित किया जाता है k, nहर बार काउंटर को कम करके जब तक कि यह हिट नहीं हो जाता है 0। इसके बाद यह kउस ट्रिगर को वापस कर सकता है , लेकिन 1हर बार जोड़कर गिनती को फिर से रखना कम होता है , हालांकि एक ऑफ-बाय -1को फिक्स करने के लिए आधार गणना की आवश्यकता होती है ।

— XNOR
स्रोत

0

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

cएक अंक vकी पवित्रता है, एक संख्या की पवित्रता, n!hबाकी है।

c=([2,0,0,0,1,0,1,0,2,1]!!)
v n|n>9=c(mod n 10)+v(div n 10)|1<2=c n
n!h=[i|i<-[0..],v i<=h]!!n

नोट: मुझे लगता है कि पात्रों के बिना यह एकमात्र उत्तर है 4,6,8।

— माइकल क्लेन
स्रोत

0

तीव्र

func f(n: Int, h: Int) {
    var m = 0
    let a = [1,2,3,5,7]
    for j in 0..<Int.max {
        var c = 0
        for i in (j.description.characters.map{(String($0) as NSString).integerValue}) {
            c += (a.contains(i)) ? 0 : (i == 8 || i == 0) ? 2 :1
        }
        if c >= h { m += 1; if m >= n {print(j); break}}
    }
}

— सुमित
स्रोत

पवित्र नंबर