Primes - allocate descendants to their ancestors: Difference between revisions

Total Descendants 546.986

</pre>

 

=={{header|AutoHotkey}}==

 

I seem that the use of an associative array is a little bit slower than the use of a simple array combined with the 'Sort' command, even if the 'Sort' command pumps 85% of the processing time.

#SingleInstance force

#NoEnv ; Recommended for performance and compatibility with future AutoHotkey releases.

return lPrimes

 

=={{header|C}}==

 

The InsertChild function is replaced by the AppendChild function which appends directly the child as the new last item in the list.

#include <stdio.h>

#include <stdlib.h>

 

return Index;

 

=== Optimized Approach ===

 

It is based on the same logic as the Python script.

#include <stdio.h>

#include <stdlib.h>

 

return Index;

 

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

#include <iostream>

#include <vector>

std::cout << "Total descendants: " << total_descendants << '\n';

return 0;

 

{{out}}

=={{header|Go}}==

{{trans|Python}}

 

import (

}

fmt.Println("\nTotal descendants", total)

 

{{out}}

Total descendants 546986

</pre>

 

=={{header|J}}==

===Implementation I===

 

 

family=:3 :0 M.

)

 

If you want to inspect individual results, that's fairly straightforward.

=== Some examples ===

 

546986

level 46

8 6 5

#descendants 18

 

===Implementation II===

Furthermore, the script produces the full report in a '.txt' file which can easily be compared with the output of some of the other languages. In Windows : <code>fc /N /L</code>

 

dd=: (<(>y{dd),y)y}dd

y getproducts"0 >:i.maxsum-y

 

file=: jpath '~user/temp/Ancestors.ijs.txt'

 

=={{header|Java}}==

{{Trans|C++}}

import java.util.*;

 

writer.write("\n");

}

 

{{out}}

Total descendants: 546986

</pre>

 

=={{header|Julia}}==

{{trans|Go}}

 

function ancestraldecendants(maxsum)

 

ancestraldecendants(99)

1: 0 Ancestor(s):Int64[] 0 Descendant(s): Int64[]

2: 0 Ancestor(s):Int64[] 0 Descendant(s): Int64[]

</pre>

=== A remake ===

aprimes = primes(maxsum)

ancestors = [Vector{Int}() for _ in 1:maxsum]

foreach(

s -> append!(descendants[s + p], [p * pr for pr in descendants[s]]),

)

end

total = 0

for s in 1:maxsum

)

)

end

end

{{output}}

<pre>

</pre>

 

=={{header|Kotlin}}==

{{trans|Python}}

 

const val MAXSUM = 99

 

println("\nTotal descendants $total")

 

{{out}}

=={{header|Nim}}==

{{trans|Python}}

 

const MaxSum = 99

inc total, dlength

 

 

{{out}}

{{trans|Raku}}

{{libheader|ntheory}}

use ntheory qw(nth_prime);

 

 

map { for my $k (keys %{$tree{$_}{descendants}}) { $total += $tree{$_}{descendants}{$k} } } 1..$max;

{{out}}

<pre> 1, 0 Ancestors: [], 0 Descendants: []

=={{header|Phix}}==

{{trans|Go}}

{{out}}

<pre>

 

Total descendants 546986

"16 days, 2 hours, 2 minutes and 45s"

</pre>

=={{header|Python}}==

Python is very flexible, concise and effective with lists.

from itertools import takewhile

 

total += len(descendants[s])

 

 

=={{header|Racket}}==

We first define a macro to create memorized functions and a few auxiliary functions. In particular <code>(border list)</code> transforms a long list in a list with ellipsis.

 

 

(define-syntax-rule (define/mem (name args ...) body ...)

(define (add-tail list x)

 

The main part of the program uses the memorized functions.

 

(if (= x 1)

#f

(define (total-descendants n)

(for/sum ([x (in-range 1 (add1 n))])

 

Now we display some results.

 

(show-info x))

(for ([x (in-range 1 (add1 15))])

(newline)

(printf "Total ancestors up to 99: ~a\n" (total-ancestors 99))

 

{{out}}

{{works with|Rakudo|2018.11}}

 

my %tree;

%tree{$_}<ancestor> = ();

%tree{$_}<descendants> = {};

 

say "\nTotal descendants: ",

{{out}}

<pre> 1, 0 Ancestors: [], 0 Descendants: []

=={{header|Sidef}}==

{{trans|Go}}

var primes = maxsum.primes

 

var idx = descendants[s].first_index {|x| x > maxsum }

 

ancestors[d] = (ancestors[s] + [s])

}

}

 

{{out}}

<pre>

=={{header|Simula}}==

{{trans|Python}}

BEGIN

OUTINT(TOTAL, 0);

OUTIMAGE;

{{out}}

<pre>[1] LEVEL: 0

=={{header|Visual Basic .NET}}==

It is based on the same logic as the Python script.

 

Module Module1

Return vbTrue

End Function

 

=={{header|Wren}}==

{{libheader|Wren-sort}}

{{libheader|Wren-fmt}}

 

var maxSum = 99

}

}

 

{{out}}

{{trans|Racket}}

Using [[Extensible prime generator#zkl]]

primes:=Utils.Generator(Import("sieve.zkl").postponed_sieve)

}

println("Total ancestors: %,d".fmt(ta));

{{out}}

<pre>