java代码单词接龙,单词接龙怎么写

JAVA在控制台输入两个单词,如果第一个单词的最后几个字母,恰好是第二个单词的首字母,则输出相同的字母

package tool;

创新互联专业为企业提供永安网站建设、永安做网站、永安网站设计、永安网站制作等企业网站建设、网页设计与制作、永安企业网站模板建站服务,10年永安做网站经验,不只是建网站,更提供有价值的思路和整体网络服务。

import java.util.Scanner;

public class DogSuZu

{

public static void main ( String[] args )

{

Scanner input = new Scanner (System.in);

StringBuilder builder = new StringBuilder ();

System.out.println ("输入两个单词 ,空格隔开");

while (input.hasNextLine ())

{

String line = input.nextLine ();

String one = line.split ("\\s+")[0];

String two = line.split ("\\s+")[1];

int len = one.length ()  two.length () ? one.length () : two.length ();

String result = "";

one = builder.append (one).reverse ().toString ();

for ( int i = 0; i  len; i++ )

{

if (one.charAt (i) == two.charAt (i))

{

result += one.charAt (i);

}

else

{

break;

}

}

if ("".equals (result))

{

System.out.println ("接龙不成功");

}

else

{

System.out.println (result);

}

}

}

}

java 代码 猜字母

package util;

import java.util.Random;

import java.util.Scanner;

public class test {

public static void main(String[] args) {

Random rnd=new Random();

Scanner in = new Scanner(System.in);

char c=0;

String yn = "";

do{

c=(char)('A'+rnd.nextInt(27)); //产生的是随机字母

System.out.println("输入C:"+c);

for (int i = 0; i 4; i++) {

System.out.println("请输入一个大写字母:");

String at = in.next();

System.out.println(at);

String a = String.valueOf(c);

if (a.equals(at)) {

System.out.println("恭喜你,猜对了!");

break;

}else {

System.out.println("你猜错了!");

}

}

System.out.println("是否继续:y/n");

yn = in.next().trim();

}while("y".equals(yn));

System.out.println("你结束了猜字母的游戏!");

}

}

//直接粘贴,复制,就能运行。

《编程题》单词接龙求教java高人解答

先将单词复制一份。拿你的例子说,5个单词,由于每个可以出现两次,那么最终就是10个单词。

构造图结构,你把每个单词当成一个节点,遍历所有节点,能收尾相连且不包含节点的就连一根线,做成一个有向图。

遍历整个图,找到最长的

由于你最多只有20个单词,这种方法是绝对可行的,相当于把所有可能的龙找出来并挑选最长的。

算我无聊,写了份代码,你参考下吧,输入输出我没怎么管哈

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

public class FindLongestDragon

{

public static void main(String args[])

{

  getLongestDragon('a', "at", "touch", "cheat", "choose", "tact");

}

public static void getLongestDragon(char startChar, String ... nodesStr)

{

  ListNode nodes = new ArrayListNode();

  for (String nodeStr : nodesStr)

  {

      nodes.add(new Node(nodeStr));

      nodes.add(new Node(nodeStr));

  }

  //遍历所有节点关系,构成图

  for (Node node1 : nodes)

  {

      for (Node node2: nodes)

      {

          if (node1 != node2)

          {

              checkIsLink(node1, node2);

          }

      }

  }

  //遍历

  for (Node node : getStartWithCharNodes(nodes, startChar))

  {

      Dragon dragon = new Dragon();

      dragon.append(node);

      dragon.findNextNode();

  }

  //输出所有的龙

  Collections.sort(Dragon.dragons);

  for (Dragon dragon : Dragon.dragons)

  {

      System.out.println(dragon);

  }

}

//b是否能和a相连

public static void checkIsLink(Node a, Node b)

{

  String nameA = a.getName();

  String nameB = b.getName();

  //存在包含关系

  if (nameA.endsWith(nameB) || nameB.startsWith(nameA))

  {

      return;

  }

  if (getLinkStr(a, b) != null)

  {

      a.addChild(b);

  }

}

public static String getLinkStr(Node a, Node b)

{

  String nameA = a.getName();

  String nameB = b.getName();

  //从第二个字符开始检查是否相连

  for (int i = 1, length = nameA.length(); i length; i++)

  {

      String linkStr = nameA.substring(i);

      if (nameB.startsWith(linkStr))

      {

          return linkStr;

      }

  }

  return null;

}

private static ListNode getStartWithCharNodes(ListNode list, char startChar)

{

  ListNode nodes = new ArrayListNode();

  int size = list.size();

  for (int i = 0; i size; i+=2)

  {

      Node node = list.get(i);

      if (node.getName().charAt(0) == startChar)

      {

          nodes.add(node);

      }

  }

  return nodes;

}

}

class Dragon implements ComparableDragon

{

private ListNode nodes = new ArrayListNode();

public static ListDragon dragons = new ArrayListDragon();

public void findNextNode()

{

  Node lastNode = nodes.get(nodes.size() - 1);

  boolean hasNextNode = false;

  for (Node nextNode : lastNode.getChildren())

  {

      if (!nodes.contains(nextNode))

      {

          hasNextNode = true;

          append(nextNode);

          findNextNode();

          removeTail();

      }

  }

  //找到了尽头

  if (!hasNextNode)

  {

      Dragon copy = this.copy();

      if (!dragons.contains(copy))

      {

          dragons.add(copy);

      }

  }

}

private Dragon copy()

{

  Dragon dragon = new Dragon();

  for (Node node : this.nodes)

      dragon.append(node);

  return dragon;

}

public void append(Node node)

{

  nodes.add(node);

}

public void removeTail()

{

  nodes.remove(nodes.size() - 1);

}

public String toString()

{

  StringBuilder sb = new StringBuilder();

  //展示所有的节点

  String allNodeLinkStr = getAllNodeLinkStr();

  sb.append(allNodeLinkStr).append(" ");

  sb.append(allNodeLinkStr.length()).append(" ");

  for (Node node : nodes)

  {

      sb.append(node.getName()).append(" ");

  }

  return sb.toString();

}

@Override

public int compareTo(Dragon o)

{

  return o.getLength() - this.getLength();

}

public int getLength()

{

  return getAllNodeLinkStr().length();

}

public String getAllNodeLinkStr()

{

  StringBuilder sb = new StringBuilder();

  //展示所有的节点

  sb.append(nodes.get(0));

  for (int i = 1, length = nodes.size(); i length; i++)

  {

      Node node = nodes.get(i);

      sb.append(node.getName().substring(FindLongestDragon.getLinkStr(nodes.get(i - 1), node).length()));

  }

  return sb.toString();

}

public boolean equals(Object o)

{

  if (o instanceof Dragon)

  {

      Dragon d = (Dragon)o;

      if (d.nodes.size() == this.nodes.size())

      {

          int length = this.nodes.size();

          for (int i = 0; i length; i++)

          {

              if (!d.nodes.get(i).getName().equals(this.nodes.get(i).getName()))

              {

                  return false;

              }

          }

          return true;

      }

  }

  return false;

}

}

class Node

{

private ListNode children = new ArrayListNode();

private String name;

public Node(String name)

{

  super();

  this.name = name;

}

public ListNode getChildren()

{

  return children;

}

public String getName()

{

  return name;

}

public void addChild(Node e)

{

  this.children.add(e);

}

public String toString()

{

  return this.getName();

}

}

一个很小的java问题 代码如下: enum Fruit { 苹果,梨,香蕉,西瓜,芒果 }

这种情形大多是源文件里面还有其他类定义或者内部类定义,然后编译时会有xxx.class,xxx$1.class。其他情形暂未碰到。


新闻名称:java代码单词接龙,单词接龙怎么写
转载源于:http://scyanting.com/article/hohdgo.html