Trong nhiều phông chữ (cụ thể là phông chữ Consolas ), 5 trong số 10 chữ số thập phân có "lỗ hổng" trong đó. Chúng tôi sẽ gọi những chữ số thần thánh này:

46890

Do đó, 5 chữ số không linh hoạt là:

12357

Do đó, một số nguyên có thể được phân loại là "thánh" nếu nó chỉ chứa các chữ số thánh và "không linh hoạt" nếu không. Bởi vì -không linh thiêng, không có số nguyên âm nào có thể là thánh.

Số nguyên có thể được phân loại thêm dựa trên số lượng lỗ họ có. Ví dụ: các chữ số sau có độ thánh là 1:

469

Và những chữ số này có độ thánh là 2:

80

Chúng ta nói rằng tổng thể của một số nguyên là tổng của các số của nó. Do đó, 80sẽ có sự thánh thiện là 4, và 99sẽ có sự thánh thiện là 2.

Các thách thức

Cho hai số nguyên n > 0và h > 0, xuất ra nsố nguyên thánh thứ ít nhất có độ linh thiêng h. Bạn có thể giả định rằng đầu vào và đầu ra sẽ không lớn hơn số nguyên có thể biểu thị tối đa trong ngôn ngữ của bạn hoặc 2^64 - 1, tùy theo giá trị nào nhỏ hơn.

Dưới đây là danh sách 25 số nguyên thần thánh đầu tiên với sự thánh thiện h >= 1, để tham khảo:

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 số nguyên đầu tiên với sự thánh thiện h >= 2là:

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

Bình thường, 32 byte

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

Giải trình

                                 - 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ãy thử nó ở đây

Đưa đầu vào theo mẫu h \n n

Ruby, 109 105 95 82 byte

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

Đây là cách tiếp cận "tính toán từ 0 đến 99999999999 ..." khủng khiếp xảy ra ngắn hơn 13 byte so với đối tác lười biếng của nó. Tuy nhiên, phiên bản này khó có thể kết thúc trước cái chết nóng bỏng của vũ trụ. Đáng giá 13 byte, dù sao \ _ (ツ) _ /

Bạn có thể kiểm tra nó cho các giá trị nhỏ hơn bằng cách thay đổi ?9*99thành, nói , '99999'.

Đây là phiên bản cũ (95 byte, với đánh giá lười biếng, chạy gần như ngay lập tức thay vì gần như không bao giờ):

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

Trăn 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]

Đây là một giải pháp sử dụng cách tiếp cận hiệu quả hơn về bộ nhớ, nhưng nếu không thì sử dụng cùng một thuật toán nếu bạn muốn kiểm tra 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

Các trường hợp thử nghiệm:

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

PowerShell, 163 150 141 101 98 96 byte

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

Đưa đầu vào, sau đó lặp cho đến khi $nbằng không. Chúng tôi ban đầu thiết lập $i=-1bằng cách sử dụng một thủ thuật tiền xử lý, hoạt động bởi vì $i, trước đây chưa được khai báo, là $null. Sau đó, chúng tôi --, điều này khiến PowerShell đánh giá nó là $i = $null - 1, đó là $i=-1.

Mỗi vòng lặp chúng ta tăng lên $ivà sau đó thực hiện một ifcâu lệnh dài . Phần đầu tiên của điều kiện xác minh rằng $ikhông có bất kỳ phần nào 12357trong đó bằng cách sử dụng -notmatchtoán tử , để lọc ra các số không chính xác.

Phần thứ hai của điều kiện kiểm tra số lượng lỗ trong $i. Nó sử dụng -replacetoán tử để thay thế từng 8hoặc 0bằng 11, và sau đó so sánh xem độ dài là> = $h. Chúng ta không cần phải lo lắng về việc loại bỏ các số không linh hoạt, vì đó là phần đầu tiên của điều kiện và các số đơn lẻ có cùng độ dài như 1vậy, vì vậy chúng ta cũng không cần phải thay thế chúng.

Nếu điều đó vẫn đúng, chúng tôi sẽ giảm $n(vì điều đó có nghĩa là chúng tôi đã tìm thấy một số khác thỏa mãn yêu cầu đầu vào). Do đó, khi forđiều kiện được tính toán lại để kiểm tra xem $ncó bằng không, điều đó có nghĩa là chúng ta đã tìm thấy điều thứ n , vì vậy chúng ta thoát khỏi forvòng lặp, đầu ra $ivà chấm dứt.

_{Chỉnh sửa - đã lưu 13 byte bằng cách sử dụng một mảng thay vì chuỗi $lvà thay đổi cách $ngiảm / kiểm tra
Chỉnh sửa 2 - đã lưu thêm 9 byte bằng cách kiểm tra $ntrong forđiều kiện và di chuyển đầu ra bên ngoài vòng lặp
Chỉnh sửa 3 - đã lưu một con số khổng lồ Thêm 40 byte bằng cách thay đổi hoàn toàn cách chúng tôi tính toán các lỗ
Chỉnh sửa 4 - đã lưu thêm 3 byte bằng cách di chuyển ++đến mức tăng trước trên phần đầu tiên của Chỉnh sửa có điều kiện
5 - đã lưu thêm 2 byte nhờ TessellatingHeckler}

CJam, 36 34 byte

Cảm ơn aditsu đã lưu 2 byte.

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

Kiểm tra nó ở đây.

Tiện ích Bash + GNU, 67

• 20 byte được lưu nhờ vào @TobySpeight!

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

• seqchỉ cần tạo các số nguyên bắt đầu từ 0trở lên
• sed -r:
  • h sao chép dòng đầu vào vào không gian giữ
  • /12357/d xóa các số không đúng
  • s/8|0/&&/gthay thế chữ số gấp đôi bằng hai lần. Do đó, các chữ số đơn lẻ được tính một lần và các chữ số gấp đôi được tính hai lần.
  • /^.{$1}/!dNếu không khớp ít nhất $1các lỗ, xóa và tiếp tục dòng tiếp theo
  • x đưa số gốc trở lại không gian mẫu
  • in ngầm
• sed
  • $2!dtrên bất kỳ dòng nào trước dòng $2, xóa và tiếp tục dòng tiếp theo
  • qphải ở dòng $2- thoát (và in ngầm)

Ideone.

MATL , 39 40 byte

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

Inpunts nvà htheo thứ tự đó.

Hãy thử trực tuyến!

Chúng ta cần theo dõi hai số: số ứng cử viên hiện tại (để kiểm tra tính toàn vẹn của nó) và số lượng tìm thấy là đủ thánh. Đầu tiên là top od của ngăn xếp, và cái sau được giữ dưới dạng số phần tử trong ngăn xếp. Khi chương trình kết thúc, chỉ cần hiển thị hàng đầu.

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 byte

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}

Với các dòng mới và thụt lề:

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
}

Sử dụng:

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

JavaScript (ES6), 110 byte

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

Giải pháp đệ quy đuôi tích lũy số thánh trong một mảng.

Không quan tâm, không yêu cầu số phải là toàn bộ (!) Làm cho số thánh trở nên khó xử hơn, nhưng nó vẫn tiết kiệm 10% tổng thể:

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 byte

Chắc chắn, đây không phải là cách hiệu quả nhất. Nhưng bạn biết tôi mà, tôi yêu máy phát điện <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ơi vô dụng:

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 byte

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

Đây là Biểu thức Lambda thuộc loại Func <int, int, int>. Mã này được otimized cho kích thước tối thiểu (không biểu diễn).

Dưới đây, mã được làm đẹp trong khai báo phương thức (với hiệu suất cao hơn):

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

Ít chơi gôn

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
}  

Kiểm tra

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>

Lua, 169 byte

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

Ung dung:

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 byte

Đưa cả hai đầu vào bằng đối số dòng lệnh (đối số đầu tiên là n, sau đó h)

Chỉnh sửa: Cảm ơn @DavisDude, người đã giúp tôi cạo 14 byte và nhắc nhở tôi rằng tôi không phải in tất cả các số thánh lên đến n, mà chỉ là số thứ n.

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 và giải thích

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 byte

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;

Không chơi gôn

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

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)

Tình trạng thánh trên kđược kiểm tra bởi

• sum(map(s.count,`k`))>=h, tính số lượng lỗ bằng cách tính tổng số đếm cho mỗi ký tự s="0046889", ở đâu 0và 8xuất hiện hai lần.
• set(str(k))<=set(s)), trong đó kiểm tra rằng các con số là tất cả thánh. strđược sử dụng chứ không phải backticks để tránh hậu tố Ltrong thời gian dài.

Chúng được kết nối thành một đẳng thức duy nhất bằng cách sử dụng Python 2 thực tế là các số nhỏ hơn các tập hợp.

Hàm được định nghĩa đệ quy để đếm số lượng k, giảm bộ đếm nmỗi lần số lần truy cập thần thánh trừ khi nó chạm 0. Sau đó, nó có thể trả về cái kđã kích hoạt cái này, nhưng nó sẽ ngắn hơn để giữ số đếm theo cách đệ quy bằng cách thêm 1mỗi lần, mặc dù một cái khác đòi hỏi một số lượng cơ sở -1để sửa chữa.

Haskell, 94 byte

clà sự linh thiêng của một chữ số, vsự linh thiêng của một con số, n!hlàm phần còn lại.

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

Lưu ý: Tôi nghĩ rằng đây là câu trả lời duy nhất mà không có các nhân vật 4,6,8.

Nhanh

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