Humble numbers: Difference between revisions

{{task|Prime Numbers}}

 

 

 

<br>although this conflicts with another meaning of &nbsp; ''highly composite numbers''.

 

 

;References:

:* &nbsp; [http://www.informatik.uni-ulm.de/acm/Locals/1996/number.sol University of Ulm, The first 5842 terms of humble numbers]

<br><br>

{{trans|C++}}

 

I i <= 1

R 1B

I num !C humble

L.break

 

{{out}}

1272 have 8 digits

1767 have 9 digits

</pre>

 

=={{header|Ada}}==

 

procedure Show_Humble is

Count_Humble_Digits;

Show_Digit_Counts;

 

{{out}}

8 1272

9 1767</pre>

 

=={{header|C}}==

{{trans|C++}}

#include <stdbool.h>

#include <stdio.h>

 

return 0;

{{out}}

<pre>1 2 3 4 5 6 7 8 9 10 12 14 15 16 18 20 21 24 25 27 28 30 32 35 36 40 42 45 48 49 50 54 56 60 63 64 70 72 75 80 81 84 90 96 98 100 105 108 112 120

=={{header|C sharp|C#}}==

{{trans|D}}

using System.Collections.Generic;

 

}

}

{{out}}

<pre>1 2 3 4 5 6 7 8 9 10 12 14 15 16 18 20 21 24 25 27 28 30 32 35 36 40 42 45 48 49 50 54 56 60 63 64 70 72 75 80 81 84 90 96 98 100 105 108 112 120

1272 have 8 digits

1767 have 9 digits</pre>

 

=={{header|C++}}==

{{trans|Kotlin}}

#include <iostream>

#include <map>

 

return 0;

{{out}}

<pre>1 2 3 4 5 6 7 8 9 10 12 14 15 16 18 20 21 24 25 27 28 30 32 35 36 40 42 45 48 49 50 54 56 60 63 64 70 72 75 80 81 84 90 96 98 100 105 108 112 120

1272 have 8 digits

1767 have 9 digits</pre>

 

=={{header|Crystal}}==

===Brute force and slow===

{{trans|C++}}

return true if (i < 2)

return humble?(i // 2) if (i % 2 == 0)

 

print "\n\nOf the first #{count} humble numbers:\n"

{{out}}

<pre>1 2 3 4 5 6 7 8 9 10 12 14 15 16 18 20 21 24 25 27 28 30 32 35 36 40 42 45 48 49 50 54 56 60 63 64 70 72 75 80 81 84 90 96 98 100 105 108 112 120

2381 have 10 digits</pre>

 

{{trans|Zkl}}

 

def humble(digits)

i, j, k, l = 0, 0, 0, 0

(1..).each do |n|

break if x.to_s.size > digits

h << x

end

 

h = humble(digits) # humble numbers <= digits size

count = h.size # the total humble numbers count

print "First 50 Humble Numbers: \n"; (0...50).each { |i| print "#{h[i]} " }

print "\n\nOf the first #{count} humble numbers:\n"

{{out}}

<pre>First 50 Humble Numbers:

1 2 3 4 5 6 7 8 9 10 12 14 15 16 18 20 21 24 25 27 28 30 32 35 36 40 42 45 48 49 50 54 56 60 63 64 70 72 75 80 81 84 90 96 98 100 105 108 112 120

 

 

=={{header|D}}==

{{trans|C++}}

import std.stdio;

 

}

}

{{out}}

<pre>1 2 3 4 5 6 7 8 9 10 12 14 15 16 18 20 21 24 25 27 28 30 32 35 36 40 42 45 48 49 50 54 56 60 63 64 70 72 75 80 81 84 90 96 98 100 105 108 112 120

1272 have 8 digits

1767 have 9 digits</pre>

 

=={{header|Factor}}==

generalizations io kernel make math math.functions math.order

prettyprint sequences tools.memory.private ;

] tri ] time ;

 

{{out}}

<pre style="height:45ex">

Running time: 335.1803624581294 seconds

</pre>

 

=={{header|Go}}==

Not particularly fast and uses a lot of memory but easier to understand than the 'log' based methods for generating 7-smooth numbers.

 

import (

fmt.Printf("%9s have %2d digit%s\n", commatize(counts[i]), i, s)

}

 

{{out}}

 

=={{header|Haskell}}==

import Data.List.Split (chunksOf)

import Data.List (group)

------------------------- DISPLAY -------------------------

justifyRight :: Int -> a -> [a] -> [a]

{{Out}}

<pre>First 50 Humble numbers:

(24,29458)

(25,33188)</pre>

 

=={{header|J}}==

Multiply all the humble numbers by all the factors appending the next largest value.

humble=: 4 : 0

NB. x humble y generates x humble numbers based on factors y

end.

)

<pre>

p: i.4

 

Use a class to simulate the python generator. This is a more efficient implementation of the first method.

FACTORS_h_=: p: i. 4

HUMBLE_h_=: 1

)

reset_h_=: 3 :'0 $ HUMBLE=: 1'

<pre>

3 :0 [ 50 [ reset_h_''

 

=={{header|Java}}==

import java.math.BigInteger;

import java.util.ArrayList;

 

}

{{Out}}

<pre>

 

=={{header|JavaScript}}==

'use strict';

 

 

// humbles :: () -> [Int]

};

 

// main :: IO ()

const main = () => {

 

 

 

// chunksOf :: Int -> [a] -> [[a]]

xs.length - 1

).reduce(

[]

);

 

// compose (<<<) :: (b -> c) -> (a -> b) -> a -> c

const compose = (...fs) =>

 

// concat :: [[a]] -> [a]

return unit.concat.apply(unit, xs);

})() : [];

 

// enumFromThenTo :: Int -> Int -> Int -> [Int]

 

// enumFromTo :: Int -> Int -> [Int]

length: 1 + n - m

}, (_, i) => m + i);

 

// fTable :: String -> (a -> String) -> (b -> String)

).join('\n');

};

 

// fmapGen <$> :: (a -> b) -> Gen [a] -> Gen [b]

};

 

const group = xs => {

const go = xs =>

0 < xs.length ? (() => {

) : [xs];

})() : [];

};

 

// justifyRight :: Int -> Char -> String -> String

) : s;

 

 

// length :: [a] -> Int

const length = xs =>

(Array.isArray(xs) || 'string' === typeof xs) ? (

xs.length

) : Infinity;

 

xs

 

// str :: a -> String

 

// take :: Int -> [a] -> [a]

return x.done ? [] : [x.value];

}));

 

// takeWhileGen :: (a -> Bool) -> Gen [a] -> [a]

return ys;

};

 

// zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

 

// MAIN ---

return main();

{{Out}}

<pre>First 50 humble numbers:

9 -> 1767

10 -> 2381</pre>

 

=={{header|Julia}}==

To spare heap memory, keeps only the last 2 million values found for use in the generation of further values.

function counthumbledigits(maxdigits, returnsequencelength=50)

n, count, adjustindex, maxdiff = BigInt(1), 0, BigInt(0), 0

println(lpad(digitcounts[ndigits], 10), " have ", lpad(ndigits, 3), " digits.")

end

<pre>

828.693164 seconds (3.61 G allocations: 64.351 GiB, 51.37% gc time)

 

=={{header|Kotlin}}==

if (i <= 1) return true

if (i % 2 == 0) return isHumble(i / 2)

}

}

{{out}}

<pre>1 2 3 4 5 6 7 8 9 10 12 14 15 16 18 20 21 24 25 27 28 30 32 35 36 40 42 45 48 49 50 54 56 60 63 64 70 72 75 80 81 84 90 96 98 100 105 108 112 120

1272 have 8 digits

1767 have 9 digits</pre>

 

=={{header|Pascal}}==

float32 get wrong at 37 digits,->37 104925 instead of 104926<BR>

runtime: 2 x digits => ~ runtime 2^4 <BR>

{$IFDEF FPC}

{$MODE DELPHI}

first50;

GetDigitCounts(100);

{{out}}

<pre>1 2 3 4 5 6 7 8 9 10 12 14 15 16 18 20 21 24 25 27 28 30 32 35 36 40 42 45 48 49 50 54 56 60 63 64 70 72 75 80 81 84 90 96 98 100 105 108 112 120

 

=={{header|Perl}}==

use warnings;

use List::Util 'min';

printf "Digits: %2d - Count: %s\n", $digits++, $count;

$count = 1;

{{out}}

<pre style="height:20ex">1 2 3 4 5 6 7 8 9 10 12 14 15 16 18 20 21 24 25 27 28 30 32 35 36 40 42 45 48 49 50 54 56 60 63 64 70 72 75 80 81 84 90 96 98 100 105 108 112 120

 

=={{header|Phix}}==

{{trans|Julia}}

I felt pretty good about the performance of this, until I ran the Go version - humbled indeed!<br>

It will go all the way to 100 digits if you give it time (18 mins, on 64bit - 32bit runs out of memory after printing the 99th line)<br>

I also tried a log version (similar to [[Hamming_numbers#A_much_faster_logarithmic_version|Hamming_numbers]]) but inaccuracies with floor(h[n][LOG]) crept in quite early, at just 10 digits.