हमिंग नंबर

Question

एक सकारात्मक पूर्णांक को देखते हुए, उस क्रम में कई हैमिंग संख्याएं प्रिंट करें।

नियम:

• इनपुट एक सकारात्मक पूर्णांक हो जाएगा $n \le 1,000,000$
• आउटपुट https://oeis.org/A051037 का पहला n शब्द होना चाहिए
• निष्पादन का समय <1 मिनट होना चाहिए
• यह कोड-गोल्फ है ; सबसे छोटा कोड जीतता है

Comments

किस उद्देश्य का उत्तर होना चाहिए? गोल्फ? सबसे प्रभावी एल्गोरिथ्म? बस समाधान के तरीकों की खोज?

— नकिलन

विशिष्ट नहीं होने के लिए क्षमा करें। मैंने इसे स्वयं हल नहीं किया है, इसलिए मुझे यकीन नहीं है कि मैंने जो सीमाएं लगाई हैं वे उचित हैं। कृपया मुझे बताओ।

— ग्रुकस ३०'११

OEIS

— स्टीफन

1 एक हैमिंग नंबर है, इसलिए, 1,000,000 1s को प्रिंट करना आपके चश्मे के अनुरूप है। यह क्रम में भी होगा, न कि अनियोजित अनुक्रम। :)

— विल नेस

Answer 1

हास्केल, 101 97 92+ | n | पात्र

h=1:m 2h&m 3h&m 5h
m=map.(*)
c@(a:b)&o@(m:n)|a<m=a:b&o|a>m=m:c&n|0<1=a:b&n
main=print$take 1000000h

मैंने जिस मशीन पर परीक्षण किया है उस पर 3.7 मिलियन में पूर्ण मिलियन की गणना करता है (यदि आप वास्तव में संग्रहित आउटपुट चाहते हैं तो अधिक)

Ungolfed:

-- print out the first million Hamming numbers
main = print $ take 1000000 h

-- h is the entire Hamming sequence.
-- It starts with 1; for each number in the
-- sequence, 2n, 3n and 5n are also in.
h = 1 : (m 2 h) & (m 3 h) & (m 5 h)

-- helper: m scales a list by a constant factor
m f xs = map (f*) xs

-- helper: (&) merges two ordered sequences
a@(ha:ta) & b@(hb:tb)
    |    ha < hb = ha : ta & b
    |    ha > hb = hb :  a & tb
    |  otherwise = ha : ta & tb

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

Comments

आपको सकारात्मक पूर्णांक पैरामीटर नहीं मिलता है, जो आपके कोड में अधिक आकार जोड़ते हैं

— झेन

@ जब पॉजिटिव पूर्णांक पैरामीटर दूसरा-से-अंतिम टोकन होता है, और हेडर में इसका आकार बाहरी घोषित किया जाता है।

— जेबी

Answer 2

अजगर 181 वर्ण

h=[]        
h.append(1)
n=input()
i=j=k=0
while n:
    print h[-1]
    while h[i]*2<=h[-1]:
        i+=1
    while h[j]*3<=h[-1]:
        j+=1
    while h[k]*5<=h[-1]:
        k+=1
    h.append(min(h[i]*2,h[j]*3,h[k]*5))
    n-=1

Comments

यह 181 वर्ण कैसे है? मैंने इसे एक फ़ाइल में सहेजा है, व्हाट्सएप को हटाने के बाद h=[], एक न्यूनतम टैब दूरी का उपयोग करके, और एकल वर्ण रेखा टूट जाती है, और फ़ाइल का आकार 187 बाइट्स तक समाप्त होता है।

— नाइट्रो 2k01

वैसे भी ... तुच्छ अनुकूलन h=[1]:। इसके अलावा, संख्याओं के लिए वर्णों को सहेजने के लिए, सीधे स्रोत कोड में एक संख्या दें <1000000।

— नाइट्रो 2k01

और उफ़, क्षमा करें, यह महसूस नहीं किया कि उत्तर अति-पुराना है।

— नाइट्रो 2k01

@ nitro2k01, मैं इसे 183 वर्ण बनाता हूं। (पहली पंक्ति के अंत में कुछ अनुगामी व्हाट्सएप है, और इंडेंटेशन में एक स्तर और दो स्तरों के लिए एक टैब होना चाहिए)।

— पीटर टेलर

Answer 3

रूबी - 154 231 वर्ण

def k i,n;(l=Math).log(i,2)*l.log(i,3)*l.log(i,5)/6>n end
def l i,n;k(i,n)?[i]:[i]+l(5*i,n)end
def j i,n;k(i,n)?[i]:[i]+j(3*i,n)+l(5*i,n)end
def h i,n;k(i,n)?[i]:[i]+h(2*i,n)+j(3*i,n)+l(5*i,n)end
puts h(1,n=gets.to_i).sort.first n

और अब यह काफी तेज है, निश्चित रूप से बहुत से गोल्फिंग हैं जो अभी भी हो सकते हैं।

→ time echo 1000000 | ruby golf-hamming.rb | wc
1000000 1000000 64103205
echo 1000000  0.00s user 0.00s system 0% cpu 0.003 total
ruby golf-hamming.rb  40.39s user 0.81s system 99% cpu 41.229 total
wc  1.58s user 0.05s system 3% cpu 41.228 total

Answer 4

पर्ल, 94 चार्ट (लेकिन बहुत धीमी गति से)

use List::Util min;
$\=$/;$h{1}=();delete$h{$_=min keys%h},print,@h{$_*2,$_*3,$_*5}=()for 1..<>

Ungolfed:

use List::Util 'min';
my %hamming;
my $up_to = <>;
$hamming{1} = (); # The value is undef, but the key exists!
for (1 .. $up_to) {
    my $next = min( keys %hamming );
    delete $hamming{$next}; # We're done with this one
    print $next, "\n";
    @hamming{ $next * 2, $next * 3, $next * 5 } = (); # Create keys for the multiples
} # Rinse, repeat

पहले 100,000 नंबरों की गणना के लिए 11 मिनट लगते हैं, और मैं 1,000,000 के बारे में सोचना भी नहीं चाहता। यह एक साफ 3 सेकंड में पहले 10,000 किया जाता है; यह सिर्फ ओ (n ^ 2) जैसा कुछ है :(

Answer 5

एपीएल (डायलॉग क्लासिक) , 34 23 बाइट्स

{⍺⍴{⍵[⍋⍵]}∪,⍵∘.×⍳5}⍣≡∘1

इसे ऑनलाइन आज़माएं!

TIO लिए एक WS पूर्ण त्रुटि फेंकता है$n = 1000000$

{⍺⍴{⍵[⍋⍵]}∪,⍵∘.×⍳5}⍣≡∘1     Monadic function:
{⍺⍴{⍵[⍋⍵]}∪,⍵∘.×⍳5}         Define the following helper function g(⍺,⍵):
             ⍵∘.×⍳5             Make a multiplication table between ⍵ and (1 2 3 4 5).
                                (Including 4 is unnecessary but saves bytes.)
            ,                   Flatten the table into an array.
           ∪                    Keep unique elements.
    {⍵[⍋⍵]}                     Grade up the array and access it at those indices.
                                (This is the APL idiom to sort an array.)
 ⍺⍴                             Keep the first ⍺ elements; pad by repeating the array.
{⍺⍴{⍵[⍋⍵]}∪,⍵∘.×⍳5}⍣≡       Repeatedly apply g with some fixed left argument
                             until a fixed point is reached.
                             At this point we have a dyadic function that takes
                             n on the left and the starting value on the right,
                             and returns multiples of the n Hamming numbers.
                      ∘1     Fix 1 as the right argument.

Comments

आसपास की चीजों में फेरबदल से चार की बचत होती है:1↓0 1{⍺↑{⍵[⍋⍵]}∪,⍵∘.×⍳5}⍣≡⍨1+⊢

— Adám

{⍺⍴∧∪,⍵×⍀⍳5}`⍣≡∘1विस्तारित में FYI करें । (बग के कारण बैकटीक की जरूरत है।)

— एडम

Answer 6

हास्केल, 71

h n = drop n $ iterate (\(_,(a:t))-> (a,union t [2*a,3*a,5*a])) (0,[1])

उत्पादन

*Main> map fst $ take 20 $ h 1
[1,2,3,4,5,6,8,9,10,12,15,16,18,20,24,25,27,30,32,36]

Comments

युक्ति आपको प्रिंट करने के लिए बुलाती है, इसलिए प्रिंट करने के लिए कोड को गिना जाना चाहिए। यह अन्य हास्केल कार्यान्वयन के खिलाफ एक निष्पक्ष तुलना की भी अनुमति देता है।

— पीटर टेलर

@PeterTaylor आपको लगता है कि मुझे कितने पात्रों को जोड़ना चाहिए?

— टिमटेक

Answer 7

उर्सला, 103

#import std
#import nat
smooth"p" "n" = ~&z take/"n" nleq-< (rep(length "n") ^Ts/~& product*K0/"p") <1>

आउटपुट के लिएmain = smooth<2,3,5>* nrange(1,20)

<1,2,3,4,5,6,8,9,10,12,15,16,18,20,24,25,27,30,32,36>

Answer 8

मैथेमेटिका, 54 बाइट्स

Sort[1##&@@@({2,3,5}^#&/@Tuples[0~Range~#,3])]~Take~#&

अक्षम लेकिन कम शुद्ध कार्य। प्रपत्र के सभी उत्पादों की गणना करता है 2^i * 3^j * 5^kके लिए 0 <= i, j, k <= #( #कार्य करने के लिए पहला तर्क है), तो Sortउन्हें है और Takeकेवल पहले एस #।

Comments

किसी भी तरह मुझे नहीं लगता कि 1e18 की गणना एक मिनट के अंदर होने वाली है।

— जोनाथन एलन

Answer 9

जाप, 15 बाइट्स

@_k e§5}a°X}h1ì

कोशिश करो

ÆJ=_k d>5}f°Jª1

कोशिश करो

---

3 बाइट्स

अगर जो राजा का दृष्टिकोण वैध माना जाता है।

o!²

कोशिश करो

Comments

यह <1 मिनट में निष्पादित करने की आवश्यकता को पूरा करने के लिए कहीं भी करीब नहीं आता है। (और जो किंग का दृष्टिकोण मान्य नहीं है।)

— एंडर्स कासोर्ग