우리가 성수 에서 배웠 듯이 , 5 개의 거룩한 숫자 ( 0, 4, 6, 8, 9)가 있고, 그 숫자로만 구성된 양의 정수는 거룩한 것입니다. 또한, 다수의 신성은 (수가 구멍의 합 +2마다 용 0또는 8과 +1달리)이.

이제, 거룩함을 진실하고 정확하게 표현하기 위해 고려해야 할 추가 속성이 있습니다. 보시다시피, 그것은 숫자의 중요한 홀 수뿐만 아니라 숫자의 발생 위치이기도합니다.

숫자를 고려하십시오 88. 우리의 오래된 규칙에 따르면, 그것은 거룩함을 갖게 될 것입니다 4. 그러나 그것은 거의 공평하지 않습니다! 8왼쪽은 다른 것보다 더 많은 일을하고있다 8- 10 시간 일을! 그것은 일에 대한 보상이되어야합니다. 우리는 오른쪽에있는 모든 자릿수의 총 거룩 성과 동일한 여분의 성결 점 (이 규칙에 의해 오른쪽의 숫자에 부여 된 여분의 성결 점 포함)에서 1을 뺀 것으로 보상합니다.

고려해야 할 추가 예는 다음과 같습니다.

Number: 8080
Digital holiness: (2 + 7 - 1) + (2 + 3 - 1) + (2 + 1 - 1) + (2 + 0 - 1)
Total holiness: 15

Number: 68904
Digital holiness: (1 + 5 - 1) + (2 + 2 - 1) + (1 + 1 - 1) + (2 + 0 - 1) + (1 + 0 - 1)
Total holiness: 10

모든 자릿수는 여분의 성결로 그들의 일에 대해 적절하게 보상되며, 모든 것이 좋습니다. 우리는이 속성을 "향상된 선명도"라고 부릅니다.

위대한 언어 파이썬에서 향상된 명료도를 계산하는 알고리즘은 다음과 같습니다.

# assumes n is a holy number
def enhanced_holarity(n):
    if n < 10:
        return 1 if n in [0, 8] else 0
    else:
        digits = list(map(int,str(n)[::-1]))
        res = []
        for i,x in enumerate(digits):
            res.append(enhanced_holarity(x))
            if i > 0:
                res[i] += sum(res[:i])
        return sum(res)

도전

integer가 주어지면 숫자 값을 타이 브레이커로 사용하여 강화 된 명료도를 오름차순으로 정렬 n > 0하여 첫 번째 n홀수를 출력합니다 . 입력 및 출력이 사용자 언어의 표현 가능한 최대 정수보다 크거나 같지 않다고 가정 할 수 있습니다 2^64 - 1.

참고로 다음은 몇 가지 테스트 사례입니다 (입력, 출력).

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

100
4, 6, 9, 44, 46, 49, 64, 66, 69, 94, 96, 99, 444, 446, 449, 464, 466, 469, 494, 496, 499, 644, 646, 649, 664, 666, 669, 694, 696, 699, 0, 8, 84, 86, 89, 844, 846, 849, 864, 866, 869, 894, 896, 899, 40, 48, 60, 68, 90, 98, 404, 406, 409, 484, 486, 489, 604, 606, 609, 684, 686, 689, 80, 88, 804, 806, 809, 884, 886, 889, 440, 448, 460, 468, 490, 498, 640, 648, 660, 668, 690, 698, 840, 848, 860, 868, 890, 898, 400, 408, 480, 488, 600, 608, 680, 688, 800, 808, 880, 888

200
4, 6, 9, 44, 46, 49, 64, 66, 69, 94, 96, 99, 444, 446, 449, 464, 466, 469, 494, 496, 499, 644, 646, 649, 664, 666, 669, 694, 696, 699, 944, 946, 949, 964, 966, 969, 994, 996, 999, 4444, 4446, 4449, 4464, 4466, 4469, 4494, 4496, 4499, 4644, 4646, 4649, 4664, 4666, 4669, 4694, 4696, 4699, 0, 8, 84, 86, 89, 844, 846, 849, 864, 866, 869, 894, 896, 899, 40, 48, 60, 68, 90, 98, 404, 406, 409, 484, 486, 489, 604, 606, 609, 684, 686, 689, 904, 906, 909, 984, 986, 989, 4044, 4046, 4049, 4064, 4066, 4069, 4094, 4096, 4099, 80, 88, 804, 806, 809, 884, 886, 889, 440, 448, 460, 468, 490, 498, 640, 648, 660, 668, 690, 698, 940, 948, 960, 968, 990, 998, 4404, 4406, 4409, 4484, 4486, 4489, 4604, 4606, 4609, 4684, 4686, 4689, 840, 848, 860, 868, 890, 898, 400, 408, 480, 488, 600, 608, 680, 688, 900, 908, 980, 988, 4004, 4006, 4009, 4084, 4086, 4089, 800, 808, 880, 888, 4440, 4448, 4460, 4468, 4490, 4498, 4640, 4648, 4660, 4668, 4690, 4698, 4040, 4048, 4060, 4068, 4090, 4098, 4400, 4408, 4480, 4488, 4600, 4608, 4680, 4688, 4000, 4008, 4080, 4088

파이썬 2, 138122 바이트

이것은 입력 N에 대해 최대 ^5N의 거룩한 숫자를 찾고 엄청나게 느립니다.

e=lambda s:s and(s[0]in'08')+e(s[1:])*2or 0
lambda N:sorted([`x`for x in range(5**N)if set(`x`)<=set('04689')][:N],key=e)

여기서 한계는 5 N ² 이며 단일 바이트 비용으로 실제로 테스트 케이스를 실행할 수 있습니다.

e=lambda s:s and(s[0]in'08')+e(s[1:])*2or 0
lambda N:sorted([`x`for x in range(5*N*N)if set(`x`)<=set('04689')][:N],key=e)

첫 번째 스 니펫은 모든 양의 정수 N에 대해 5 ^N ≥ 5 N ² 로 유효합니다 .

루아, 317 바이트

나는 이것을하는 데 문제가 있었고, 루아의 일부는 내가 생각하는 것처럼 작동하지 않습니다. 골프를 즐기고 싶다면 그들과 함께 놀아 봐야합니다. 원하는 요소 수로 교체 하여 루아를 온라인 으로 테스트 할 수 있습니다 arg[1]. :).

function f(y)h=0(y..''):reverse():gsub(".",function(c)h=c:find("[08]")and 1+h or h end)return h end
x,a=0,{}while(#a<arg[1]+0)do a[#a+1],x=(x..''):find("^[04689]*$")and x or nil,x+1 end
for i=1,#a do m=1
for j=1,#a do x=a[m]m=(f(x)~=f(a[j])and f(x)>f(a[j])or x>a[j])and j or m
end end print(a[m])table.remove(a,m)end

언 골프 및 설명

function f(y)                     -- function returning the enhanced holiness of a holy number
  h=0                             -- h is the cumulated holyness of processed digits
  (y..''):reverse()               -- reverse the digits in y
         :gsub(".",function(c)    -- iterate over each digits
     h=c:find("[08]")and 1+h or h -- ternary based on the digit being [08] or [469]
   end)                           
  return h                        -- return h
end

x,a=0,{}                          -- initialise a counter, and the array of holy numbers
while(#a<arg[1]+0)                -- iterate until we have n holy numbers
do
  a[#a+1]=(x..'')                 
      :find("^[04689]*$")         -- if we can't find an unholy digit
             and x or nil         -- insert x into a
  x=x+1                           -- increment x anyway
end

for i=1,#a                        -- iterate n times(current size of a)
do
  m=1                             -- m is the index of the lowest value
  for j=1,#a                      -- iterate over a
  do
    x=a[m]                        -- x is shorter to write than a[m]
    m=(f(x)~=f(a[j])              -- nested ternaries, translated in
        and f(x)>f(a[j])          -- nested if below
        or x>a[j])and j or m      
  end
  print(a[m])                     -- output a[m]
  table.remove(a,m)               -- remove it from the table a
end

새 값에 사용 된 중첩 삼항 m은 다음과 같이 중첩 if에서 변환 될 수 있습니다.

if(f(a[m])~=f(a[j])) then         -- if a[m] and a[j] don't have the same holyness
  if(f(a[m])>f(a[j])) then m=j end-- compare by holyness
else
  if(a[m]>a[j]) then m=j end      -- else, compare by numeric value

또한 for을 사용하여 중첩을 대체하고 싶었지만 table.sort알 수없는 이유로 무한 루프를 생성하지 않거나 정렬 함수를 분쇄하지 않아도 다음이 작동하지 않습니다.

table.sort(a,function(i,j)
    return f(i)~=f(j)              
         and f(i)>f(j)          
         or i>j
end)

자바 스크립트 (ES6) 166 165 바이트

f=n=>[...Array(n)].map((_,i)=>i.toString(5)).sort((a,b)=>e(a)-e(b),e=n=>'0b'+[...n.replace(/./g,c=>'10010'[c])].reverse().join``).map(n=>+n.replace(/./g,c=>"04689"[c]))

편집 : 문자열 배열을 반환하여 1 바이트를 절약했습니다.

언 골프 드 :

function base5_to_extended_holiness_binary(c) {
    return "10010"[c];
}
function extended_holiness(n) {
    var binary = n.toString(5).replace(/./g, base5_to_extended_holiness_binary);
    binary = s.split("").reverse().join("");
    return parseInt(s, 2);
}
function extended_holiness_sort(a, b) {
    return extended_holiness(a) - extended_holiness(b);
}
function base5_to_holy_number(c) {
    return "04689"[c];
}
function list_by_extended_holiness(n) {
    var array = new Array(n);
    for (var i = 0; i < n; i++)
         array[i] = i;
    array = array.sort(extended_holiness_sort);
    for (var i = 0; i < n; i++)
        array[i] = parseInt(array[i].toString(5).replace(/./g, base5_to_holy_number);
    return array;
}