mirP-Zahlen - Programmieraufgaben.ch

mirP-Zahlen (Unterprogramme)

Eine Mirp-Zahl ist eine Primzahl, die rückwärtsgelesen eine andere Primzahl ergibt. (Mirp = "Prim" rückwärts gelesen.)

Schreiben Sie ein Programm, das alle Mirp-Zahlen bis 1000 ausgibt.

0 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

public class MirpZahlen {

	public static void main(String[] args) {
		new MirpZahlen().top();
	}


	void top() {
		for(int i = 1; i <= 1000; i++) {
			if(istMirp(i)) {
				System.out.println(i + " ist eine Mirp-Zahl.");
			}
		}
	}

	boolean istMirp(int zahl) {
		if(! istPrim(zahl)) {
			return false;
		}
		int lahz = umkehren(zahl);
		return istPrim(lahz) && zahl != lahz;
	}

	int umkehren(int zahl) {
		int umk = 0;
		while(zahl > 0) {
			int einer = zahl % 10;
			umk = umk * 10 + einer;
			zahl = zahl / 10;
		}
		return umk;
	}

	boolean istPrim(int zahl) {
		if(zahl < 2) return false;
		if(zahl < 4) return true;
		for(int i = 2; i < Math.sqrt(zahl + 1); i++) {
			if(0 == zahl % i) {
				return false;
			}
		}
		return true;
	}

}

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

i = 2
lst = []
while i <= 1000:
    primzahl = True
    m = 1
    while i >= m:
        if i % m == 0 and m != 1 and m != i:
            primzahl = None
            m = i
        else:
            m += 1
    if primzahl == True:
        mirpzahl = True
        a = str(i)[::-1]
        a = int(a)
        s = 1
        while s < a:
            if a == i or a % s == 0 and s != 1 and s != a:
                mirpzahl = None
                s = a
            else:
                s += 1
        if mirpzahl == True:
            lst.append(a)
            i += 1
        else:
            i += 1
    else:
        i += 1
x = sorted(lst)
for c in range(len(lst)):
    print(x[c], "ist eine Mirp-Zahl")

Lösung von: Sergej ;) (TU Dortmund)

from math import sqrt

def is_prim(zahl):
    for i in range(2, int(sqrt(zahl))+1):
        if zahl%i == 0:
            return False
    return True

mirp_zahlen = [i for i in range(2, 1001) if is_prim(i) and is_prim(int(str(i)[::-1]))]
for zahl in mirp_zahlen:
    print(zahl, "ist eine Mirp-Zahl.")

Lösung von: Karl Welzel ()

object MIRP extends App {
	def isPrime(num: Int) = !(2 to math.sqrt(num).toInt).exists(num % _ == 0)

  	val mirpIter = Iterator.iterate(2)(
  		n => Iterator.from(n + 1).find(x => isPrime(x) && isPrime(x.toString.reverse.toInt)).get
  	)

  	println(mirpIter.takeWhile(_ < 1000).toList)
}

Lösung von: Name nicht veröffentlicht

#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <math.h>
#include <stdlib.h>

bool is_prim( uint64_t n );
uint64_t reverse_number( uint64_t n );
bool is_mirp( uint64_t n );

int main()
{
  
  uint64_t i;
  for( i = 1; i <= 1000; ++i )
  {
      if( is_mirp( i ) )
          printf( "%ld\n", i );
  }
  
  return EXIT_SUCCESS;
  
}

bool is_prim( uint64_t n )
{
  
  uint64_t i;
  
  if( n < 2 ) return false;
  if( n == 2 ) return true;
  if( n % 2 == 0 ) return false;
  
  for( i = 3; i <= (uint64_t)sqrt(n); i += 2 )
  {
    if( n % i == 0 ) return false;
  }
  
  return true;
  
}

uint64_t reverse_number( uint64_t n )
{
  
  if( n == 0 ) return 0;
  
  uint64_t i;
  uint64_t sum;
  uint64_t pot;
  uint64_t l = (uint64_t)log10( n );
  
  pot = pow(10, l);
  sum = 0;
  for( i = l; i > 0; --i )
  {
    sum += (n % 10) * pot;
    n /= 10;
    pot /= 10;
  }
  sum += n;
  
  return sum;
  
}

bool is_mirp( uint64_t n )
{
  
  if( ! is_prim( n ) ) return false;
  uint64_t rn = reverse_number( n );
  return rn != n && is_prim( rn );
  
}

Lösung von: reeman :3 (TU Ilmenau)

var i = 10,
    emirps = [];

function isEmirp(num) {
   var arr = [];
   function isPrime(x) {
      var j = 2;
       for (j; j <= Math.floor(x/2); j++)
         if (x % j == 0) return false;
       return true;
   }
   if (isPrime(num)) {
      arr = num.toString().split("").reverse();
      if (isPrime(parseInt(arr.join("")))) return true;
      return false;
   }
}

for (i; i <= 1000; i++) {
   if (isEmirp(i)) emirps.push(i);
}
console.log(emirps.join(", "));

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

import math

def probedivision(n):
	grenze = int(math.sqrt(n))
	for i in range(2, grenze+1):
		if n % i == 0:
			return False
			break #Abbruch, sobald ein Teiler gefunden wurde
	return True

def umdrehen(n):
	zahlenstring = str(n)
	spiegelstring = zahlenstring[::-1]
	return int(spiegelstring)
	
def palindrom(n):
	if n == umdrehen(n):
		return True
	else:
		return False
	
def mirp_zahl(n):
	if probedivision(n) and probedivision(umdrehen(n)) and not palindrom(n):
		return True
	else:
		return False

#Ausgabe aller Mirp-Zahlen unter 1000
for i in range(2,1000):
	if mirp_zahl(i):
		print(i)

Lösung von: Matthias Richter (BIP Kreativitätsgymnasium, Leipzig)

// NET 6.x | C# 10.x | VS-2022

// Variante 1(kurz und knapp, aber extrem langsam)
static bool IsPrime(int n) => n > 1 && Enumerable.Range(1, n).Where(x => n % x == 0).SequenceEqual(new[] { 1, n });
IEnumerable<int> GetEmirp(int max) => Enumerable.Range(1, max).Where(x => IsPrime(x) && IsPrime(int.Parse(new string(x.ToString().Reverse().ToArray())))).ToList();
GetEmirp(1_000).ToList().ForEach(x => Console.WriteLine($"{x} ist eine Mirp-Zahl"));

// Variante 2 (wenn es mal schnell gehen soll...)
static bool IsPrime2(int n)
{
    if (n == 0 || n == 1) return false;
    if (n == 2) return true;
    for (int i = 2; i <= (int)Math.Ceiling(Math.Sqrt(n)); i++)
        if (n % i == 0) return false;
    return true;
}

static int ReverseNumber2(int n)
{
    if (n % 10 == n) return n;
    var z = 0;
    while (n > 0)
    {
        var r = n % 10;
        n /= 10;
        z = z * 10 + r;
    }
    return z;
}

IEnumerable<int> GetEmirp2(int max)
{
    for (var i = 11; i <= max; i += 2)
    {
        if (IsPrime2(i) && IsPrime2(ReverseNumber2(i)))
            yield return i;
    }
}

foreach (var mirp in GetEmirp2(1_000))
    Console.WriteLine($"{mirp} ist eine Mirp-Zahl");