javasolver的简单介绍
本篇文章给大家谈谈javasolver，以及对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
用java实现野人传教士过河问题
//CrossRiverQuestion.java
import java.util.ArrayList;
import java.util.List;
public class CrossRiverQuestion {
public static void main(String[] args) {
CrossRiverQuestion q = new CrossRiverQuestion(5, 4);
q.solveQuestion();
}
private int peoNum;
private int savageNum;
private ListNode resultList = new ArrayListNode();
public ListNode solveQuestion() {
Node n = new Node(peoNum,savageNum,0,0,0,new ArrayListInteger(),0,0);
boolean dfsResult = dfs(n);
if(dfsResult) {
resultList.add(0,n);
for(Node node : resultList) {
System.out.println("左岸传教士："+node.getLeftPeo()+"左岸野人： "+node.getLeftSavage()+" 右岸传教士： "+node.getRightPeo()+"右岸野人："+node.getRightSavage()+"船上传教士："+node.getOnBoatPeoNum()+"船上野人："+node.getOnBoatSavageNum());
}
return resultList;
}
return null;
}
public CrossRiverQuestion(int peoNum, int savageNum) {
super();
this.peoNum = peoNum;
this.savageNum = savageNum;
}
private boolean dfs(Node n) {
if(n.hasVisited()) return false;
n.addCheckSum();
if(n.getLeftPeo()==0n.getLeftSavage()==0) return true;
if(n.getLeftPeo()0||n.getRightPeo()0||n.getLeftSavage()0||n.getRightSavage()0) {
return false;
}
if(n.getLeftPeo()n.getLeftSavage()n.getLeftPeo()0) return false;
if(n.getRightPeo()n.getRightSavage()n.getRightPeo()0) return false;
if(n.getCURR_STATE()==n.getStateBoatLeft()) {
Node n1 = new Node(n.getLeftPeo()-1,n.getLeftSavage()-1,n.getRightPeo()+1,n.getRightSavage()+1,n.getStateBoatRight(),n.getNodesCheckSum(),1,1);
if(dfs(n1)) {
resultList.add(0,n1);
return true;
}
Node n4 = new Node(n.getLeftPeo()-2,n.getLeftSavage(),n.getRightPeo()+2,n.getRightSavage(),n.getStateBoatRight(),n.getNodesCheckSum(),2,0);
if(dfs(n4)) {
resultList.add(0,n4);
return true;
}
Node n5 = new Node(n.getLeftPeo(),n.getLeftSavage()-2,n.getRightPeo(),n.getRightSavage()+2,n.getStateBoatRight(),n.getNodesCheckSum(),0,2);
if(dfs(n5)) {
resultList.add(0,n5);
return true;
}
}
else {
Node n6 = new Node(n.getLeftPeo(),n.getLeftSavage()+1,n.getRightPeo(),n.getRightSavage()-1,n.getStateBoatLeft(),n.getNodesCheckSum(),0,1);
if(dfs(n6)) {
resultList.add(0,n6);
return true;
}
Node n7 = new Node(n.getLeftPeo()+1,n.getLeftSavage(),n.getRightPeo()-1,n.getRightSavage(),n.getStateBoatLeft(),n.getNodesCheckSum(),1,0);
if(dfs(n7)) {
resultList.add(0,n7);
return true;
}
Node n1 = new Node(n.getLeftPeo()+1,n.getLeftSavage()+1,n.getRightPeo()-1,n.getRightSavage()-1,n.getStateBoatLeft(),n.getNodesCheckSum(),1,1);
if(dfs(n1)) {
resultList.add(0,n1);
return true;
}
Node n4 = new Node(n.getLeftPeo()+2,n.getLeftSavage(),n.getRightPeo()-2,n.getRightSavage(),n.getStateBoatLeft(),n.getNodesCheckSum(),2,0);
if(dfs(n4)) {
resultList.add(0,n4);
return true;
}
Node n5 = new Node(n.getLeftPeo(),n.getLeftSavage()+2,n.getRightPeo(),n.getRightSavage()-2,n.getStateBoatLeft(),n.getNodesCheckSum(),0,2);
if(dfs(n5)) {
resultList.add(0,n5);
return true;
}
}
return false;
}
public ListNode getResultList() {
return resultList;
}
}
Node.java
import java.util.ArrayList;
import java.util.List;
public class Node {
private ListInteger nodesCheckSum = new ArrayListInteger();
private int leftPeo;
private int rightPeo;
private int leftSavage;
private int rightSavage;
private int CURR_STATE = 0;
private int onBoatPeoNum = 0;
private int onBoatSavageNum = 0;
private final int STATE_BOAT_LEFT = 0;
private final int STATE_BOAT_RIGHT = 1;
public Node(int leftPeo, int leftSavage, int rightPeo, int rightSavage, int state, List checkSumList, int onBoatPeoNum, int onBoatSavageNum) {
this.CURR_STATE = state;
this.leftPeo = leftPeo;
this.leftSavage = leftSavage;
this.rightPeo = rightPeo;
this.rightSavage = rightSavage;
this.nodesCheckSum.addAll(checkSumList);
this.onBoatPeoNum = onBoatPeoNum;
this.onBoatSavageNum = onBoatSavageNum;
}
public int getLeftPeo() {
return leftPeo;
}
public void setLeftPeo(int leftPeo) {
this.leftPeo = leftPeo;
}
public int getRightPeo() {
return rightPeo;
}
public void setRightPeo(int rightPeo) {
this.rightPeo = rightPeo;
}
public int getLeftSavage() {
return leftSavage;
}
public void setLeftSavage(int leftSavage) {
this.leftSavage = leftSavage;
}
public int getRightSavage() {
return rightSavage;
}
public void setRightSavage(int rightSavage) {
this.rightSavage = rightSavage;
}
@Override
public String toString() {
return leftPeo+","+leftSavage+","+rightPeo+","+rightSavage+","+CURR_STATE;
}
public int getCURR_STATE() {
return CURR_STATE;
}
public void setCURR_STATE(int cURR_STATE) {
CURR_STATE = cURR_STATE;
}
public int getStateBoatLeft() {
return STATE_BOAT_LEFT;
}
public int getStateBoatRight() {
return STATE_BOAT_RIGHT;
}
public int calcCheckSum() {
return 1*getCURR_STATE()+10*getLeftPeo()+100*getLeftSavage()+1000*getRightPeo()+10000*getRightSavage();
}
public void addCheckSum() {
int checkSum = calcCheckSum();
nodesCheckSum.add(checkSum);
}
public boolean hasVisited() {
int sum = calcCheckSum();
for (Integer checkSum : nodesCheckSum) {
if(checkSum==sum) return true;
}
return false;
}
public ListInteger getNodesCheckSum() {
return nodesCheckSum;
}
public int getOnBoatPeoNum() {
return onBoatPeoNum;
}
public void setOnBoatPeoNum(int onBoatPeoNum) {
this.onBoatPeoNum = onBoatPeoNum;
}
public int getOnBoatSavageNum() {
return onBoatSavageNum;
}
public void setOnBoatSavageNum(int onBoatSavageNum) {
this.onBoatSavageNum = onBoatSavageNum;
}
}
大数据专业都需要学习哪些软件啊？
大数据处理分析能力在21世纪至关重要。使用正确的大数据工具是企业提高自身优势、战胜竞争对手的必要条件。下面让我们来了解一下最常用的30种大数据工具，紧跟大数据发展脚步。
第一部分、数据提取工具
Octoparse是一种简单直观的网络爬虫，可以从网站上直接提取数据，不需要编写代码。无论你是初学者、大数据专家、还是企业管理层，都能通过其企业级的服务满足需求。为了方便操作，Octoparse还添加了涵盖30多个网站的“任务模板 (Task Templates)”，操作简单易上手。用户无需任务配置即可提取数据。随着你对Octoparse的操作更加熟悉，你还可以使用其“向导模式 (Wizard Mode)”来构建爬虫。除此之外，大数据专家们可以使用“高级模式 (Advanced Mode)”在数分钟内提取企业批量数据。你还可以设置“自动云提取 (Scheduled Cloud Extraction)”，以便实时获取动态数据，保持跟踪记录。
02
Content Graber
Content Graber是比较进阶的网络爬网软件，具有可用于开发、测试和生产服务器的编程操作环境。用户可以使用C#或VB.NET调试或编写脚本来构建爬虫。Content Graber还允许你在爬虫的基础上添加第三方扩展软件。凭借全面的功能，Content Grabber对于具有基本技术知识的用户来说功能极其强大。
Import.io是基于网页的数据提取工具。Import.io于2016年首次启动，现已将其业务模式从B2C转变为B2B。2019年，Import.io并购了Connotate，成为了一个网络数据集成平台 (Web Data Integration Platform)。凭借广泛的网络数据服务，Import.io成为了商业分析的绝佳选择。
Parsehub是基于网页的数据爬虫。它可以使用AJax，JavaScript等等从网站上提取动态的的数据。Parsehub提供为期一周的免费试用，供用户体验其功能。
Mozenda是网络数据抓取软件，提供企业级数据抓取服务。它既可以从云端也可以从内部软件中提取可伸缩的数据。
第二部分、开源数据工具
01Knime
KNIME是一个分析平台，可以帮助你分析企业数据，发现潜在的趋势价值，在市场中发挥更大潜能。KNIME提供Eclipse平台以及其他用于数据挖掘和机器学习的外部扩展。KNIME为数据分析师提供了2,000多个模块。
02OpenRefine（过去的Google Refine）是处理杂乱数据的强有力工具，可用于清理、转换、链接数据集。借助其分组功能，用户可以轻松地对数据进行规范化。
03R-Programming
R大家都不陌生，是用于统计计算和绘制图形的免费软件编程语言和软件环境。R语言在数据挖掘中很流行，常用于开发统计软件和数据分析。近年来，由于其使用方便、功能强大，得到了很大普及。
04RapidMiner
与KNIME相似，RapidMiner通过可视化程序进行操作，能够进行分析、建模等等操作。它通过开源平台、机器学习和模型部署来提高数据分析效率。统一的数据科学平台可加快从数据准备到实施的数据分析流程，极大地提高了效率。
第三部分、数据可视化工具
01
Datawrapper
Microsoft PowerBI既提供本地服务又提供云服务。它最初是作为Excel附加组件引入的，后来因其强大的功能而广受欢迎。截至目前，它已被视为数据分析领域的领头羊，并且可以提供数据可视化和商业智能功能，使用户能够以较低的成本轻松创建美观的报告或BI仪表板。
02
Solver
Solver专用于企业绩效管理 (CPM) 数据可视化。其BI360软件既可用于云端又可用于本地部署，该软件侧重于财务报告、预算、仪表板和数据仓库的四个关键分析领域。
03
Qlik
Qlik是一种自助式数据分析和可视化工具。可视化的仪表板可帮助公司有效地“理解”其业务绩效。
04
Tableau Public

Tableau是一种交互式数据可视化工具。与大多数需要脚本的可视化工具不同，Tableau可帮助新手克服最初的困难并动手实践。拖放功能使数据分析变得简单。除此之外，Tableau还提供了入门工具包和丰富的培训资源来帮助用户创建报告。
05
Google Fusion Tables
Fusion Table是Google提供的数据管理平台。你可以使用它来收集，可视化和共享数据。Fusion Table与电子表格类似，但功能更强大、更专业。你可以通过添加CSV，KML和电子表格中的数据集与同事进行协作。你还可以发布数据作品并将其嵌入到其他网络媒体资源中。
06
Infogram
Infogram提供了超过35种交互式图表和500多种地图，帮助你进行数据可视化。多种多样的图表（包括柱形图，条形图，饼形图和文字云等等）一定会使你的听众印象深刻。
第四部分、情感分析工具
01
HubSpot’s ServiceHub
HubSpot具有客户反馈工具，可以收集客户反馈和评论，然后使用自然语言处理 (NLP) 分析数据以确定积极意图或消极意图，最终通过仪表板上的图形和图表将结果可视化。你还可以将HubSpot’s ServiceHub连接到CRM系统，将调查结果与特定联系人联系起来。这样，你可以识别不满意的客户，改善服务，以增加客户保留率。
02
Semantria
Semantria是一款从各种社交媒体收集帖子、推文和评论的工具。Semantria使用自然语言处理来解析文本并分析客户的态度。通过Semantria，公司可以了解客户对于产品或服务的感受，并提出更好的方案来改善产品或服务。
03
Trackur
Trackur的社交媒体监控工具可跟踪提到某一用户的不同来源。它会浏览大量网页，包括视频、博客、论坛和图像，以搜索相关消息。用户可以利用这一功能维护公司声誉，或是了解客户对品牌和产品的评价。
04
SAS Sentiment Analysis

SAS Sentiment Analysis是一款功能全面的软件。网页文本分析中最具挑战性的部分是拼写错误。SAS可以轻松校对并进行聚类分析。通过基于规则的自然语言处理，SAS可以有效地对消息进行分级和分类。
05
Hootsuit Insight
Hootsuit Insight可以分析评论、帖子、论坛、新闻站点以及超过50种语言的上千万种其他来源。除此之外，它还可以按性别和位置对数据进行分类，使用户可以制定针对特定群体的战略营销计划。你还可以访问实时数据并检查在线对话。
第五部分、数据库
01
Oracle

毫无疑问，Oracle是开源数据库中的佼佼者，功能丰富，支持不同平台的集成，是企业的最佳选择。并且，Oracle可以在AWS中轻松设置，是关系型数据库的可靠选择。除此之外，Oracle集成信用卡等私人数据的高安全性是其他软件难以匹敌的。
02
PostgreSQL
PostgreSQL超越了Oracle、MySQL和Microsoft SQL Server，成为第四大最受欢迎的数据库。凭借其坚如磐石的稳定性，它可以处理大量数据。
03
Airtable
Airtable是基于云端的数据库软件，善于捕获和显示数据表中的信息。Airtable提供一系列入门模板，例如：潜在客户管理、错误跟踪和申请人跟踪等，使用户可以轻松进行操作。
04
MariaDB
MariaDB是一个免费的开源数据库，用于数据存储、插入、修改和检索。此外，Maria提供强大的社区支持，用户可以在这里分享信息和知识。
05
Improvado
Improvado是一种供营销人员使用自动化仪表板和报告将所有数据实时地显示在一个地方的工具。作为营销和分析领导者，如果你希望在一个地方查看所有营销平台收集的数据，那么Inprovado对你再合适不过了。你可以选择在Improvado仪表板中查看数据，也可以将其通过管道传输到你选择的数据仓库或可视化工具中，例如Tableau、Looker、Excel等。品牌，代理商和大学往往都喜欢使用Improvado，以大大节省人工报告时间和营销花费。
在JAVA中，用递规的方法求7!
;
解题时可以把渡河的过程省略掉，也就是可以忽略河的存在。
为了用 Java 解这道题，我写了 3 个类：
河边（RiverSide）、河景（RiverScene）和解题者（MACPS，即 Missionaries And Cannibals Puzzle Solver）。
问题中的传教士、野人和船都是非常简单的物件，所以就简单地用单字符字符串“m”、“c” 和 “v”来代表。
其实那三个类都很简单；它们之间的关系也很简单：
1）每个河边都能有 0 或更多的 m 和 c，及最多 1 个 v。
2）每个河景里有两个河边。
3）解题者里有两个河景：初始河景和终极河景。
解题者的任务就是要搜索出能把初始河景及终极河景连起来的河景系列。
解题者的 getSolutionSteps（ ）以递归的方式作深度优先搜索。
其它两个“类”（Combinatorics 和 Copy）都是只提供一个方法的简单类。
代码里有文档。 有不明白的地方可以问。
你可以用类似 Jacobe （）的程序恢复代码原有的缩进。
import java.util.*;
import java.io.*;
/**
* Missionaries And Cannibals Puzzle Solver.
*
* Solution to the puzzle must not violate any of the following 2 rules:
* 1) Relative headcount: cannibals can't outnumber missionaries at any point.
* 2) Boat's loading: mustn't exceed the max.
*/
public class MACPS {
public class SolutionNotFoundException extends RuntimeException
static final Object MISSIONARY = "m", // Simple representation
CANNIBAL = "c", // of objects
BOAT = "v"; // in the puzzle.
private int boat_max_load,
boat_min_load = 1; // Shouldn't be any other value.
private RiverScene firstScene,
finalScene;
// Recursively searches for a solution using Depth-First Search strategy.
// Takes a Stack containing only the first scene (root of tree).
// Returns a collection of scenes connecting the first scene to the final.
// Throws SolutionNotFoundException for obvious reason.
// Deploys the following optimization strategy:
// Transfers as much as possible from source side,
// as little as possible from target side.
private Collection getSolutionSteps( Stack takenSteps ) {
RiverScene lastScene = ( RiverScene ) takenSteps.peek( );
if( lastScene.equals( finalScene ) ) return takenSteps;
RiverScene newStep = lastScene.deepCopy( );
// To allow transfer in both directions to share the same chunk of code.
int start = boat_max_load,
stop = boat_min_load - 1,
step = -1;
RiverSide from = newStep.lside,
to = newStep.rside;
if( to.hasBoat( ) ) {
start = boat_min_load;
stop = boat_max_load + 1;
step = 1;
from = newStep.rside;
to = newStep.lside;
}
for( int nPassenger = start; nPassenger != stop; nPassenger += step ) {
Collection menCombs = new HashSet( // HashSet eliminates duplicates.
Combinatorics.combinations( from.getMenList( ), nPassenger ) );
nextComb:
for( Iterator comb = menCombs.iterator( ); comb.hasNext( ); ) {
Collection menList = ( Collection ) comb.next( );
try {
from.transferMen( to, menList );
// If it's a taken step, undo and try next combination.
for( Iterator i = takenSteps.iterator( ); i.hasNext( ); )
if( i.next( ).equals( newStep ) ) {
to.transferMen( from, menList );
continue nextComb;
}
takenSteps.push( newStep );
return getSolutionSteps( takenSteps );
}
catch( SecurityException e ) {
// Transfer didn't take place. Just try next combination.
}
catch( SolutionNotFoundException e ) {
// New step led to no solution in leaves. Undo, then next.
takenSteps.pop( );
to.transferMen( from, menList );
}
}
}
// All possible steps led to no solution, so
throw new SolutionNotFoundException( );
}
// Do setup, then kick-starts getSolutionSteps( Stack takenSteps ).
public Collection
getSolutionSteps( int nMissionary, int nCannibal, int boatCapacity ) {
if( nMissionary 0 || nCannibal 0 || boatCapacity 0 )
throw new IllegalArgumentException( "Negative argument value." );
RiverSide sourceSide = new RiverSide( nMissionary, nCannibal, true ),
targetSide = new RiverSide( 0, 0, false );
boat_max_load = boatCapacity;
firstScene = new RiverScene( sourceSide, targetSide );
finalScene = new RiverScene( targetSide, sourceSide );
if( firstScene.lside.fatal( ) ) // First scene can be valid but fatal.
throw new SolutionNotFoundException( );
Stack steps = new Stack( );
steps.push( firstScene );
return getSolutionSteps( steps );
}
public static void main( String[ ] args ) {
int nMissionary = 3,
nCannibal = 3,
boatCapacity = 2;
System.out.println(
"\nSolving the puzzle of Missionaries And Cannibals with\n" +
nMissionary + " missionaries and " + nCannibal + " cannibals " +
"and a boat that can take up to " + boatCapacity + " creatures.." );
try {
Collection steps = new MACPS( ).
getSolutionSteps( nMissionary, nCannibal, boatCapacity );
System.out.println( "\nSolution found:\n" );
for( Iterator step = steps.iterator( ); step.hasNext( ); )
System.out.println( step.next( ) + "\n" );
}
catch( SolutionNotFoundException e ) {
System.out.println( "\nNo solution found." );
}
}
}
/**
* Represents a riverside in the puzzle.
*/
class RiverSide implements Serializable {
private ArrayList men = new ArrayList( ),
boat = new ArrayList( );
public RiverSide( int nMissionary, int nCannibal, boolean withBoat ) {
men.addAll( Collections.nCopies( nMissionary, MACPS.MISSIONARY ) );
men.addAll( Collections.nCopies( nCannibal, MACPS.CANNIBAL ) );
Collections.sort( men );
if( withBoat ) boat.add( MACPS.BOAT );
}
public RiverSide deepCopy( ) {
return ( RiverSide ) Copy.deepCopy( this );
}
public Collection getMenList( ) {
return ( Collection ) Copy.deepCopy( men );
}
public boolean equals( Object otherSide ) {
RiverSide other = ( RiverSide ) otherSide;
Collections.sort( men );
Collections.sort( other.men );
return this.men.equals( other.men ) this.boat.equals( other.boat );
}
public String toString( ) {
return "BOAT" + boat + "\t" + "MEN" + men;
}
public boolean hasBoat( ) {
return ! boat.isEmpty( );
}
// Checks for violation of Rule #1.
public boolean fatal( ) {
int mCount = 0, cCount = 0;
for( Iterator i = men.iterator( ); i.hasNext( ); ) {
Object val = i.next( );
if( val.equals( MACPS.MISSIONARY ) ) ++mCount;
if( val.equals( MACPS.CANNIBAL ) ) ++cCount;
}
return mCount 0 mCount cCount;
}
// Throws SecurityException if the transfer of all men in menList
// from this to destination *will* result in violation of Rule #1.
// Else, executes the transfer.
public void transferMen( RiverSide destination, Collection menList ) {
for( Iterator i = menList.iterator( ); i.hasNext( ); )
destination.men.add( men.remove( men.indexOf( i.next( ) ) ) );
// A nice place to automate boat transfer.
_transferBoat( destination );
// Undo the transfer if it led to violation of Rule #1.
if( fatal( ) || destination.fatal( ) ) {
destination.transferMen( this, menList );
throw new SecurityException( );
}
}
// Tansfers boat from this to destination. Called only by transferMen( ).
private void _transferBoat( RiverSide destination ) {
destination.boat.add( boat.remove( 0 ) );
}
}
/**
* Combines two riversides. Serves mainly as a data object.
*/
class RiverScene implements Serializable {
RiverSide lside, rside; // Package access.
public RiverScene( RiverSide lside, RiverSide rside ) {
this.lside = lside.deepCopy( );
this.rside = rside.deepCopy( );
}
public RiverScene deepCopy( ) {
return ( RiverScene ) Copy.deepCopy( this );
}
public boolean equals( Object otherScene ) {
RiverScene other = ( RiverScene ) otherScene;
return lside.equals( other.lside ) rside.equals( other.rside );
}
public String toString( ) {
return "Left Side:\t" + lside + "\n" + "Right Side:\t" + rside;
}
}
/**
* Provides a static method to generate combinations of items taken r at a time.
*/
class Combinatorics {
public static Collection combinations( Collection items, int r ) {
if( r == 0 ) // Return [ [ ] ]. Note that [ ] denotes a List.
return Collections.nCopies( 1, new ArrayList( ) );
List copy = new ArrayList( items ), // To enable subListing of items.
result = new ArrayList( );
for( int i = 0; i copy.size( ); ++i ) {
Collection subCombs =
combinations( copy.subList( i + 1, copy.size( ) ), r - 1 );
for( Iterator iter = subCombs.iterator( ); iter.hasNext( ); ) {
// Assign [ [ items.get( i ) ] ] to subComb.
List subComb = new ArrayList( copy.subList( i, i + 1 ) );
subComb.addAll( ( List ) iter.next( ) );
result.add( subComb );
}
}
return result;
}
}
/**
* Provides a static method to perform deepcopy of object via serialization.
*/
class Copy {
public static Object deepCopy( Object o ) {
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream( );
ObjectOutputStream oos = new ObjectOutputStream( baos );
oos.writeObject( o );
oos.close( );
ObjectInputStream ois =
new ObjectInputStream(
new ByteArrayInputStream( baos.toByteArray( ) ) );
return ois.readObject( );
}
catch ( Exception e ) {
throw new RuntimeException( e );
}
}
}
JAVA这道题要如何用递归实现呢，求大神
按照你的要求编写的Java递归程序如下:
import java.util.Scanner;
public class GGG {
public static void main(String[] args) {
int N = 0;
Scanner sc=new Scanner(System.in);
int num=sc.nextInt();
for(int n=0;nnum;n++){
N=sc.nextInt();
int a[]=new int[N];
for(int i=0;ia.length;i++){
a[i]=sc.nextInt();
}
System.out.print("case "+(n+1)+":");
process(a,0);
System.out.println();
}
}
private static void process(int[] a, int n) {
if(n==0){
if(isPrime(a[n+1]))
System.out.print(1+" ");
else
System.out.print(0+" ");
}else if(n==a.length-1){
if(isPrime(a[n-1]))
System.out.print(1+" ");
else
System.out.print(0+" ");
return;
}else{
if(isPrime(a[n-1])isPrime(a[n+1]))
System.out.print(2+" ");
else if(isPrime(a[n-1])||isPrime(a[n+1]))
System.out.print(1+" ");
else
System.out.print(0+" ");
}
process(a,n+1);
}
public static boolean isPrime(int num) {
int i;
for(i=2;inum;i++){
if(num%i==0)
break;
}
if(i==num){
return true;
}
return false;
}
}
运行结果:
2
5
5 7 2 9 13
case 1:1 2 1 2 0
3
10 4 5
case 2:0 1 0
有没有 java 算式解析 工具类
试试apache的MATH工具类。
Section 1 linear 线性代数（矩阵为主）
1） Vector 向量
2） Matrix 矩阵
3） Matrix Decomposition 矩阵分解
Section 2 analysis 数学分析（函数为主）
1） Function 函数
2） Polynomial 多项式函数
3） Interpolation 插值
4） Integration 积分
5） Solver 求解
Section 3 Probabilityand Statistics 概率和统计
1）distribution 分布
2）fraction and complex 分数和复数
3）random and statistics 随机生成和统计初步
4）cluster and regression聚类和回归
javasolver的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于、javasolver的信息别忘了在本站进行查找喔。
发布于：2022-11-26，除非注明，否则均为原创文章，转载请注明出处。