양의 정수가 주어지면 많은 해밍 숫자 를 순서대로 인쇄하십시오 .

규칙 :

• 입력은 양의 정수입니다.$n \le 1,000,000$
• 출력은 https://oeis.org/A051037 의 첫 n 개 조건이어야합니다.
• 실행 시간은 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 백만의 전체 백만을 계산합니다 (실제로 출력을 저장하려는 경우 더 많음)

언 골프 드 :

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

모든 Haskell은 악명 높은 것으로 잘 알려져 있습니다. 실제로 작동하는 방식으로 목록을 자체의 게으른 함수로 정의하십시오.

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

루비 - (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

Perl, 94 자 (그러나 너무 느림)

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

언 골프 드 :

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 개를 처리합니다. 그것은 O (n ^ 2)와 비슷한 것입니다 :(

APL (Dyalog Classic) , 34 23 바이트

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

온라인으로 사용해보십시오!

$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.

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

우르 살라, 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>

수학, 54 바이트

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

비효율적이지만 짧은 순수한 기능. 양식의 모든 제품에 계산 2^i * 3^j * 5^k에를 0 <= i, j, k <= #( #함수의 첫 번째 인수 인), 다음 Sort을 S와 Take첫 번째에요 #.

apt, 15 바이트

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

시도 해봐

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

시도 해봐

3 바이트

Jo King의 접근 방식 이 유효한 것으로 간주되는 경우 .

o!²

시도 해봐