Như chúng ta đã học được từ The Holy Numbers , có 5 chữ số thánh ( 0, 4, 6, 8, 9) và các số nguyên dương chỉ bao gồm các chữ số đó là thánh. Ngoài ra, sự linh thiêng của một số là tổng của các lỗ trong số đó ( +2cho mỗi 0hoặc 8, và +1nếu không).

Bây giờ, có một tài sản bổ sung để xem xét, để thể hiện thực sự và chính xác sự linh thiêng của một con số. Bạn thấy đấy, nó không chỉ là số lượng lỗ trong chữ số quan trọng, mà còn là số lượng xảy ra.

Hãy xem xét số lượng 88. Theo quy tắc cũ của chúng tôi, nó sẽ có một sự thánh thiện 4. Nhưng điều đó thật khó công bằng! Bên 8trái đang làm nhiều việc hơn bên kia 8- gấp 10 lần công việc! Nó nên được khen thưởng cho công việc của nó. Chúng tôi sẽ thưởng cho nó thêm điểm thánh bằng tổng số thánh của tất cả các chữ số ở bên phải của nó (bao gồm cả các điểm thánh được thêm bởi quy tắc này cho các chữ số bên phải của nó), trừ đi 1.

Dưới đây là nhiều ví dụ để xem xét:

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

Tất cả các chữ số được khen thưởng thích hợp cho công việc của họ với sự thánh thiện thêm, và tất cả đều tốt. Chúng tôi sẽ gọi tài sản này là "tăng cường toàn diện".

Trong ngôn ngữ tuyệt vời Python, một thuật toán để tính toán tổng thể nâng cao có thể trông giống như thế này:

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

Các thách thức

Cho một số nguyên n > 0, xuất ra các nSố Thánh đầu tiên , được sắp xếp theo mức tăng dần, tăng giá trị số, làm giá trị số làm bộ chia. 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.

Để tham khảo, đây là một số trường hợp thử nghiệm (đầu vào, tiếp theo là đầu ra):

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

Python 2, 138 122 byte

Điều này tìm kiếm các số thánh lên đến 5 ^N cho một đầu vào N , tốc độ rất chậm:

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)

Ở đây giới hạn là 5 N ² và bạn thực sự có thể chạy các trường hợp thử nghiệm, với chi phí của một byte đơ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)

Đoạn đầu tiên là hợp lệ, như 5 ^N ≥ 5 N ² cho tất cả các số nguyên dương N .

Lua, 317 byte

Tôi đã gặp một số rắc rối khi làm điều này, một số điều ở Lua không hoạt động như tôi nghĩ. Tôi sẽ phải cố gắng và chơi với họ nếu tôi muốn chơi golf này. Bạn có thể kiểm tra lua trực tuyến bằng cách thay thế arg[1]bằng số lượng phần tử bạn muốn :).

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

Ungolfed và giải thích

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

Các ternaries lồng nhau được sử dụng cho giá trị mới của mcó thể được dịch trong ifs lồng nhau như:

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

Ngoài ra, tôi rất thích thay thế lồng nhau forbằng cách sử dụng table.sort, nhưng, vì một lý do tôi không biết, những điều sau đây không hoạt động mặc dù không tạo ra một vòng lặp vô hạn hoặc nghiền nát hàm sắp xếp.

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

JavaScript (ES6), 166 165 byte

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

Chỉnh sửa: Đã lưu 1 byte bằng cách trả về một chuỗi các chuỗi.

Ung dung:

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