ในฟอนต์หลายแบบ (โดยเฉพาะในฟอนต์ Consolas ) ตัวเลข 5 ใน 10 หลักมี "รู" ในตัว เราจะเรียกเลขศักดิ์สิทธิ์เหล่านี้:

46890

ดังนั้นตัวเลข 5 หลักที่ไม่บริสุทธิ์คือ:

12357

จำนวนเต็มจึงอาจจัดเป็น "ศักดิ์สิทธิ์" หากมันมีเพียงตัวเลขศักดิ์สิทธิ์และ "ไม่บริสุทธิ์" เป็นอย่างอื่น เนื่องจาก-ไม่บริสุทธิ์จึงไม่สามารถลบเลขจำนวนเต็มลบได้

จำนวนเต็มศักดิ์สิทธิ์อาจถูกจัดประเภทเพิ่มเติมตามจำนวนหลุมที่มี ตัวอย่างเช่นตัวเลขต่อไปนี้มีความศักดิ์สิทธิ์ที่ 1:

469

และตัวเลขเหล่านี้มีความศักดิ์สิทธิ์ 2:

80

เราพูดว่าความศักดิ์สิทธิ์โดยรวมของจำนวนเต็มคือผลรวมของความศักดิ์สิทธิ์ของตัวเลข ดังนั้น80จะมีความศักดิ์สิทธิ์ 4 และ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

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

Ruby, 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
}

Python 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

PowerShell, 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เป็นศูนย์นั่นหมายความว่าเราได้พบที่ nหนึ่งดังนั้นเราจึงออกจากforวงเอาท์พุท$iและยุติ

_{แก้ไข - บันทึก 13 ไบต์โดยใช้อาร์เรย์แทนสตริงสำหรับ$lและการเปลี่ยนแปลงวิธีการ$nลด / ตรวจสอบ
แก้ไข 2 - บันทึกเพิ่มอีก 9 ไบต์โดยการตรวจสอบ$nในforเงื่อนไขและย้ายผลลัพธ์นอกวง
แก้ไข 3 - บันทึกมหันต์ 40 ไบต์โดยการเปลี่ยนแปลงวิธีที่เราคำนวณรู
แก้ไข 4 - บันทึกอีก 3 ไบต์โดยการย้าย++ไปเป็นส่วนเพิ่มล่วงหน้าในส่วนแรกของเงื่อนไขการ
แก้ไข 5 - บันทึกอีก 2 ไบต์ด้วยTessellatingHeckler}

CJam, 36 34 ไบต์

ขอบคุณ aditsu สำหรับการบันทึก 2 ไบต์

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

ทดสอบที่นี่

ยูทิลิตี Bash + GNU, 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

MATL , 39 40ไบต์

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

Inpunts มี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

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

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

Tail recursive solution ที่สะสมตัวเลขศักดิ์สิทธิ์ในอาเรย์

ไม่เป็นที่น่าสนใจโดยไม่ต้องการจำนวนที่ศักดิ์สิทธิ์ทั้งหมด (!) ทำให้ความศักดิ์สิทธิ์นั้นน่าอึดอัดใจมากขึ้น แต่ก็ยังช่วยให้ประหยัดได้ 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

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

ungolfed เล็กน้อย:

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

C # 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;}

นี่คือ Lambda Expression ของประเภท Func <int, int, int> รหัสนี้ถูก otimized สำหรับขนาด min (ไม่ใช่ performatic)

ด้านล่างโค้ดที่สวยงามในการประกาศเมธอด (มีประสิทธิภาพมากกว่า):

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

JavaScript (ES6), 87

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

น้อย golfed

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>

ลัวะ 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

Lua, 155 141 140 Bytes

รับอินพุตทั้งสองโดยอาร์กิวเมนต์บรรทัดคำสั่ง (อาร์กิวเมนต์แรกคือ 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])

Ungolfed และคำอธิบาย

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

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;

ยกเลิกแข็งแรงเล่นกอล์ฟ

: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 

Python 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ใช้แทน backticks เพื่อหลีกเลี่ยงคำต่อท้ายเป็นLเวลานาน

สิ่งเหล่านี้ถูกล่ามโซ่ไว้ในความเท่าเทียมกันเพียงครั้งเดียวโดยใช้ Python 2 ข้อเท็จจริงที่ว่าตัวเลขมีขนาดเล็กกว่าชุด

ฟังก์ชั่นที่มีการกำหนดซ้ำการนับตัวเลขkลดลงนับในแต่ละครั้งจำนวนศักดิ์สิทธิ์ของตีเว้นแต่จะฮิตn 0จากนั้นก็จะกลับมาkที่เรียกนี้ แต่มันสั้นเพื่อให้การนับซ้ำโดยการเพิ่ม1แต่ละครั้ง แต่ปิดโดยหนึ่งต้องมีการนับฐานของ-1การแก้ไข

Haskell, 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ผมคิดว่านี่เป็นคำตอบเดียวโดยไม่ต้องตัวละคร

รวดเร็ว

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