পবিত্র নাম্বার

44

অনেকগুলি ফন্টে (বিশেষত কনসোলস ফন্টে ) 10 দশমিক অঙ্কের মধ্যে 5 টিতে "গর্ত" থাকে। আমরা এই পবিত্র সংখ্যাগুলি কল করব:

46890

5 টি অপরিচ্ছন্ন অঙ্কগুলি হ'ল:

12357

কোনও পূর্ণসংখ্যাটিকে "পবিত্র" হিসাবে শ্রেণীবদ্ধ করা যেতে পারে যদি এতে কেবলমাত্র পবিত্র অঙ্ক থাকে এবং অন্যথায় "অপরিষ্কার" থাকে। কারণ -অপরিষ্কার, কোনও নেতিবাচক পূর্ণসংখ্যা পবিত্র হতে পারে না।

পবিত্র পূর্ণসংখ্যাগুলি আরও কতগুলি গর্ত রয়েছে তার ভিত্তিতে আরও শ্রেণিবদ্ধ করা যেতে পারে। উদাহরণস্বরূপ, নিম্নলিখিত সংখ্যাগুলির 1 এর পবিত্রতা রয়েছে:

469

এবং এই সংখ্যার 2 এর পবিত্রতা রয়েছে:

80

আমরা বলি যে একটি পূর্ণসংখ্যার সামগ্রিক পবিত্রতা হল এর অঙ্কগুলির পবিত্রতার যোগফল। সুতরাং, 804 এর 99পবিত্রতা হবে এবং 2 এর পবিত্রতা থাকবে।

চ্যালেঞ্জ

দুটি পূর্ণসংখ্যা দেওয়া n > 0এবং h > 0, nপবিত্রতম পূর্ণসংখ্যার আউটপুট নিন যার পবিত্রতা কমপক্ষে h। আপনি ধরে নিতে পারেন যে ইনপুট এবং আউটপুটগুলি আপনার ভাষার সর্বাধিক উপস্থাপনযোগ্য পূর্ণসংখ্যার চেয়ে বড় হবে না বা 2^64 - 1যে কোনওটি কম।

পবিত্রতার সাথে প্রথম 25 পবিত্র পূর্ণসংখ্যার একটি তালিকা এখানে h >= 1রেফারেন্সের জন্য রয়েছে:

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 
— ঐ মেগো
সূত্র
সম্পর্কিত - 1 2
— মেগো
26
0অবশেষে কনসোলাসের উইকিপিডিয়া লিঙ্কটিতে ক্লিক করার আগে আমি " ত্রিশ সেকেন্ডের মতো এখানে বসে বসে" এই চিন্তা করে বসে ছিলাম
— আন্ডারগ্রাউন্ডোমোরিয়েল
পঞ্চম 1-পবিত্র সংখ্যা 9 বা 40?
— কনর ও'ব্রায়েন
3
এটি কি কেবল কাকতালীয় যে 8 তম 8 + -শক্তিটি 8888? (হ্যাঁ, এটি সম্ভবত, তবে তা যাইহোক আমাকে আনন্দিত ...)
— টবি স্পাইট
5
আসলে, যেহেতু আপনি সংখ্যার আগে 0 এর যে কোনও সংখ্যক নেতৃস্থানীয় থাকতে পারেন, তাই কেউ 0 কে অসীম পবিত্র বলে প্রমাণ করতে পারে। যদিও apparent দৃশ্যত ঠিক পবিত্র। কিন্তু আশ্চর্যের 666 এমনকি নাক উঁচু গোষ্ঠীগুলোর হচ্ছে ...
— Darrel হফম্যান

উত্তর:

6

পাইথ, 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
}
— ডোরকনব
সূত্র
অলস মূল্যায়ন ভালোবাসি :)
— এমিগানা
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/...
— ঐ মেগো
@ মেগো ওহ, আমি এটি সম্পর্কে ভাবিনি। হ্যাঁ, আমি যখন কোডটিতে প্রম্পম্পিউটেড ধ্রুবকটি রাখি তখন এটি কিছুটা র‌্যামের মাধ্যমে চিবানো শুরু করে।
— মরগান থ্রাপ
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 ++পরিবর্তন করুন - শর্তসাপেক্ষ সম্পাদনা 5 এর প্রথম অংশে প্রি-ইনক্রিমেন্ট হিসাবে সরানো একটি অতিরিক্ত 3 বাইট
সংরক্ষণ করা - টেসেল্ল্যাটিংহেকলারের ধন্যবাদ আরও 2 বাইট সংরক্ষণ করা

— AdmBorkBork
সূত্র
ঝরঝরে। for(--$i;$n)এবং আরও পরিবর্তন করে আরও কয়েকটা বাইট সংরক্ষণ করবেন -replace"8|0"?
— টেসেল্ল্যাটিংহেকলার
@ টেসেল্লাটিংহেকলার হ্যাঁ, ধন্যবাদ এটি $i=-1আমাকে একেবারে kersণদাতাদের চালাচ্ছিল। আমি এখনও একটি উপায় কাজ করার চেষ্টা করছি যাতে $iপ্রথমে আমাদের আরম্ভ করতে হবে না , তবে এখন পর্যন্ত যে জিনিসগুলি চেষ্টা করেছি তা দীর্ঘতর (এবং, এখন এটি দেওয়া হয়েছে সম্ভবত দীর্ঘতর হবে)।
— অ্যাডমবর্কবার্ক
4

বাশ + জিএনইউ ইউটিলিটিস, 67

  • 20 বাইট সংরক্ষিত হয়েছে @ টবিস্পাইটের জন্য ধন্যবাদ!
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\;q67 স্কোর করেছি
— টবি স্পাইট
@ টবিস্পাইট ওয়াহ আশ্চর্যজনক!
— ডিজিটাল ট্রমা
@ টবিস্পাইট: এর আগে একটি missing হারিয়েছে, অন্যথায়:-sh: !d\: event not found
— অলিভিয়ার ডুলাক
1
@ অলিভিয়ারডুলাক ` before ! কোনও স্ক্রিপ্টে প্রয়োজন হয় না । এটি কেবল কমান্ড-লাইনে সরাসরি চালানোর সময় প্রয়োজন, যা আমি মনে করি না এটি একটি প্রয়োজনীয়তা।
— ডিজিটাল ট্রমা
3

এমএটিএল , 39 40 বাইট

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

ইনপুটগুলি 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

জাভাস্ক্রিপ্ট (ES6), 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

জাভাস্ক্রিপ্ট ES6, 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;}

এটি Func <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;
    }
— পাওলো সিজার বি। সিনকোস
সূত্র
হাই ববসন, দুঃখিত যদি আমি ভুল বুঝি তবে আপনি আমার কোডটিতে যে দোষগুলি চিহ্নিত করেছেন তা সনাক্ত করতে পারছেন না? এটি প্রয়োজনীয় নবম উপাদানটি প্রদান করে, এবং কেবলমাত্র তিনি এবং শূন্য যদি এটি বৈধ হয় তবে ধরে নেওয়া হয় যে ইনপুটগুলি এন = 1 এবং এইচ <= ২ I । তবে আমি আমাকে ভুল বুঝেছি এবং ইংরেজিতে
— হেরেছি
না, আপনি পুরোপুরি ঠিক বলেছেন। আমি রেফারেন্স-ফর-রেফারেন্স দ্বারা বিভ্রান্ত হয়েছিলাম এবং এটি ঠিক নবম সংখ্যাটি চেয়েছিল তা মিস করছি। বহন!
— ববসন
1

জাভাস্ক্রিপ্ট (ES6), 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)

সম্পাদনা: @ ডেভিডডুডকে ধন্যবাদ, যিনি আমাকে 14 বাইট ছাঁটাই করতে সাহায্য করেছিলেন এবং আমাকে মনে করিয়ে দিয়েছিলেন যে আমাকে সমস্ত পবিত্র সংখ্যা এন পর্যন্ত প্রিন্ট করতে হয়নি, তবে কেবল নবমই।

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]])
— চরিত্রগুলি
@ ডেভিডডুড আমি বোবা ছিলাম, যখন আমি এটি লিখেছিলাম, যদিও আমাকে অপরিষ্কার সংখ্যার পুরো তালিকাটি মুদ্রণ করতে হয়েছিল n। আসলে, print(a[#a])আরও বেশি বাইট সংরক্ষণ করে। মন্তব্যের জন্য ধন্যবাদ !
— কাটেনকিও
আপনি লিখছেন। কিছু কারণে যা আমার কাছে ঘটেনি।
— ডেভিসডুড
x=0a={}পরিবর্তে লিখে আপনি একটি চর নিতে পারেন x,a=0,{}।
— লিকি নুন
1
@ কেনেনি লাউ আসলে আপনি 0aহেক্সাডেসিমাল সংখ্যা হিসাবে ব্যাখ্যা করা যাবে না, তবে আমি a={}x=0whileকোনও সমস্যা ছাড়াই করতে পারি :)
— ক্যাটেনকিও
0

ওরাকল এসকিউএল 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}}
    }
}
— Sumeet
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.