Magnanimous numbers: Difference between revisions

A magnanimous number is an integer where there is no place in the number where a + (plus sign) could be added between any two digits to give a non-prime sum.

 

 

 

 

=={{header|ALGOL W}}==

% find some Magnanimous numbers - numbers where inserting a "+" between %

% any two of the digits and evaluating the sum results in a prime number %

write( "Last magnanimous number found: ", mPos, " = ", lastM )

end

{{out}}

<pre>

486685 488489 515116 533176 551558 559952 595592 595598 600881 602081

Last magnanimous number found: 434 = 999994

</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f MAGNANIMOUS_NUMBERS.AWK

# converted from C

printf("\n")

}

{{out}}

<pre>

391-400: 486685 488489 515116 533176 551558 559952 595592 595598 600881 602081

</pre>

 

=={{header|C}}==

{{trans|Go}}

#include <string.h>

 

list_mags(391, 400, 1, 10);

return 0;

 

{{out}}

 

=={{header|C#|CSharp}}==

 

class Program {

if (c == 240) WriteLine ("\n\n241st through 250th{0}", mn);

if (c == 390) WriteLine ("\n\n391st through 400th{0}", mn); } }

 

{{out}}

 

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

#include <iostream>

 

std::cout << '\n';

return 0;

 

{{out}}

486685, 488489, 515116, 533176, 551558, 559952, 595592, 595598, 600881, 602081

</pre>

 

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

===The function===

This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_function Extensible Prime Generator (F#)]

// Generate Magnanimous numbers. Nigel Galloway: March 20th., 2020

let rec fN n g = match (g/n,g%n) with

|_ -> false

let Magnanimous = let Magnanimous = fN 10 in seq{yield! {0..9}; yield! Seq.initInfinite id |> Seq.skip 10 |> Seq.filter Magnanimous}

===The Tasks===

;First 45

 

Magnanimous |> Seq.take 45 |> Seq.iter (printf "%d "); printfn ""

{{out}}

<pre>

;Magnanimous[241] to Magnanimous[250]

 

Magnanimous |> Seq.skip 240 |> Seq.take 10 |> Seq.iter (printf "%d "); printfn "";;

{{out}}

<pre>

;Magnanimous[391] to Magnanimous[400]

 

Magnanimous |> Seq.skip 390 |> Seq.take 10 |> Seq.iter (printf "%d "); printfn "";;

{{out}}

<pre>

486685 488489 515116 533176 551558 559952 595592 595598 600881 602081

</pre>

=={{header|Factor}}==

{{trans|Julia}}

{{works with|Factor|0.99 2020-01-23}}

math.primes math.ranges prettyprint sequences ;

 

[ "241st through 250th magnanimous numbers" print 240 250 show ]

[ "391st through 400th magnanimous numbers" print 390 400 show ]

{{out}}

<pre>

486685 488489 515116 533176 551558 559952 595592 595598 600881 602081

</pre>

 

=={{header|Go}}==

 

import "fmt"

listMags(241, 250, 1, 10)

listMags(391, 400, 1, 10)

{{out}}

<pre>

391st through 400th magnanimous numbers:

486685 488489 515116 533176 551558 559952 595592 595598 600881 602081

</pre>

 

=={{header|Java}}==

import java.util.ArrayList;

import java.util.List;

 

}

 

{{out}}

486685 488489 515116 533176 551558 559952 595592 595598 600881 602081

</pre>

 

=={{header|Julia}}==

 

function ismagnanimous(n)

println("\n241st through 250th magnanimous numbers:\n", mag400[241:250])

println("\n391st through 400th magnanimous numbers:\n", mag400[391:400])

<pre>

First 45 magnanimous numbers:

391st through 400th magnanimous numbers:

[486685, 488489, 515116, 533176, 551558, 559952, 595592, 595598, 600881, 602081]

</pre>

 

{{trans|Raku}}

{{libheader|ntheory}}

use warnings;

use feature 'say';

 

say "\n391st through 400th magnanimous numbers\n".

{{out}}

<pre>First 45 magnanimous numbers

 

=={{header|Phix}}==

{{out}}

<pre>

magnanimous numbers[241..250]: {17992,19972,20209,20261,20861,22061,22201,22801,22885,24407}

magnanimous numbers[391..400]: {486685,488489,515116,533176,551558,559952,595592,595598,600881,602081}

</pre>

 

{{works with|Rakudo|2020.02}}

 

my int $last;

(1 ..^ .chars).map: -> \c { $last = 1 and last unless (.substr(0,c) + .substr(c)).is-prime }

 

put "\n391st through 400th magnanimous numbers";

{{out}}

<pre>First 45 magnanimous numbers

=={{header|REXX}}==

The majority of the time consumed was in generating a list (sparse array) of suitable primes.

<br>The '''magna''' function (magnanimous) was quite simple to code and pretty fast, it includes the 1^st and last digit parity test.

<br>By far, the most CPU time was in the generation of primes.

parse arg bet.1 bet.2 bet.3 highP . /*obtain optional arguments from the CL*/

if bet.1=='' | bet.1=="," then bet.1= 1..45 /* " " " " " " */

if HI=='' then HI= LO /*Just a single number? Then use LO. */

if HI==0 then iterate /*Is HI a zero? Then skip this range.*/

say

say strip($)

end /*j*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

magna: procedure expose @. !.; parse arg x 1 L 2 '' -1 R /*obtain #, 1st & last digit.*/

return 1 /*Pass all the tests, it's magnanimous.*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

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

<pre>

 

=={{header|Ring}}==

load "stdlib.ring"

n = -1

txt = txt + "]"

see txt

<pre>

Magnanimous numbers 1-45:

[17992,19972,20209,20261,20861,22061,22201,22801,22885,24407]

</pre>

=={{header|Ruby}}==

{{trans|Sidef}}

 

magnanimouses = Enumerator.new do |y|

puts "\n391st through 400th magnanimous numbers:"

puts magnanimouses.first(400).last(10).join(' ')

{{out}}

<pre>First 45 magnanimous numbers:

 

=={{header|Rust}}==

if n < 2 {

return false;

}

println!();

 

{{out}}

486685 488489 515116 533176 551558 559952 595592 595598 600881 602081

</pre>

 

=={{header|Sidef}}==

1..n.ilog10 -> all {|k|

sum(divmod(n, k.ipow10)).is_prime

 

say "\n391st through 400th magnanimous numbers:"

{{out}}

<pre>

=={{header|Swift}}==

{{trans|Rust}}

 

func isPrime(_ n: Int) -> Bool {

print(n, terminator: " ")

}

 

{{out}}

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

{{trans|C#}}

 

Module Module1

End If : l += 1 : End While

End Sub

{{out}}

<pre>First 45 magnanimous numbers:

{{libheader|Wren-math}}

{{trans|Go}}

var isMagnanimous = Fn.new { |n|

listMags.call(1, 45, 3, 15)

listMags.call(241, 250, 1, 10)

 

{{out}}

486685 488489 515116 533176 551558 559952 595592 595598 600881 602081

</pre>