-1

我正在尝试编写一个程序，当给定两个字符串时，它会“处理”一个字母以形成同义词。这是一个显示它的示例的网站：

http://www.braingle.com/brainteasers/46611/letter-juggle.html

我的任务是“编写一个程序——给定一个包含同义词对的文件和一个包含字典中单词序列的第二个文件——将尽可能多地从字典中生成可用于设置拼图的单词对每个同义词对。”

这些是文件 - dictionary.txt和synonyms.txt。

当我想出一个单词时，我会查字典看它是否有效。因此，使用“boast”和“hip”这两个词，当我将它们组合起来时，我可以得到“boat”和“ship”（它们是同义词）。

现在，我拿了两个字符串（钉子和别针）并将它们分成一个字符数组，但我不知道如何调整它们来检查它们是否是有效的单词。

我希望能够将“nail”中的字母“n”添加到“pin”以给我“pinn”，然后我想检查“pinn”的每个组合并检查它是否是一个有效的单词 - 如果是，然后我检查“ail”是否可以是一个单词，如果不是，那么我继续“nail”中的下一个字母 pinn -> pinn, pnin, pnni, pnin......

public class LetterJuggle {

/**
 * @param args the command line arguments
 */
public static void main(String[] args) {
    // TODO code application logic here
    try{
        // Open the file that is the first 
        // command line parameter
        FileInputStream fstream = new FileInputStream("Dictionary.txt"); //Dictionary.txt //Synonyms.txt
        // Get the object of DataInputStream
        DataInputStream in = new DataInputStream(fstream);
        BufferedReader br = new BufferedReader(new InputStreamReader(in));
        String strLine;
        int size =0;
        while ((strLine = br.readLine()) != null){
            size++;
        }

        String [] dictionary = new String [size];

        fstream = new FileInputStream("Dictionary.txt");
        in = new DataInputStream(fstream);
        br = new BufferedReader(new InputStreamReader(in));
        size = 0;
        //Read File Line By Line
        while ((strLine = br.readLine()) != null){
            // Print the content on the console
            dictionary[size] = strLine;
            size++; 
        }

        fstream = new FileInputStream("Synonyms.txt");
        in = new DataInputStream(fstream);
        br = new BufferedReader(new InputStreamReader(in));

        while ((strLine = br.readLine()) != null){
            //System.out.println(strLine);
            String [] words = strLine.split("\\s+");
            for(int i =0; i < words.length; i++){
                //System.out.println(words[i]);
            }
            char[] ch_array_1 = words[0].toCharArray();
            char[] ch_array_2 = words[1].toCharArray();

            for(int i =0; i < ch_array_1.length; i++){
                System.out.print(ch_array_1[i] + " ");
            }
            System.out.println();
            for(int i =0; i < ch_array_2.length; i++){
                System.out.print(ch_array_2[i] + " ");
            }
            System.out.println();
        }
        //Close the input stream
        in.close();
    }catch(Exception e){//Catch exception if any
        System.err.println("Error: " + e.getMessage());
    }    


}

}

4

2 回答 2

2

它不一定有效，但它是一个想法。使用一些 (2) 循环并从第一个单词中取一个字母并将其添加到所有位置（从索引 0 到最后一个字母索引之后），并检查两者是否都是有效单词（删除字母的单词和新形成的单词）。（一些伪代码）

for (Letter l : word1)
{
    Word word1temp = extract_Letter_l_from_word(l,word1);
    check if word1temp and word2 are synonyms
    //else
    for (all letter indexes i of word2)
    {
         form word with letter L at position i and word2 form a synonim of word2
         // also maybe do this in the mirror for word2 and word1
    }
}
于 2012-12-18T15:05:20.717 回答
1

试试这个，数组的排列：排列的数组

在这里发布代码，以便即使链接已过时，您可以参考这里。我认为这对你有帮助




导入 java.util.Iterator；

导入 java.util.NoSuchElementException；

导入 java.lang.reflect.Array；                            



公共类 Permute 实现迭代器 {                 



私有最终 int 大小；

   私有最终对象 [] 元素；// 原始 0 的副本
   私有最终对象 ar；// 输出数组，
   私有最终 int [] 排列；// 数字 1..si 的烫发



私人布尔下一个=真；                            



// int[], double[] 数组不起作用 :-( 

   public Permute (Object [] e) { 

      size = e.length;

      元素=新对象[大小]；//不适合
      System.arraycopy（e，0，元素，0，大小）；

      ar = Array.newInstance (e.getClass().getComponentType
      System.arraycopy(e, 0, ar, 0, size); 

      排列 = 新的 int [大小+1]；

      对于 (int i=0; 我
         排列[i]=i; 

      } 

   }                                                       



私人无效formNextPermutation（）{

      对于 (int i=0; 我
         // i+1 因为 perm[0] 总是 = 0

         // perm[]-1 因为数字 1..size 是
         Array.set(ar, i, elements[permutation[i+1]-1]); 

      } 

   }                                                       



public boolean hasNext() {

      返回下一个；

   }                                                       



public void remove() 抛出 UnsupportedOperationExceptio
      抛出新的 UnsupportedOperationException(); 

   }                                                       



private void swap (final int i, final int j) { 

      final int x = permutation[i]; 

      排列[i] = 排列[j]；

      排列[j] = x; 

   }                                                       



// 不抛出 NoSuchElement; 它环绕！

   公共对象 next() 抛出 NoSuchElementException {    



  formNextPermutation ();  // copy original elements   

  int i = size-1;                                      
  while (permutation[i]>permutation[i+1]) i--;         

  if (i==0) {                                          
     next = false;                                     
     for (int j=0; j<size+1; j++) {                    
        permutation [j]=j;                             
     }                                                 
     return ar;                                        
  }                                                    

  int j = size;                                        

  while (permutation[i]>permutation[j]) j--;           
  swap (i,j);                                          
  int r = size;                                        
  int s = i+1;                                         
  while (r>s) { swap(r,s); r--; s++; }                 

  return ar;                                           




}                                                       



 public String toString () {                             
  final int n = Array.getLength(ar);                   
  final StringBuffer sb = new StringBuffer ("[");      
  for (int j=0; j<n; j++) {                            
     sb.append (Array.get(ar,j).toString());           
     if (j<n-1) sb.append (",");                       
  }                                                    
  sb.append("]");                                      
  return new String (sb);                              




}                                                       



公共静态无效主要（字符串[]参数）{

      for (Iterator i = new Permute(args); i.hasNext(); ) {
         final String [] a = (String []) i.next(); 

         System.out.println (i); 

      } 

   } 

}

于 2012-12-18T15:17:34.630 回答