Java实现1000以内组合素数判断-结合文件操作

最新推荐文章于 2024-03-21 14:32:53 发布
最新推荐文章于 2024-03-21 14:32:53 发布
阅读量622 收藏
点赞数 1
分类专栏： Java 文章标签： Java File Prime
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zp_icenow/article/details/81040790
版权
1万以内的所有素数判断这些素数中哪些是由素数拼接而成的。
    例如素数23就符合条件，23本身是素数，其由素数2，和素数3拼接（连接）组成。
    素数29就不满足条件，2是素数，而9不是素数。素数307不满足条件，不能忽略0. 

    7907这个素数符合条件，7是素数，907是素数。

该算法不但实现了判断输出基本功能，还实现了输出所有组合方式的功能。

至于算法中用到的prime.txt以及生成方法参见我的上一篇博文

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.ArrayDeque;
import java.util.Queue;

import com.zputil.*;

public class JoinPrime {
    private static Queue<Integer> queue = new ArrayDeque<>();


    public static void main(String[] args) throws Exception {
        int num = 0;
        File file = new File("prime.txt");
        if (file.exists() && file.isFile()) {
            System.out.println("找到该文件");

        } else {
            throw new Exception("找不到文件");
        }
        FileReader fileReader = new FileReader(file);
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        String ss = null;
        while ((ss = bufferedReader.readLine()) != null) {
            if (isJoinPrime(ss)) {

                System.out.print(ss + " : ");

                while (queue.size() != 0) {

                    if (queue.element() == -1) {
                        System.out.print("/");
                        queue.poll();
                    }
                    System.out.print(queue.poll() + " ");

                }
                System.out.println();
                num++;
            }
        }
        System.out.println("组合素数的个数为：" + num);

    }




    private static boolean isJoinPrime(String ss) {
        boolean b = false;
        switch (ss.length()) {
            case 1:
                break;
            case 2:
                if ((PrimeNum.isPrime(Integer.parseInt(ss.substring(0, 1)))) && (PrimeNum.isPrime(Integer.parseInt(ss.substring(1, 2)))) && (ss.indexOf('0') != 1)) {

                    queue.add(Integer.parseInt(ss.substring(0, 1)));
                    queue.add(Integer.parseInt(ss.substring(1, 2)));

                    b = true;

                }
                break;
            case 3:
                if ((PrimeNum.isPrime(Integer.parseInt(ss.substring(0, 1)))) && (PrimeNum.isPrime(Integer.parseInt(ss.substring(1, 2))))
                        && (PrimeNum.isPrime(Integer.parseInt(ss.substring(2, 3))))&& ((ss.indexOf('0')) == -1)) {
                    queue.add(Integer.parseInt(ss.substring(0, 1)));
                    queue.add(Integer.parseInt(ss.substring(1, 2)));
                    queue.add(Integer.parseInt(ss.substring(2, 3)));
                    if (b) queue.add(-1);
                    b = true;

                }
                if ((PrimeNum.isPrime(Integer.parseInt(ss.substring(0, 1)))) && (PrimeNum.isPrime(Integer.parseInt(ss.substring(1, 3))))
                        && (ss.indexOf('0') != 1)) {
                    if (b) queue.add(-1);
                    queue.add(Integer.parseInt(ss.substring(0, 1)));
                    queue.add(Integer.parseInt(ss.substring(1, 3)));
                    b = true;
                }
                if ((PrimeNum.isPrime(Integer.parseInt(ss.substring(0, 2)))) && (PrimeNum.isPrime(Integer.parseInt(ss.substring(2, 3))))
                        && (ss.indexOf('0') != 2)) {
                    if (b) queue.add(-1);
                    queue.add(Integer.parseInt(ss.substring(0, 2)));
                    queue.add(Integer.parseInt(ss.substring(2, 3)));
                    b = true;
                }
                break;
            case 4:
                if ((PrimeNum.isPrime(Integer.parseInt(ss.substring(0, 1)))) && (PrimeNum.isPrime(Integer.parseInt(ss.substring(1, 2))))
                        && (PrimeNum.isPrime(Integer.parseInt(ss.substring(2, 3))))&& (PrimeNum.isPrime(Integer.parseInt(ss.substring(3, 4))))&& ((ss.indexOf('0')) == -1)) {
                    queue.add(Integer.parseInt(ss.substring(0, 1)));
                    queue.add(Integer.parseInt(ss.substring(1, 2)));
                    queue.add(Integer.parseInt(ss.substring(2, 3)));
                    queue.add(Integer.parseInt(ss.substring(3, 4)));
                    b = true;

                }
                if ((PrimeNum.isPrime(Integer.parseInt(ss.substring(0, 2)))) && (PrimeNum.isPrime(Integer.parseInt(ss.substring(2, 3))))
                        && (PrimeNum.isPrime(Integer.parseInt(ss.substring(3, 4))))&& (ss.indexOf('0') != 2)&& (ss.indexOf('0') != 3)) {
                    if (b) queue.add(-1);
                    queue.add(Integer.parseInt(ss.substring(0, 2)));
                    queue.add(Integer.parseInt(ss.substring(2, 3)));
                    queue.add(Integer.parseInt(ss.substring(3, 4)));
                    b = true;
                }
                if ((PrimeNum.isPrime(Integer.parseInt(ss.substring(0, 1)))) && (PrimeNum.isPrime(Integer.parseInt(ss.substring(1, 3))))
                        && (PrimeNum.isPrime(Integer.parseInt(ss.substring(3, 4))))&& (ss.indexOf('0') != 1)&& (ss.indexOf('0') != 3)) {
                    if (b) queue.add(-1);
                    queue.add(Integer.parseInt(ss.substring(0, 1)));
                    queue.add(Integer.parseInt(ss.substring(1, 3)));
                    queue.add(Integer.parseInt(ss.substring(3, 4)));
                    b = true;
                }
                if ((PrimeNum.isPrime(Integer.parseInt(ss.substring(0, 1)))) && (PrimeNum.isPrime(Integer.parseInt(ss.substring(1, 2))))
                        && (PrimeNum.isPrime(Integer.parseInt(ss.substring(2, 4))))&& (ss.indexOf('0') != 2)&& (ss.indexOf('0') != 1)) {
                    if (b) queue.add(-1);
                    queue.add(Integer.parseInt(ss.substring(0, 1)));
                    queue.add(Integer.parseInt(ss.substring(1, 2)));
                    queue.add(Integer.parseInt(ss.substring(2, 4)));
                    b = true;
                }
                if ((PrimeNum.isPrime(Integer.parseInt(ss.substring(0, 3)))) && (PrimeNum.isPrime(Integer.parseInt(ss.substring(3, 4))))
                        && (ss.indexOf('0') != 3)) {
                    if (b) queue.add(-1);
                    queue.add(Integer.parseInt(ss.substring(0, 3)));
                    queue.add(Integer.parseInt(ss.substring(3, 4)));
                    b = true;
                }
                if ((PrimeNum.isPrime(Integer.parseInt(ss.substring(0, 1)))) && (PrimeNum.isPrime(Integer.parseInt(ss.substring(1, 4))))
                        && (ss.indexOf('0') != 1)) {
                    if (b) queue.add(-1);
                    queue.add(Integer.parseInt(ss.substring(0, 1)));
                    queue.add(Integer.parseInt(ss.substring(1, 4)));
                    b = true;
                }
                if ((PrimeNum.isPrime(Integer.parseInt(ss.substring(0, 2)))) && (PrimeNum.isPrime(Integer.parseInt(ss.substring(2, 4))))
                        && (ss.indexOf('0') != 2)) {
                    if (b) queue.add(-1);
                    queue.add(Integer.parseInt(ss.substring(0, 2)));
                    queue.add(Integer.parseInt(ss.substring(2, 4)));
                    b = true;
                }
                break;

        }
        return b;
    }
}

java的东西
weixin_43876829的博客
05-09 352
java ● 请你说一下多态 多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就...
java复习
最新发布
qq_48257021的博客
03-31 1130
将一个类声明为final，则可以将它的内容、属性和功能固定下来，与它的类名形成稳定的映射关系，从而保证引用这个类时所实现功能的正确无误。在使用中，接口类的变量可以用来代表任何实现了该接口的类的对象，这就相当于把类根据其实现的功能来分别代表，而不必顾虑它所在的类继承层次。机器语言和汇编语言几乎没有抽象，对于机器而言是最合适的描述，它可以直接操作机器的硬件，并且任何操作都是面向机器的，这就要求人们在使用机器语言或汇编语言编写程序时，必须按照机器的方式去思考问题。变量的作用域指可以访问该变量的程序代码范围。
1000以内质数的输出
03-26
public class Test public static void main String [] args { String str ""; for int i 1; i < 1000; i++ { for a 2; a < int i 2; a++ { if i % a 0 { break; } } if a > int i 2 { str+ String valueOf i +" " } } } System out println "1000以内的质数:"+str ; }">public class Test public static void main String [] args { String str ""; for int i 1; i < 1000; i++ { for a 2; a < int i 2; a++ { if i % a 0 { break; } [更多]
用java求1000之内的素数_java求1000以内的素数
weixin_39635567的博客
02-24 2473
.out.println("周长为:"+ bianChang*4); System.out.println("面积为:"+ bianChang*bianChang); } 11.编写一个方法来计算 1000 以内的素数之 和并输出。...Java编程JSP编程,显示字母表和100以内的素数的程序_理学_高等教育_教育专区。Java编程,JSP编程,显示字母表和100以内的素数,显示时间和九九乘法表...
Java判断1000以内的素数以及判断一个输入的数是不是素数的方法
qq_42700955的博客
05-03 1357
素数：除了能被一和本身整除不能被其它正数整除 /*所以判断一个数是不是素数只需要将比它小的数进行一个求余的计算， 如果结果为0--->说明它是被整除-->不是素数； 判断并输出1000以内的素数： package JavaBasis; public class JudgePrime { public static void main(String[] a...
java 求1000以内的所有素数
qq_40956679的博客
06-11 1万+
判断i是不是素数。 首先，当i=2时，i是素数，直接输出。 当i=3到i=1000，如果i被2到i-1的数整除，则i不是素数，不输出。否则输出。 public class PrimeNumber { public static void main(String[] args) { int i,j; for(i=1;i<=1000;i...
Java实现找出1000以内所有的素数
jasmyn518的博客
12-11 3408
找出1000以内的所有的素数： 具体代码如下： package com.jasmyn.demo; /** * 找出1000以内所有的素数 */ public class demo1 { public static void main(String[] args) { // TODO Auto-generated method stub int i,n; for(n=1;n<=1000;n++) { i=2; while(i<n&&n%i!=0)
Java50道经典题目
06-23
### Java50道经典题目知识点解析 #### 1. 斐波那契数列 - **知识点**: 斐波那契数列是一个经典的数学概念，指的是这样一个数列：1, 1, 2, 3, 5, 8, 13, 21, ...，后续的每一个数字都是前两个数字之和。 - **实现...
java核心面试题解析（持续更新）
卷不动了，你们继续卷。
03-21 2129
IoC 是 Inversion of Control 的简写，译为“控制反转”，它不是一门技术，而是一种设计思想，是一个重要的面向对象编程法则，能够指导我们如何设计出松耦合、更优良的程序。Spring 通过 IoC 容器来管理所有 Java 对象的实例化和初始化，控制对象与对象之间的依赖关系。我们将由 IoC 容器管理的 Java 对象称为 Spring Bean，它与使用关键字 new 创建的 Java 对象没有任何区别。
JAVA练习题(50题)
03-06
- **实现思路**：使用循环结构判断100以内的所有数是否为素数。 #### 练习题29：选择排序 - **知识点**： - 选择排序算法的原理。 - 循环结构与条件判断的应用。 - **实现思路**：通过选择排序算法，将一个数组按...
Java输出1000以内的素数
qq_46131554的博客
01-23 1444
Java输出1000以内的素数
Java编程——输出1000以内的素数（质数）
qq_51711561的博客
04-02 1万+
素数的定义是什么？ 质数（prime number）又称素数，有无限个。 一个大于1的自然数，除了1和它本身外，不能被其他自然数（质数）整除，换句话说就是该数除了1和它本身以外不再有其他的因数；否则称为合数。 public class demo7{ public static void main(String[] args) { int i,j,x=0; boolean f; for(i=4;i<=1000;i++){ .
java程序：求1000以内的质数
weixin_34227447的博客
02-28 675
package com.demo;public class CycleDemo {public static void main(String[] args) {int number=0;//定义number为质数的个数loop:for(int i = 2; i<=1000; i++){for(int j = 2; j<i; j++){if(i%j==0){con...
用 Java 语言编写一个应用程序在屏幕上输出 1000 之内的素数。
YUMIAloogy的博客~
03-18 1432
java编写一个应用程序在屏幕上输出 1000 之内的素数。
JAVA——实现输出1000以内的质数
东城庞太师
11-10 4564
题目：输出1000以内的质数 代码如下： public static void main(String[] args) { int h = 1; // 代表行号 int num = 0; // 代表每行中质数的个数 for (int i = 1; i <= 1000; i++) {// i = 10 int count = 0; // 当前元素能被整除的个数 ...
java 求一千以内的质数
HarrisJayce的博客
11-12 3274
System.out.println("输出1000以内所有的质数"); /** * 定义变量2从1到100，如果j从1到i，i对j求余运算只有两次满足为零 * （被1和它自身整除时），那么就可以认为这个数是素数，就可以输出了。 */ // 质数和 int sum2 = 0; // 多少个质数 int count2 = 0; for (int i = 1;
（java编程）输出1000以内的所有质数
热门推荐
Henry313的博客
09-22 1万+
public class prime1 { public static void main(String[] args) { // TODO Auto-generated method stub int i,j; int num; for(i=1;i&lt;=1000;i++) { for(j=2;j&lt;i;j++) { if(i%j==0) ...
用JAVA完成1000以内素数的判断
xwe_147jyz的博客
11-06 1716
素数：素数一般指质数，质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。 思路：再1000以内找出素数当然我们得用一个循环，这里笔者提供一个思路，假如这里笔者找出一个35来判断这个数是否是素数，那么我们就要从1开始让35%1来判断它的余数是否是0，这里35%1==0，接着我们继续35%2！=0，35%3！=0；35%4！=0；35%5！=0；好这里一直到35%5！这里，我们知道5*7=35，说明5和7是35的因数，记住这个思路，我们到for()循环中使用； 使用for()循环的意义：
java输出1000以内所有的素数 2020-02-28
aiyst01的博客
02-28 1655
java输出1000以内所有的素数 public class prime1 { public static void main(String[] args) { // TODO Auto-generated method stub int i,j; int num; for(i=1;i<=1000;i++) { for(j=2;j<i;j++) { if(i%...
Java实现1000以内的质数求和
05-11
以下是Java实现1000以内的质数求和的代码示例： ```java public class PrimeNumberSum { public static void main(String[] args) { int n = 1000; int sum = 0; for (int i = 2; i <= n; i++) { boolean isPrime = true; for (int j = 2; j < i; j++) { if (i % j == 0) { isPrime = false; break; } } if (isPrime) { sum += i; } } System.out.println("1000以内的质数之和为：" + sum); } } ``` 代码中先设定了求和范围为1000，然后使用两个for循环遍历从2到1000的所有整数。在内层循环中，判断当前数是否为质数，如果不是则将isPrime标记为false，退出循环。最后如果isPrime为true，则将当前质数加入sum中。最终输出求和结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值