많은 글꼴 (특히 Consolas 글꼴 )에서 10 진수 10 개 중 5 개에 "구멍"이 있습니다. 우리는이 성수들을 부를 것입니다 :

46890

따라서 부정한 5 자리 숫자는 다음과 같습니다.

12357

따라서 정수는 홀수 만 포함하면 "거룩한"것으로 분류되고 그렇지 않으면 "거룩하지 않은"로 분류 될 수 있습니다. -부정 이기 때문에 음의 정수는 거룩 할 수 없습니다.

홀수는 홀 수에 따라 추가로 분류 될 수 있습니다. 예를 들어 다음 숫자는 거룩함이 1입니다.

469

이 숫자는 거룩함이 2입니다.

80

정수의 전체 성결은 자릿수의 성결의 합이라고 말합니다. 그러므로 80거룩함은 4이고 99거룩함은 2입니다.

도전

두 개의 정수가 주어 n > 0지고 거룩함이 적어도 거룩한 정수를 h > 0출력하십시오 . 입력 및 출력이 사용자 언어의 표현 가능한 최대 정수보다 크지 않거나 더 작은 값보다 작을 것이라고 가정 할 수 있습니다 .nh2^64 - 1

다음은 h >= 1참조 용 으로 holiness가있는 첫 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

거룩함 h >= 2을 지닌 첫 25 개의 거룩한 정수 는 다음 과 같습니다.

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

루비, 109 (105) 95 82 바이트

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

이것은 게으른 상대방보다 13 바이트 더 짧은 끔찍한 "0에서 99999999999 ..."접근 방식입니다. 그러나이 버전은 우주의 더위가 죽기 전에 끝나지 않을 것입니다. 어쨌든 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
}

파이썬 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

입력을 취한 다음 $n0이 될 때까지 반복 합니다. 우리는 처음 $i=-1에 사전 처리 트릭을 사용하여 설정 합니다. 이는 $i이전에 선언되지 않았기 때문에 작동합니다 $null. 그런 다음 --PowerShell을 유발 그것은으로 평가하기 위해 $i = $null - 1인 $i=-1.

각 루프는 증분 $i한 다음 긴 if문장 을 실행합니다 . 조건부의 첫 번째 부분은 operator 를 사용 하여 부정한 숫자를 필터링 하여 그 안에 $i없는 것이 없는지 확인합니다 .12357-notmatch

조건부의 두 번째 부분은의 구멍 수량을 확인합니다 $i. 그것은 사용하는 -replace각 교체 운영자 8또는 0로를 11다음 길이인지 비교> = $h. 조건부의 첫 부분에있는 부정한 숫자를 제거하는 것에 대해 걱정할 필요가 없으며 단일 홀이 된 숫자의 길이는 1어쨌든 길이가 같으 므로이를 바꿀 필요도 없습니다.

그것이 여전히 진실이라면, 우리는 감소합니다 $n(따라서 입력 요구 사항을 충족시키는 다른 숫자를 찾았 음을 의미합니다). 따라서 for조건이 다시 계산되어 $n0 인지 확인하면 n 번째 값을 찾았 으므로 for루프를 종료하고 출력 $i하고 종료합니다.

_{편집-문자열 대신 배열을 사용하여 감소 및 검사 $l방법을 변경 하여 13 바이트 저장 $n
편집 2- 조건부 $n에서 확인 for하고 루프 외부로 출력을 이동하여 추가 9 바이트를
저장 편집 3-무려 저장 구멍 계산 방법을 근본적으로 변경하여 40 바이트 더
편집 4- ++조건부 편집 5 의 첫 번째 부분에서 사전 증분으로 이동하여 추가 3 바이트를
절약 -TessellatingHeckler 덕분에 2 바이트를 더 절약했습니다.}

CJam, 36 34 바이트

2 바이트를 절약 한 aditsu에게 감사드립니다.

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

여기에서 테스트하십시오.

배쉬 + GNU 유틸리티, 67

• @TobySpeight 덕분에 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!dline 앞에있는 행 $2에서 삭제하고 다음 행으로 계속하십시오.
  • q줄에 있어야합니다 $2-그리고 묵시적 인 인쇄

이데온

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, 109107 바이트

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

자바 스크립트 (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

자바 스크립트 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)))

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

Func <int, int, int> 유형의 Lambda 표현식입니다. 이 코드는 최소 크기 (성능이 아님)로 지정됩니다.

아래는 메소드 선언에서 아름답게 작성된 코드입니다 (성능 향상).

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

자바 스크립트 (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>

루아, 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

언 골프 드 :

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

루아, 155 (141) 140 바이트

명령 행 인수로 두 입력을받습니다 (첫 번째 인수는 n, h).

편집 : @DavisDude 덕분에 14 바이트를 줄일 수 있었고 모든 거룩한 숫자를 n까지 인쇄 할 필요는 없지만 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])

언 골프 및 설명

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 

파이썬 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를 오랫동안 피하기 위해 백틱 대신에 사용됩니다 .

이것들은 숫자가 세트보다 작다는 Python 2 사실을 사용하여 단일 동등성으로 연결됩니다.

이 함수는 숫자를 세도록 재귀 적으로 정의되며 k, n적중하지 않으면 매번 적중 횟수를 감소시킵니다 0. 그런 다음 k트리거 된 것을 반환 할 수는 있지만 1매번 추가하여 카운트를 재귀 적으로 유지하는 것이 더 짧습니다 -1.

하스켈, 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}}
    }
}