Untouchable numbers: Difference between revisions

 

;Observations and conjectures:

 

No untouchable number is perfect.

:*   Wikipedia: [https://en.wikipedia.org/wiki/Goldbach%27s_conjecture Goldbach's conjecture].

<br><br>

 

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

This solution implements [[Talk:Untouchable_numbers#Nice_recursive_solution]]

===The Function===

// Untouchable Numbers : Nigel Galloway - March 4th., 2021;

#include <functional>

}

};

===The Task===

;Less than 2000

int main(int argc, char *argv[]) {

int c{0}; auto n{uT{2000}}; for(auto g=n.nxt(0); g; g=n.nxt(*g+1)){if(c++==30){c=1; printf("\n");} printf("%4d ",*g);} printf("\n");

}

{{out}}

<pre>

</pre>

;Count less than or equal 100000

int main(int argc, char *argv[]) {

int z{100000}; auto n{uT{z}}; cout<<"untouchables below "<<z<<"->"<<n.count()<<endl;

}

{{out}}

<pre>

</pre>

;Count less than or equal 1000000

int main(int argc, char *argv[]) {

int z{1000000}; auto n{uT{z}}; cout<<"untouchables below "<<z<<"->"<<n.count()<<endl;

}

{{out}}

<pre>

</pre>

;Count less than or equal 2000000

int main(int argc, char *argv[]) {

int z{2000000}; auto n{uT{z}}; cout<<"untouchables below "<<z<<"->"<<n.count()<<endl;

}

{{out}}

<pre>

real 11m28.031s

</pre>

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

{{Trans|Go}}

program Untouchable_numbers;

 

writeln(cu:7, ' untouchable numbers were found <= ', cl);

readln;

 

=={{header|F_Sharp|F#}}==

This task uses [[Extensible_prime_generator#The_functions|Extensible Prime Generator (F#)]].<br>

It implements [[Talk:Untouchable_numbers#Nice_recursive_solution]]

// Applied dendrology. Nigel Galloway: February 15., 2021

let uT a=let N,G=Array.create(a+1) true, [|yield! primes64()|>Seq.takeWhile((>)(int64 a))|]

|_->N.[0]<-false; N

fL (fG 1L 0L 0) [fN 1L 0L 1]

===The Task===

;Less than 2000

uT 2000|>Array.mapi(fun n g->(n,g))|>Array.filter(fun(_,n)->n)|>Array.chunkBySize 30|>Array.iter(fun n->n|>Array.iter(fst>>printf "%5d");printfn "")

{{out}}

<pre>

</pre>

;Count less than or equal 100000

printfn "%d" (uT 100000|>Array.filter id|>Array.length)

{{out}}

<pre>

</pre>

;Count less than or equal 1000000

printfn "%d" (uT 1000000|>Array.filter id|>Array.length)

{{out}}

<pre>

</pre>

;Count less than or equal 2000000

printfn "%d" (uT 2000000|>Array.filter id|>Array.length)

{{out}}

<pre>

</pre>

;Count less than or equal 3000000

printfn "%d" (uT 3000000|>Array.filter id|>Array.length)

{{out}}

<pre>

 

=={{header|Go}}==

 

import "fmt"

cl := commatize(limit)

fmt.Printf("%7s untouchable numbers were found <= %s\n", cu, cl)

 

{{out}}

13,863 untouchable numbers were found <= 100,000

150,232 untouchable numbers were found <= 1,000,000

</pre>

 

=={{header|J}}==

factor=: 3 : 0 NB. explicit

'primes powers'=. __&q: y

candidates=: 5 , [: +: [: #\@i. >.@-: NB. within considered range, all but one candidate are even.

spds=:([:sum_of_proper_divisors"0(#\@i.-.i.&.:(p:inv))@*:)f. NB. remove primes which contribute 1

We may revisit to correct the larger untouchable tallies. The straightforward algorithm presented is a little bit efficient, and, I claim, the verb <tt>(candidates-.spds)</tt> produces the full list of untouchable numbers up to its argument. It considers the sum of proper divisors through the argument squared, less primes. Since J is an algorithm description language, it may be "fairer" to state in J that "more resources required" than in some other language. [https://www.eecg.utoronto.ca/~jzhu/csc326/readings/iverson.pdf]

 

but the 512,000,000 sieved below is just from doubling 1,000,000 and running the sieve until we get 150232 for the number

of untouchables under 1,000,000.

 

function properfactorsum(n)

println("The count of untouchable numbers ≤ $N is: ", count(x -> untouchables[x], 1:N))

end

<pre>

The untouchable numbers ≤ 2000 are:

The count of untouchable numbers ≤ 1000000 is: 150232

</pre>

 

=={{header|Nim}}==

 

const

if lim == Lim1:

# Emit last message.

 

{{out}}

There are 1212 untouchable numbers ≤ 10000.

There are 13863 untouchable numbers ≤ 100000.</pre>

 

=={{header|Perl}}==

{{libheader|ntheory}}

use warnings;

use enum qw(False True);

printf($fmt, scalar @untouchable, $limit) and last if $limit == ($p *= 10)

}

{{out}}

<pre>Number of untouchable numbers ≤ 2000 : 196

 

=={{header|Phix}}==

{{out}}

<pre>

Borrow the proper divisors routine from [https://rosettacode.org/wiki/Proper_divisors#Raku here].

{{trans|Wren}}

 

sub propdiv (\x) {

}

}

{{out}}

<pre>

 

This version of REXX would need a 64-bit version to calculate the number of untouchable numbers for one million.

parse arg n cols tens over . /*obtain optional arguments from the CL*/

if n='' | n=="," then n=2000 /*Not specified? Then use the default.*/

end /*m*/ /* [↑] process an even integer. ___*/

if q.m==j then return s + m /*Was J a square? If so, add √ J */

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Wren}}==

{{libheader|Wren-math}}

{{libheader|Wren-fmt}}

Not an easy task as, even allowing for the prime tests, it's difficult to know how far you need to sieve to get the right answers. The parameters here were found by trial and error.

 

var sieve = Fn.new { |n|

 

System.print("List of untouchable numbers <= 2,000:")

System.print()

Fmt.print("$,6d untouchable numbers were found <= 2,000", untouchable.count { |n| n <= 2000 })

}

}

 

{{out}}

1,212 untouchable numbers were found <= 10,000

13,863 untouchable numbers were found <= 100,000

</pre>