होलियर नंबर

Question

जैसा कि हमने द होली नंबरों से सीखा है , 5 पवित्र अंक ( 0, 4, 6, 8, 9) हैं, और उन पूर्णांकों से युक्त सकारात्मक पूर्णांक पवित्र हैं। इसके अतिरिक्त, एक संख्या की पवित्रता संख्या में छिद्रों का योग है ( +2हर 0या 8, और +1अन्यथा के लिए)।

अब, एक नंबर की पवित्रता को सही और सही रूप से दर्शाने के लिए, विचार करने के लिए एक अतिरिक्त संपत्ति है। आप देखते हैं, यह केवल अंकों के छिद्रों की संख्या नहीं है जो मायने रखती है, बल्कि यह भी कि यह कितनी संख्या में होता है।

संख्या पर विचार करें 88। हमारे पुराने नियमों से, इसकी पवित्रता होगी 4। लेकिन यह शायद ही उचित है! 8बाईं तरफ के अन्य की तुलना में अधिक काम कर रहा है 810 बार काम - इसके काम के लिए इसे पुरस्कृत किया जाना चाहिए। हम इसे सभी अंकों की कुल पवित्रता के बराबर इसके अधिकार के लिए अतिरिक्त पवित्रता अंकों के साथ पुरस्कृत करेंगे।

यहाँ और अधिक उदाहरणों को ध्यान में रखा गया है:

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)

चुनौती

पूर्णांक को देखते हुए 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

Comments

यह छेद विचार पवित्र है।

— केल्विन के शौक

"आउटपुट से अधिक नहीं होगा ..." से आपका क्या तात्पर्य है? जैसा कि आउटपुट में किसी भी संख्या से अधिक नहीं होगा 2^64 - 1? अगर ऐसा है तो शायद यह पता लगाने लायक है कि कौन सा इनपुट पहले ऐसे नंबर उत्पन्न करता है, ताकि लोग अपने उत्तरों का परीक्षण कर सकें।

— FryAmTheEggman

@FryAmTheEggman से अधिक या इसके बराबर का मतलब से कम नहीं है। मैं विभिन्न पूर्णांक आकार के लिए कुछ अधिकतम के साथ पोस्ट को अपडेट करूंगा।

— मैगो

आपका अजगर कोड 6 के लिए काम नहीं करता है, यह

— श्रिक्स

Answer 1

पायथन 2, 138 122 बाइट्स

यह एक इनपुट एन के लिए 5 ^एन तक की पवित्र संख्या की तलाश करता है, जो हास्यास्पद रूप से धीमा है:

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 एन ^{2 है} , और आप वास्तव में एक बाइट की कीमत पर परीक्षण मामलों को चला सकते हैं:

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)

पहला स्निपेट मान्य है, क्योंकि सभी सकारात्मक पूर्णांक एन के लिए 5 ^एन sn 5 एन ^{2 है} ।

Comments

ओह, रुको, मुझे कुछ याद आया .. इसके लिए बहुत थक गया।

— 21

Answer 2

लुआ, 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

घोंसले के नए मूल्य के लिए उपयोग किए जाने वाले नेस्टेड टर्नरीज़ का अनुवाद नेस्टेड ifs में निम्नानुसार किया mजा सकता है:

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)

Answer 3

जावास्क्रिप्ट (ईएस 6), 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 बाइट को बचाया।

Ungolfed:

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