Magnanimous numbers: Difference between revisions

=={{header|ALGOL 68}}==

# digits ab=nd evaluatinf the sum results in a prime in all cases #

# returns the first n magnanimous numbers #

print magnanimous( m, 241, 250, "Magnanimous numbers 241-250" );

print magnanimous( m, 391, 400, "Magnanimous numbers 391-400" )

{{out}}

<pre>

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

=={{header|AWK}}==

# syntax: GAWK -f MAGNANIMOUS_NUMBERS.AWK

# converted from C

printf("\n")

}

{{out}}

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

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

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

=={{header|FreeBASIC}}==

#include "isprime.bas"

print i+1,magn(i)

next i

{{out}}

<pre>1 0

=={{header|Go}}==

import "fmt"

listMags(241, 250, 1, 10)

listMags(391, 400, 1, 10)

{{out}}

=={{header|Haskell}}==

import Data.List ( (!!) )

putStrLn "391'st to 400th magnanimous numbers:"

putStr $ show ( numbers !! 390 )

{{out}}

<pre>First 45 magnanimous numbers:

=={{header|Java}}==

import java.util.ArrayList;

import java.util.List;

}

{{out}}

'''Preliminaries'''

def power($b): . as $in | reduce range(0;$b) as $i (1; . * $in);

def divrem($x; $y):

[$x/$y|floor, $x % $y];

'''The Task'''

def ismagnanimous:

. as $n

| "First 45 magnanimous numbers:", .[:45],

"\n241st through 250th magnanimous numbers:", .[241:251],

{{out}}

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

=={{header|Mathematica}}/{{header|Wolfram Language}}==

MagnanimousNumberQ[Alternatives @@ Range[0, 9]] = True;

MagnanimousNumberQ[n_Integer] := AllTrue[Range[IntegerLength[n] - 1], PrimeQ[Total[FromDigits /@ TakeDrop[IntegerDigits[n], #]]] &]

sel[[;; 45]]

sel[[241 ;; 250]]

{{out}}

<pre>{0,1,2,3,4,5,6,7,8,9,11,12,14,16,20,21,23,25,29,30,32,34,38,41,43,47,49,50,52,56,58,61,65,67,70,74,76,83,85,89,92,94,98,101,110}

=={{header|Nim}}==

if n < 2: return

if n mod 2 == 0: return n == 2

elif i > 400:

{{out}}

Eliminating all numbers, which would sum to 5 in the last digit.<br>

On TIO.RUN found all til 569 84448000009 0.715 s

//Magnanimous Numbers

//algorithm find only numbers where all digits are even except the last

readln;

{$ENDIF}

{{out}}

<pre style="height:180px">

{{trans|Raku}}

{{libheader|ntheory}}

use warnings;

use feature 'say';

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

{{out}}

<pre>First 45 magnanimous numbers

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">magnanimous</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"magnanimous numbers[241..250]: %v\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">mag</span><span style="color: #0000FF;">[</span><span style="color: #000000;">241</span><span style="color: #0000FF;">..</span><span style="color: #000000;">250</span><span style="color: #0000FF;">]})</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"magnanimous numbers[391..400]: %v\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">mag</span><span style="color: #0000FF;">[</span><span style="color: #000000;">391</span><span style="color: #0000FF;">..</span><span style="color: #000000;">400</span><span style="color: #0000FF;">]})</span>

{{out}}

<pre>

=={{header|PicoLisp}}==

(let M 1

(loop

(println (head 45 Lst))

(println (head 10 (nth Lst 241)))

{{out}}

<pre>

This sample can be compiled with the original 8080 PL/M compiler and run under CP/M (or a clone/emulator).

<br>THe original 8080 PL/M only supports 8 and 16 bit quantities, so this only shows magnanimous numbers up to the 250th.

/* ANY TWO OF THE DIGITS AND EVALUATING THE SUM RESULTS IN A PRIME */

BDOS: PROCEDURE( FN, ARG ); /* CP/M BDOS SYSTEM CALL */

END;

CALL PRINT$NL;

{{out}}

<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

<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 /* " " " " " " */

end /*k*/ /* [↓] a prime (J) has been found. */

#= #+1; @.#= j; sq.#= j*j; !.j= 1 /*bump #Ps; P──►@.assign P; P^2; P flag*/

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

=={{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}}

=={{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}}

import "/math" for Int

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

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

{{out}}