Wie erkennt man, welche Regex-Übereinstimmungen Primzahlen sind?

Question

Ich habe eine Textdatei und eine Regex, die alle Zahlen extrahiert, die im gesamten Text geschrieben werden. Ich bin in der Lage, die Zahlen zu vergleichen und zu extrahieren, aber ich habe Mühe, herauszufinden, welche extrahierten Zahlen prim sind.

Kann mir jemand helfen? Vielen Dank!

Hier ist mein Code:

import java.util.Scanner;//Import Scanner class to read a file in the computer 
import java.io.File;//Import File class to read a file in the computer 
import java.io.FileNotFoundException;//Import FileNotFoundException class if case file is not found in the computer 

import java.util.regex.Matcher; 
import java.util.regex.Pattern; 

public class Regex2 { 
    public static void main(String[] args) throws FileNotFoundException {   
     int count = 0; 
     //Display each word in INPUT_TEXT 
     Scanner INPUT_TEXT = new Scanner(new File("/Users/Matt/Desktop/regex2.csv"));//Create a Scanner Class and File Class to read a file from your computer. 

     INPUT_TEXT.useDelimiter(" ");//Divide file into several pieces by a space 
     if (INPUT_TEXT != null) { 
      System.out.println(INPUT_TEXT); 
     } 

     while(INPUT_TEXT.hasNext()) { 
      //Read each word 
      String TempString = INPUT_TEXT.next(); 
      //Display all numbers.Eliminate comma, e.g., 1,200 -> 1200 
      String temp1 = TempString.replaceAll("[\\,]", "");//Create a String class temp1 that eliminates comma. 
      String pattern1 = "[0-9]+";//Create a String class pattern1 that stores the Regular Expression to match numbers. 

      Pattern r1 = Pattern.compile(pattern1);//Create Pattern class to compile pattern1. 

      Matcher m1 = r1.matcher(temp1);//Match each piece with the Regular Expression 

      if (m1.find()) { 
       System.out.print(m1.group() + " "); 
       //System.out.println(count); 
       count++; 
      // if count reaches 5, reset count and print new line 
      if (count == 5) { 
       count = 0; 
       System.out.println(); 
      } 
     } 
    } 
    INPUT_TEXT.close();//Close your Scanner. 
    } 
} 

Answer 1

beziehen Also ja, alles, was ich tun musste, war ein weiteres „isPrime“ Methode hinzufügen. Obwohl ich jede Übereinstimmung zu einer Array-Liste hinzugefügt habe, glaube ich, dass Sie auch die Gruppe (0) zu Integer analysieren und jeden Wert so testen könnten.

Hier ist mein Code:

import java.util.Scanner;//Import Scanner class to read a file in the computer 
import java.io.File;//Import File class to read a file in the computer 
import java.io.FileNotFoundException;//Import FileNotFoundException class if case file is not found in the computer 

import java.util.regex.Matcher; 
import java.util.regex.Pattern; 
import java.util.*; // Import all java utilities 


public class assignmentTwo { 
    public static ArrayList<Integer> nums; 

    public static void main(String[] args) throws FileNotFoundException{ 

     int count = 0; 


     //Display each word in INPUT_TEXT 
     Scanner INPUT_TEXT = new Scanner(new File("/Users/Matt/Desktop/assignment2.csv"));//Create a Scanner Class and File Class to read a file from your computer. 


     INPUT_TEXT.useDelimiter(" ");//Divide DemoData.txt into several pieces by a space 

     // test to see if file was received 
     if (INPUT_TEXT != null) { 

      System.out.println(INPUT_TEXT); 

     } 


     while(INPUT_TEXT.hasNext()){ 


      //Read each word 
      String TempString = INPUT_TEXT.next(); 

      //Display all numbers.Eliminate comma, e.g., 1,200 -> 1200 
      String temp1 = TempString.replaceAll("[\\,]", "");//Create a String class temp1 that eliminates comma. 
      String pattern1 = "[0-9]+";//Create a String class pattern1 that stores the Regular Expression to match numbers. 
      Pattern r1 = Pattern.compile(pattern1);//Create Pattern class to compile pattern1. 
      Matcher m1 = r1.matcher(temp1);//Match each piece with the Regular Expression 


      // array variable 
      nums = new ArrayList<Integer>(); 

      // find values that match 
      if (m1.find()) { 

      // parse array values from string to integers 
      int parsedNum = Integer.parseInt(m1.group()); 
      nums.add(parsedNum); 


      //If a number is matched, print the number. 
      System.out.print(m1.group() + " "); 

      // increment counter when number validation is reached 
      count++; 


      // if count reaches 5, reset count and print new line 
      if (count == 5) { 

      count = 0; 

      System.out.println(); 



    } 

    // run isPrime method 
    isPrime(); 

} 

    } 

     INPUT_TEXT.close();//Close your Scanner. 

    } 

    // isPrime method to test which #s are prime 
    public static int isPrime(){ 

     // finds size of array 
     for(int s = 0; s < nums.size(); s++){ 

      // primeNum is true by default 
      boolean primeNum = true; 

      /* if a value from the array is divisible by any # <= array value 
       then that value is not prime */ 
      for (int divisor = 2; divisor <= nums.get(s)/2; divisor++) { 
       if (nums.get(s) % divisor == 0) { 

        primeNum = false; 

       } 

      } 
       // if value is prime, print out current value 
       if (primeNum) { 

        //System.out.println(); 
        System.out.print(nums.get(s) + " "); 

        // return array list values 
        return nums.get(s); 

       } 

     } 

     // exit status 
     return 0; 
    }  
} 

Answer 2

Sie völlig den Posten falsch verstanden haben Sie verknüpft. Es sieht so aus, als hätten Sie eine Zeichenfolge, die eine Zahl darstellt, und Sie denken, dass Sie eine Regex verwenden können, um festzustellen, ob es sich um eine Primzahl handelt. Das ist völlig unmöglich.

Der Pfosten hat gezeigt, wie zu testen, ob n durch Prime ist ein String der Länge n, und passende es gegen einen regulären Ausdruck zu schaffen, die nur übereinstimmt, wenn die Zeichenfolge nach unten in 2 oder mehreren Gruppen von gleicher Länge und Länge gebrochen werden kann > = 2. Wenn es geht, dann kann die Zahl nicht prim sein, weil sie das Produkt von zwei Zahlen> = 2 sein muss. Dies ist ein sehr schlechter Weg, um auf Primalität zu testen. Es dient nur dazu, einige Leute ihre Klugheit zeigen zu lassen.

Auch wenn Sie eine Reihe von dieser Länge erstellen täte, würde der Code nicht funktioniert, weil Sie verwenden find(), die, wenn jeder Teilkette Ihrer Quellstring Matches erfolgreich sein wird. Dies wird nicht funktionieren. Der Trick funktioniert nur, wenn der Matcher gezwungen ist, den gesamten Quellstring zu finden.

Answer 3

Wenn Sie mit unary Format einer Nummer in Ordnung sind.

Sie zu diesem link