Programmieren lernen

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");
                

Lösung von: Jens Kelm (@JKooP)

// C++ 17

#include <iostream>
#include <vector>

bool is_prime(int n) {
    if (n == 0 || n == 1) return false;
    if (n == 2) return true;
    for (auto i{ 2 }; i <= (int)ceil(sqrt(n)); i++)
        if (n % i == 0) return false;
    return true;
}

void reverse_number(int& n) {
    if (n % 10 == n) return;
    auto z{ 0 };
    while (n > 0) {
        auto r{ n % 10 };
        n /= 10;
        z = z * 10 + r;
    }
    n = z;
}

std::vector<int> get_emirps(int max) {
    std::vector<int>v;
    for (auto i{ 11 }; i <= max; i+=2) {
        auto k{ i };
        reverse_number(k);
        if (is_prime(i) && is_prime(k))
            v.push_back(i);
    }
    return v;
}

void print(std::vector<int> emirps) {
    for (const auto& mirp : emirps)
        std::cout << mirp << " ist eime Mirp-Zahl\n";
}

int main() {
    print(get_emirps(1000));
}
                

Lösung von: Jens Kelm (@JKooP)

sieb=L=[i for i in range(2,1000)]
for a in range(2,len(L)):
        for b in sieb: sieb.remove(b) if b!=a and b%a==0 else None
for a in sieb: print(a) if int(str(a)[::-1])!=a and int(str(a)[::-1]) in sieb else None

                

Lösung von: rob ert (tub)

' VBA
Function IsPrime(ByVal n%)
    r = True
    Select Case n
        Case 0 To 1: r = False
        Case 2: r = True
        Case Else:
        For i% = 2 To CInt(WorksheetFunction.Ceiling(Sqr(n), 1))
            If n Mod i = 0 Then
                r = False
                Exit For
            End If
        Next
    End Select
    IsPrime = r
End Function

Sub ReverseNumber(ByRef n%)
    Dim z%
    Do While n > 0
        r% = n Mod 10
        n = n \ 10
        z = z * 10 + r
    Loop
    n = z
End Sub

Function GetEmirps(ByVal max%)
    Dim arr()
    Dim n%
    For i = 11 To max Step 2
        k% = i
        ReverseNumber k
        If IsPrime(i) And IsPrime(k) Then
            ReDim Preserve arr(n)
            arr(n) = i
            n = n + 1
        End If
    Next
    GetEmirps = arr
End Function

Sub PrintEmirps(arr)
    For Each a In arr
        Debug.Print a
    Next
End Sub

Sub Main()
    PrintEmirps GetEmirps(1000)
End Sub
                

Lösung von: Jens Kelm (@JKooP)

// C++20 | VS-2022

#include <iostream>
#include <vector>

inline static constexpr auto is_prime(auto&& num_) {
    if (num_ <= 3) return num_ > 1;
    else if (num_ % 2 == 0 || num_ % 3 == 0) return false;
    else {
        for (auto i{ 5 }; i * i < num_; i += 6)
            if (num_ % i == 0 || num_ % (i + 2) == 0) return false;
        return true;
    }
}

inline static constexpr auto reverse_number(auto&& num_) {
    if (num_ % 10 == num_) return;
    auto z{ 0 };
    while (num_) {
        auto r{ num_ % 10 };
        num_ /= 10;
        z = z * 10 + r;
    }
    num_ = z;
}

inline static constexpr auto get_emirps(auto&& max_) {
    std::vector<size_t>out;
    for (auto i{ 11 }; i <= max_; i += 2) {
        if (is_prime(i)) {
            auto k{ i };
            reverse_number(k);
            if(is_prime(k))
                out.push_back(i);
        }
    }
    return out;
}

void print(auto&& emirps_) {
    for (const auto& mirp : emirps_)
        std::cout << mirp << " ist eime Mirp-Zahl\n";
}

int main() {
    print(get_emirps(1000));
}
                

Lösung von: Jens Kelm (@JKooP)