Java实验--关于英文短语词语接龙

最新推荐文章于 2021-05-09 18:04:17 发布
最新推荐文章于 2021-05-09 18:04:17 发布
阅读量315 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/halone/p/10988864.html
版权

在课堂上经过实验之后，重新在宿舍里面从0开始编写大概30分钟左右能够完成这个实验，不是原来的思路。

该实验的表述为：从两个文本input1.txt和input2.txt中读取英文单词，若前面的英文单词的尾字母和后面的英文单词的未字母相同的话，则构成一个英文词语接龙，直到文章结尾，求出整篇文章中词语接龙最长的词语接龙词组，并将其输出到output1.txt和output2.txt文件夹中。

实验代码：

package ctn;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.List;

public class Ctn {

    static List<String> words=new ArrayList<String>();
    public static void main(String args[]) throws IOException
    {
        words.clear();
        if(daoru("input1.txt"))
        {
            int size=0;
            List<String> result = null;
            while(words.size()>0)
            {
                List<String> temp=returnList(words);
                if(temp.size()>size)
                {
                    result=temp;
                    size=temp.size();
                }
            }
            String all=new String();
            if(result.size()>1)
            {
                for(String it:result)
                {
                    all+=it+"\r\n";
                }
                daochu(all,"output1.txt");
                System.out.println("文件output1.txt导出");
            }
            else System.out.println("单词数量过少无法导出");
        }
        else System.out.println("文件input1.txt不存在");
        
        words.clear();
        if(daoru("input2.txt"))
        {
            int size=0;
            List<String> result = null;
            while(words.size()>0)
            {
                List<String> temp=returnList(words);
                if(temp.size()>size)
                {
                    result=temp;
                    size=temp.size();
                }
            }
            String all=new String();
            if(result.size()>1)
            {
                for(String it:result)
                {
                    all+=it+"\r\n";
                }
                daochu(all,"output2.txt");
                System.out.println("文件output2.txt导出");
            }
            else System.out.println("单词数量过少无法导出");
            words.clear();
        }
        else System.out.println("文件input2.txt不存在");
    }
    public static List<String> returnList(List<String> in)
    {
        char cold=0;
        char cnew=0;
        List<String> temp=new ArrayList<String>();
        List<Integer> tempNum=new ArrayList<Integer>();
        for(int i=0;i<in.size();i++)
        {
            String now=in.get(i);
            if(i==0)
            {
                cold=now.charAt(now.length()-1);
                tempNum.add(i);
                temp.add(now);
                continue;
            }
            cnew=now.charAt(0);
            if(cold==cnew)
            {
                
                tempNum.add(i);
                if(!temp.contains(now))
                {
                    temp.add(now);
                    cold=now.charAt(now.length()-1);
                }
            }
        }
        for(int j=tempNum.size()-1;j>=0;j--)
        {
            in.remove((int)tempNum.get(j));
        }
        return temp;
    }
    public static boolean daoru(String path) throws IOException
    {
        
        File a=new File(path);
        if(!judeFileExists(a))
        {
            System.out.println("文件不存在");
            return false;
        }
        FileInputStream b = new FileInputStream(a);
        InputStreamReader c=new InputStreamReader(b,"UTF-8");
        {
            BufferedReader bufr =new BufferedReader(c);
            String line = null;
            while((line = bufr.readLine())!=null){
                //line是每一行的数据
                
                String ook[]=line.split("[^A-Za-z]");
                for(String it:ook)
                {
                    //it是每一个空格的数据
                    String temp=it.toLowerCase().replace("\'", "").replace(",", "").replace(".", "").replace(":", "").replace("!", "");
                    if(temp.length()>0)
                    words.add(temp);
                }
                
            }
            bufr.close();
        }
        c.close();
        b.close();
        return true;
    }
    //导入文件时判断文件存在
        public static boolean judeFileExists(File file) {

            if (file.exists()) {
                return true;
            } else {
                return false;
            }

        }
        public static void daochu(String txt,String outfile) throws IOException
        {
            File fi=new File(outfile);
            FileOutputStream fop=new FileOutputStream(fi);
            OutputStreamWriter ops=new OutputStreamWriter(fop,"UTF-8");
            ops.append(txt);
            ops.close();
            fop.close();
        }
}

该实验过程中

对input1.txt输入飘的英文小说的第一章内容，输出output1.txt的时间响应应该在毫秒级以内。（单词量1W左右）

对input2.txt输入飘的整本英文小说的内筒后，输出output2.txt的时间响应应该在5分钟左右。（单词量50W左右）

 

因此上述代码的算法对于数的运算过程响应的时间较长，推断是List中读取N个数据所耗费的时间太长，但是经过了把代码修改成HashMap和Vector对比之后(算法一样的情况下)，上面的代码在处理速度已经是最优了

对于Vector来说：处理1w单词就需要耗费数秒，对于50w词的数据就更不用说了

对于Map来说：处理1w单词的时候和List都在1秒以内，50w单词的处理未经过测试

Map的成语接龙实验代码：

package ctn;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Ctn2 {

    static Map<Integer,String> words=null;
    public static void main(String args[]) throws IOException
    {
        //words.clear();
        //System.out.println("导入Input1.txt");
        words=new HashMap<Integer,String>();
        if(daoru("input1.txt"))
        {
            //System.out.println("导入成功");
            int size=0;
            Map<Integer,String> result = null;
            int maxSize=words.size();

            while(words.size()>0)
            {
                Map<Integer,String> temp=returnMap(words);
                if(temp.size()>size)
                {
                    result=temp;
                    size=temp.size();
                }
            }
            String all=new String();
            if(result.size()>1)
            {
                for(int i=0;i<maxSize;i++)
                {
                    if(result.get(i)!=null)
                        all+=result.get(i)+"\r\n";
                }
                daochu(all,"output1.txt");
                System.out.println("文件output1.txt导出");
            }
            else System.out.println("单词数量过少无法导出");
        }
        else System.out.println("文件input1.txt不存在");
        System.out.println("开始清空Words");
        words.clear();
        System.out.println("Words清空完毕");
        System.out.println("导入Input2.txt");
        if(daoru("input2.txt"))
        {
            System.out.println("导入成功");
            int size=0;
            Map<Integer,String> result = null;
            int maxSize=words.size();

            while(words.size()>0)
            {
                Map<Integer,String> temp=returnMap(words);
                if(temp.size()>size)
                {
                    result=temp;
                    size=temp.size();
                }
            }
            String all=new String();
            if(result.size()>1)
            {
                for(int i=0;i<maxSize;i++)
                {
                    if(result.get(i)!=null)
                        all+=result.get(i)+"\r\n";
                }
                daochu(all,"output2.txt");
                System.out.println("文件output2.txt导出");
            }
            else System.out.println("单词数量过少无法导出");
        }
        else System.out.println("文件input2.txt不存在");
    }
    //将元素对应到Map上，如何判断已经检查过？
    public static Map<Integer,String> returnMap(Map<Integer,String> in)
    {
        char cold=0;
        char cnew=0;
        Map<Integer,String> temp=new HashMap<Integer,String>();
        List<Integer> tempNum=new ArrayList<Integer>();
        boolean g_firstStart=false;
        int g_start=0;
        for(Integer i:in.keySet())
        {
                if(!g_firstStart)
                {
                    g_firstStart=true;
                    g_start=i;
                }
                String now=in.get(i);
                if(i==g_start)
                {
                    cold=now.charAt(now.length()-1);
                    temp.put(i, now);
                    tempNum.add(i);
                    continue;
                }
                cnew=now.charAt(0);
                if(cold==cnew)
                {
                    temp.put(i, now);
                    tempNum.add(i);
                    cold=now.charAt(now.length()-1);
                }
        }
        for(Integer z:tempNum)
        {
                in.remove(z);
        }
        return temp;
    }
    public static boolean daoru(String path) throws IOException
    {
        
        File a=new File(path);
        if(!judeFileExists(a))
        {
            System.out.println("文件不存在");
            return false;
        }
        FileInputStream b = new FileInputStream(a);
        InputStreamReader c=new InputStreamReader(b,"UTF-8");
        {
            BufferedReader bufr =new BufferedReader(c);
            String line = null;
            Integer i=0;
            while((line = bufr.readLine())!=null){
                //line是每一行的数据
                
                String ook[]=line.split("[^A-Za-z]");
                
                for(String it:ook)
                {
                    //it是每一个空格的数据
                    String temp=it.toLowerCase().replace("\'", "").replace(",", "").replace(".", "").replace(":", "").replace("!", "");
                    if(temp.length()>1)
                    {
                        words.put(i,temp);
                        i+=1;
                        
                    }
                }
                
            }
            bufr.close();
        }
        c.close();
        b.close();
        return true;
    }
    //导入文件时判断文件存在
        public static boolean judeFileExists(File file) {

            if (file.exists()) {
                return true;
            } else {
                return false;
            }

        }
        public static void daochu(String txt,String outfile) throws IOException
        {
            File fi=new File(outfile);
            FileOutputStream fop=new FileOutputStream(fi);
            OutputStreamWriter ops=new OutputStreamWriter(fop,"UTF-8");
            ops.append(txt);
            ops.close();
            fop.close();
        }
}

 在算法方面我找不到更优的解法，对于老师要求的几百W个单词中词语接龙的算法，还是得进一步探索后才能知道，虽然单词读入的过程中不会死机，但是要想在1分钟内实现百万级别的单词的找出最长的成语接龙还需要很长的1段路需要走。

现在暂时挂起，以后有能力再继续挑战。

转载于:https://www.cnblogs.com/halone/p/10988864.html

baleizhong820870
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
单词接龙 递归
weixin_43191153的博客
02-07 540
问题描述 单词接龙是一个与我们经常玩的成语接龙相类似的游戏，现在我们已知一组单词，且给定一个开头的字母，要求出以这个字母开头的最长的“龙”（每个单词都最多在“龙”中出现两次），在两个单词相连时，其重合部分合为一部分，例如 beast和astonish，如果接成一条龙则变为beastonish，另外相邻的两部分不能存在包含关系，例如at 和 atide 间不能相连。 输入格式 输入的第一行为一个单独...
成语接龙（英语单词链）
weixin_30485379的博客
06-06 1260
《构建之法》练习题 大家经常玩成语接龙游戏，我们试一试英语的接龙吧：一个文本文件中有N 个不同的英语单词， 我们能否写一个程序，快速找出最长的能首尾相连的英语单词链，每个单词最多只能用一次。最长的定义是：最多单词数量，和单词中字母的数量无关。 例如， 文件里有： Apple Zoo Elephant Under Fox Dog Moon Leaf Tree Pse...
java:单词接龙（dfs）（重点看看：包括相同单词不包含，还有找到第一个相同的开头单词相同的字母，连接字符串重复部分删除）
Claire的博客
03-22 794
java:单词接龙 题目 问题描述 　　单词接龙是一个与我们经常玩的成语接龙相类似的游戏，现在我们已知一组单词，且给定一个开头的字母，要求出以这个字母开头的最长的“龙”（每个单词都最多在“龙”中出现两次），在两个单词相连时，其重合部分合为一部分，例如 beast和astonish，如果接成一条龙则变为beastonish，另外相邻的两部分不能存在包含关系，例如at 和 atide 间不能相连。 ...
Java Web成语接龙小游戏源码
04-22
利用Java Web技术实现的一款成语接龙小游戏,使用到了Java、JDBC、Servlet、HTML+CSS+JavaScript等Java Web技术,适合Java初学者学习与参考,便于Java初学者全面系统的了解Java Web的基本结构及实现过程,可用于构建全栈思想或了解全栈开发
单词接龙java实现
WukongGo的博客
04-27 1365
题目I描述 https://leetcode-cn.com/problems/word-ladder 给定两个单词（beginWord和 endWord）和一个字典，找到从beginWord 到endWord 的最短转换序列的长度。转换需遵循如下规则： 每次转换只能改变一个字母。 转换过程中的中间单词必须是字典中的单词。 说明: 如果不存在这样的转换序列，返回 0。 所有单词具有相同...
新东方软件同步-英语短语句型总结.pdf
11-16
新东方软件同步-英语短语句型总结.pdf
auto-phrase-tokenfilter:Lucene自动短语TokenFilter实现
05-02
自动短语令牌过滤器 Lucene自动短语TokenFilter实现 对令牌流执行“自动短语编制”。 自动短语是指标记序列，旨在描述单个事物，因此应进行搜索。 当在令牌流中检测到这些短语时，将发出代表该短语的单个令牌，而...
Python-基于PySpark的大规模短语挖掘
08-10
使用数据驱动方法检测大量文本中的常用短语。 发现的短语的大小可以是任意的。 可以用于英语以外的语言
local-phrases:常用网络短语的翻译
05-09
局部用语 常用网络短语的翻译。 对于内容本地化很有用。 安装 $ npm install local-phrases 用法 ... 英语 恩 法语 fr 德语 德 印地语 你好 义大利文 它 日本人 ja 韩国人 KO 葡萄牙语 pt 俄语 R
phrase-hunter:猜词游戏短语猎人
03-29
词组搜寻器 每个玩家有5次机会找出该词组。 祝所有玩家好运！ 签出此项目： :
单词接龙
qq_51537085的博客
05-09 3052
单词接龙 单词接龙是一个与我们经常玩的成语接龙相类似的游戏。 现在我们已知一组单词，且给定一个开头的字母，要求出以这个字母开头的最长的“龙”，每个单词最多被使用两次。 在两个单词相连时，其重合部分合为一部分，例如 beast 和 astonish ，如果接成一条龙则变为 beastonish。 我们可以任意选择重合部分的长度，但其长度必须大于等于1，且严格小于两个串的长度，例如 at 和 atide 间不能相连。 输入格式 输入的第一行为一个单独的整数n表示单词数，以下n行每行有一个单词...
单词接龙最长——6.6——计算最长英语单词链
weixin_30817749的博客
06-07 434
题目要求： 大家经常玩成语接龙游戏，我们试一试英语的接龙吧：一个文本文件中有N 个不同的英语单词， 我们能否写一个程序，快速找出最长的能首尾相连的英语单词链，每个单词最多只能用一次。最长的定义是：最多单词数量，和单词中字母的数量无关。 例如， 文件里有： Apple Zoo Elephant Under Fox Dog Moon Leaf Tree Pseudopseu...
Java实现 蓝桥杯VIP 算法训练 单词接龙
热门推荐
南 墙
06-18 1万+
问题描述 单词接龙是一个与我们经常玩的成语接龙相类似的游戏，现在我们已知一组单词，且给定一个开头的字母，要求出以这个字母开头的最长的“龙”（每个单词都最多在“龙”中出现两次），在两个单词相连时，其重合部分合为一部分，例如 beast和astonish，如果接成一条龙则变为beastonish，另外相邻的两部分不能存在包含关系，例如at 和 atide 间不能相连。 输入格式 输入的第一行为一个单独...
ALGO-18 单词接龙 —— DFS与字符串处理(java)
Pluto
03-26 1666
前言：药丸啊药丸啊真的药丸啊，几天时间没做题，昨天做了一道单词接龙题，做了一整个晚上啊，大几个小时。本来想昨天十一点多的时候，也就是好不容易AC了之后就写题解的，可是AC了之后反而身心俱疲，感觉自己蒟蒻，心态收到了冲击。今天上完课写完作业后，还是心有余悸... 再好好地回顾一下，写一篇题解吧。分析：这道题的tag是搜索，但是其实还有字符串处理混杂在里面。首先，理解题意就是一个坎，如果不是写到实在思...
P1019 单词接龙
Lily1221的博客
03-08 174
https://www.luogu.org/problemnew/show/P1019 题目描述 单词接龙是一个与我们经常玩的成语接龙相类似的游戏，现在我们已知一组单词，且给定一个开头的字母，要求出以这个字母开头的最长的“龙”（每个单词都最多在“龙”中出现两次），在两个单词相连时，其重合部分合为一部分，例如 beast和astonish，如果接成一条龙则变为beastonish，另外...
算法题解：单词接龙（JAVA+BFS算法）
梅森上校的博客 业精于勤荒于嬉，形成于思毁于随。
07-15 1657
单词接龙（JAVA+BFS算法） 原题链接：127.Word Ladderhttps://leetcode.com/problems/word-ladder/ 给定两个单词（beginWord和 endWord）和一个字典，找到从beginWord 到endWord 的最短转换序列的长度。转换需遵循如下规则： 每次转换只能改变一个字母。 转换过程中的中间单词必须是字典中的单词。 ...
python Solution LeetCode No.127 word-ladder（单词接龙）
一梦如是的博客
02-22 318
题目: 给定两个单词（beginWord和endWord）和一个字典，找到从beginWord到endWord的最短转换序列的长度。转换需遵循如下规则： 每次转换只能改变一个字母。 转换过程中的中间单词必须是字典中的单词。 说明: 如果不存在这样的转换序列，返回 0。 所有单词具有相同的长度。 所有单词只由小写字母组成。 字典中不存在重复的单词。 你可以假设begin...
java输入三字短语输出两字短语
最新发布
05-15
例如，以下是一个输入三字短语，输出前两个字的Java代码示例： ``` import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值