数字の特定のパターンを識別するプログラムを作成しようとしています。これにアルゴリズムが必要なのか、プログラミングを慎重に考えただけなのかはわかりません。私はソースコードを提供してくれる人を探しているのではなく、正しい方向に私を始めるための刺激的なアイデアを探しています。
数値は、000000から999999までの6桁の固定長になります。各数値は、配列の一部として格納されると思います。次に、パターンに対して数値をテストしたいと思います。
たとえば、私が使用している3つのパターンは
A A A A A A - would match such examples as 111111 , 222222, 333333 etc where
A B A B A B - would match such examples as 121212 , 454545, 919191 etc
A (A+1) (A+2) B (B+1) (B+2) - would match such examples as 123345, 789123, 456234
私が立ち往生している部分は、整数配列の各部分をAやBなどの値に割り当てる方法だと思います
私の最初の考えは、各部分を個別の文字として割り当てることです。したがって、配列が1 3 5 4 6 8で構成されている場合、次のようなマップを作成します。
A=1
B=3
C=5
D=4
E=6
F=8
次に、最初のパターンをどのように取るか、
AAAAAA
そして、if（AAAAAA = ABCDEF）のようなものでテストすると、AAAAAAAと一致します
そうでない場合は、すべてのパターンで（ABABAB = ABCDEF）などを試してください
このシナリオでは、番号234874のように、Cに割り当てられた値がFに割り当てられた値と同じにならない理由はありません。
これが誰にとっても意味があるかどうかはわかりませんが、フィードバックに基づいて質問を絞り込むことができると思います。
要約すると、プログラムに6桁の数字を受け入れて、どのパターンに一致したかを返す方法についてのアイデアを探しています。
解決
与えられたコメントが私を下の良い軌道に乗せた後、私が最終的な解決策として作成したものです。
package com.doyleisgod.number.pattern.finder;
import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
public class FindPattern {
private final int[] numberArray; //Array that we will match patterns against.
private final Document patternTree = buildPatternTree(); //patternTree containing all the patterns
private final Map<String, Integer> patternisedNumberMap; //Map used to allocate ints in the array to a letter for pattern analysis
private int depth = 0; //current depth of the pattern tree
// take the int array passed to the constructor and store it in out numberArray variable then build the patternised map
public FindPattern (int[] numberArray){
this.numberArray = numberArray;
this.patternisedNumberMap = createPatternisedNumberMap();
}
//builds a map allocating numbers to letters. map is built from left to right of array and only if the number does not exist in the map does it get added
//with the next available letter. This enforces that the number assigned to A can never be the same as the number assigned to B etc
private Map<String, Integer> createPatternisedNumberMap() {
Map<String, Integer> numberPatternMap = new HashMap<String, Integer>();
ArrayList<String> patternisedListAllocations = new ArrayList<String>();
patternisedListAllocations.add("A");
patternisedListAllocations.add("B");
patternisedListAllocations.add("C");
patternisedListAllocations.add("D");
Iterator<String> patternisedKeyIterator = patternisedListAllocations.iterator();
for (int i = 0; i<numberArray.length; i++){
if (!numberPatternMap.containsValue(numberArray[i])) {
numberPatternMap.put(patternisedKeyIterator.next(), numberArray[i]);
}
}
return numberPatternMap;
}
//Loads an xml file containing all the patterns.
private Document buildPatternTree(){
Document document = null;
try {
File patternsXML = new File("c:\\Users\\echrdoy\\Desktop\\ALGO.xml");
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
document = db.parse(patternsXML);
} catch (Exception e){
e.printStackTrace();
System.out.println("Error building tree pattern");
}
return document;
}
//gets the rootnode of the xml pattern list then called the dfsnodesearch method to analyse the pattern against the int array. If a pattern is found a
//patternfound exception is thorwn. if the dfsNodeSearch method returns without the exception thrown then the int array didn't match any pattern
public void patternFinder() {
Node rootnode= patternTree.getFirstChild();
try {
dfsNodeSearch(rootnode);
System.out.println("Pattern not found");
} catch (PatternFoundException p) {
System.out.println(p.getPattern());
}
}
//takes a node of the xml. the node is checked to see if it matches a pattern (this would only be true if we reached the lowest depth so must have
//matched a pattern. if no pattern then analyse the node for an expression. if expression is found then test for a match. the int from the array to be tested
//will be based on the current depth of the pattern tree. as each depth represent an int such as depth 0 (i.e root) represent position 0 in the int array
//depth 1 represents position 1 in the int array etc.
private void dfsNodeSearch (Node node) throws PatternFoundException {
if (node instanceof Element){
Element nodeElement = (Element) node;
String nodeName = nodeElement.getNodeName();
//As this method calls its self for each child node in the pattern tree we need a mechanism to break out when we finally reach the bottom
// of the tree and identify a pattern. For this reason we throw pattern found exception allowing the process to stop and no further patterns.
// to be checked.
if (nodeName.equalsIgnoreCase("pattern")){
throw new PatternFoundException(nodeElement.getTextContent());
} else {
String logic = nodeElement.getAttribute("LOGIC");
String difference = nodeElement.getAttribute("DIFFERENCE");
if (!logic.equalsIgnoreCase("")&&!difference.equalsIgnoreCase("")){
if (matchPattern(nodeName, logic, difference)){
if (node.hasChildNodes()){
depth++;
NodeList childnodes = node.getChildNodes();
for (int i = 0; i<childnodes.getLength(); i++){
dfsNodeSearch(childnodes.item(i));
}
depth--;
}
}
}
}
}
}
//for each node at a current depth a test will be performed against the pattern, logic and difference to identify if we have a match.
private boolean matchPattern(String pattern, String logic, String difference) {
boolean matched = false;
int patternValue = patternisedNumberMap.get(pattern);
if (logic.equalsIgnoreCase("+")){
patternValue += Integer.parseInt(difference);
} else if (logic.equalsIgnoreCase("-")){
patternValue -= Integer.parseInt(difference);
}
if(patternValue == numberArray[depth]){
matched=true;
}
return matched;
}
}
パターンのxmlリストは次のようになります
<?xml version="1.0"?>
<A LOGIC="=" DIFFERENCE="0">
<A LOGIC="=" DIFFERENCE="0">
<A LOGIC="=" DIFFERENCE="0">
<A LOGIC="=" DIFFERENCE="0">
<pattern>(A)(A)(A)(A)</pattern>
</A>
<B LOGIC="=" DIFFERENCE="0">
<pattern>(A)(A)(B)(A)</pattern>
</B>
</A>
<B LOGIC="=" DIFFERENCE="0">
<A LOGIC="=" DIFFERENCE="0">
<pattern>(A)(A)(B)(A)</pattern>
</A>
<B LOGIC="=" DIFFERENCE="0">
<pattern>(A)(A)(B)(B)</pattern>
</B>
</B>
</A>
<A LOGIC="+" DIFFERENCE="2">
<A LOGIC="+" DIFFERENCE="4">
<A LOGIC="+" DIFFERENCE="6">
<pattern>(A)(A+2)(A+4)(A+6)</pattern>
</A>
</A>
</A>
<B LOGIC="=" DIFFERENCE="0">
<A LOGIC="+" DIFFERENCE="1">
<B LOGIC="+" DIFFERENCE="1">
<pattern>(A)(B)(A+1)(B+1)</pattern>
</B>
</A>
<A LOGIC="=" DIFFERENCE="0">
<A LOGIC="=" DIFFERENCE="0">
<pattern>(A)(B)(A)(A)</pattern>
</A>
<B LOGIC="+" DIFFERENCE="1">
<pattern>(A)(B)(A)(B+1)</pattern>
</B>
<B LOGIC="=" DIFFERENCE="0">
<pattern>(A)(B)(A)(B)</pattern>
</B>
</A>
<B LOGIC="=" DIFFERENCE="0">
<A LOGIC="=" DIFFERENCE="0">
<pattern>(A)(B)(B)(A)</pattern>
</A>
<B LOGIC="=" DIFFERENCE="0">
<pattern>(A)(B)(B)(B)</pattern>
</B>
</B>
<A LOGIC="-" DIFFERENCE="1">
<B LOGIC="-" DIFFERENCE="1">
<pattern>(A)(B)(A-1)(B-1)</pattern>
</B>
</A>
</B>
<A LOGIC="+" DIFFERENCE="1">
<A LOGIC="+" DIFFERENCE="2">
<A LOGIC="+" DIFFERENCE="3">
<pattern>(A)(A+1)(A+2)(A+3)</pattern>
</A>
</A>
</A>
<A LOGIC="-" DIFFERENCE="1">
<A LOGIC="-" DIFFERENCE="2">
<A LOGIC="-" DIFFERENCE="3">
<pattern>(A)(A-1)(A-2)(A-3)</pattern>
</A>
</A>
</A>
</A>
私のパターンで見つかった例外クラスは次のようになります
package com.doyleisgod.number.pattern.finder;
public class PatternFoundException extends Exception {
private static final long serialVersionUID = 1L;
private final String pattern;
public PatternFoundException(String pattern) {
this.pattern = pattern;
}
public String getPattern() {
return pattern;
}
}
これのいずれかが同様の問題を抱えている人に役立つかどうか、またはこれがどのように機能しているかについて誰かがコメントを持っているかどうかはわかりません。