精华内容
下载资源
问答
  • 2021-08-09 11:06:41

    上周接了个新需求,写完之后产品让我加一下模糊匹配按照匹配度匹配,查阅相关资料写出了四种,产品直呼过瘾。

    1 、order by case 不过在数据量大的时候查询会很慢,甚至有可能崩溃宕机

    SELECT * FROM table1 WHERE name LIKE '%张三%' 
    ORDER BY(
    CASE   
    WHEN name LIKE  '张三' THEN 1
    WHEN name LIKE  '张三%' THEN 2
    WHEN name LIKE  '%张三%' THEN 3
    ELSE 4 
    END )  
    

    2、UNION ALL 不过如果筛选条件太多的话在mapper文件中写会很麻烦

    SELECT * FROM table1 WHERE name LIKE '张三'
    UNION ALL
    SELECT * FROM table1 WHERE name LIKE '%张三%'
    

    3、length关键字 根据数据的长短进行排序

    SELECT  * FROM table1 WHERE name LIKE '%张三%' ORDER BY (LENGTH (name)) 
    

    4、 LOCATE 关键字 不过 select LOCATE(‘张三’, “张三丰”) 结果是1; select LOCATE(‘张’, “张三丰”) 结果也是1

    排序的时候先查到哪个数据哪个就放在前面

    select LOCATE('张三', "张三丰")  result:1SELECT * FROM table1 WHERE name LIKE '%张三%' ORDER BY (SELECT  LOCATE('张三', name))
    

    5、全文索引 score是根据查出数据的长度来进行排序
    输入nike dunk 也会查询出 nike XXX dunk

    SELECT *, (MATCH(shoes) AGAINST('nike' IN BOOLEAN MODE) - ABS(LENGTH(translate_before) *10)) AS score
    FROM table1
    WHERE MATCH(shoes) AGAINST('nike' IN BOOLEAN MODE)
    ORDER BY score DESC
    
    更多相关内容
  • 并按照lucene的得分算法进行多条件检索并按照得分算法计算匹配度排序。 可以输入一句话进行检索。 lucene.net的版本为2.9.2 盘古分词的版本为2.3.1 并实现了高亮功能。高亮上使用的是盘古分词的高亮算法。 有点小bug...
  • NULL 博文链接:https://sky-xin.iteye.com/blog/2281954
  • ImageRecognition:图片识别,比较两张图片的匹配度
  • sql模糊查询并按匹配度排序 ,实现 匹配+排序 的搜索引擎功能!!!!
  • SQL语句实现按关健字模糊查询,并按匹配度排序
  • 论文研究-城市道路网络功能匹配度分析模型.pdf, 为合理地评价城市道路的实际使用功能与规划设计功能之间的吻合程度,提出了功能匹配度的概念并以此作为评价的目标值.从...
  • ikanalyzersearch
  • 人岗匹配是保证企业人才发挥高效作用的基础,匹配度为人岗匹配提供了一种决策依据,运用层次分析法和模糊综合评价法,从道德素质、身心素质、知识、能力四个方面,建立了人岗匹配度测算模型,并进行实例验证。结果表明,该...
  • 基于信息匹配度的混合推荐算法.pdf
  • 基于用户与物品匹配度的推荐系统性能研究.pdf
  • oracle匹配度函数[自己写的] 比如: a 匹配 ab 匹配度 100% ab 匹配 a 匹配度 50% 社报 匹配 社会报销 匹配度 50%
  • 为了解决基于资源传输的链路预测方法忽略节点间匹配度对资源传输过程影响的问题,提出了一种基于资源传输匹配度的复杂网络链路预测方法。首先,对资源传输路径上的2个端点进行详细分析,提出任意节点间匹配度的量化...
  • 本文在机位匹配度最高条件下,构建了以.近机位使用率和停机位预分配方案鲁棒性为目标的两阶段分配模型,以求解机场的.停机位预分配问题。首先,基于硬约束条件,以机位匹配度最高为目标进行求解。.然后,根据所得...
  • 百度内部SEO培训:百度相关性评估培训:主题匹配度打分
  • 基于区域平均能量匹配度和区域偏差的NSCT的图像融合算法 英文的论文
  • 该文在多因素综合的模糊地图匹配基础上计算匹配度,对匹配结果的可信程度进行评价。该匹配度通过反馈方式在下一次匹配的连通性因素中加以利用。实验表明带匹配度的反馈模糊地图匹配方法可以使连通性得到更加合理有效...
  • 提出了基于匹配度的广度优先推理方法,给出了匹配度的计算方法;实现了用于确定发酵过程生物量软测量混合模型结构的推理过程。实验表明,与基于穷举法的深度优先推理方法比较,基于匹配度的广度优先推理方法能够有效...
  • 匹配度测试.exe

    2022-04-29 00:30:16
    匹配度测试.exe
  • MySQL模糊查询 结果按匹配度 排序

    千次阅读 2021-10-01 16:40:11
    下面介绍一些可以用来当做匹配度的函数: 匹配度量化-字符串长度char_length() 我们可以对记录的字符长度进行排序,如下: SELECT name FROM user WHERE name LIKE CONCAT("%","张三","%") ORDER BY CHAR_LENGTH...

    我们在使用 MySQL 进行模糊查询的时候,受到默认排序的影响,我们会发现与查询关键字相似的记录有时候并没有排到最前面。
    如 :

    CREATE TABLE user(
    	id BIGINT(11) AUTO_INCREMENT PRIMARY KEY,
    	name varchar(255)
    )engine=InnoDB,DEFAULT CHARSET=UTF8;
    INSERT INTO user(name) values("F张三");
    INSERT INTO user(name) values("E张三");
    INSERT INTO user(name) values("D张三");
    INSERT INTO user(name) values("C张三");
    INSERT INTO user(name) values("B张三");
    INSERT INTO user(name) values("A张三");
    INSERT INTO user(name) values("张三");
    

    对上述数据以张三为关键字进行模糊查询后,会发现查询结果如下:

    SELECT * FROM user WHERE name LIKE "%张三%";
    

    在这里插入图片描述
    可以看到,与张三最相似的一条记录被排序到了最后面,如果我们使用了 LIMIT语句,那么很有可能无法再第一页获取到张三这条记录。
    也就引出了今天的问题,如何在模糊查询条件下,让返回结果按照匹配度(相似度)进行进行排序,从而让最匹配的那条记录排在最前面。

    问题分析

    首先,我们需要定位一下问题原因,为什么最匹配的那条记录被排到了最后面?

    这其实是与SELECT 的默认排序规则有关,当我们使用 SELECT 进行查询而没有指定 ORDER BY的时候,MySQL其实是按照id 进行升序排序的,因为 id作为主键索引通过它根本不需要排序,同时每次返回的结果顺序也完全相同。也就是说id = 7 的张三记录之所以被排在最后面是因为它是在最后被插入的,即使它是最张三张三也要讲个先来后到。

    在一些情况下我们的排序是按照 name 来排序的,那么 name是如何进行排序的呢?首先 name字段的数据类型是 varchar可变长度的字符串类型,而对于字符串的排序方式则必然是字典序。

    也就是当我们按照 name 进行排序后,会发现排序结果 变成了这样:
    在这里插入图片描述
    A张三被排在了最前面,是由于字符A的编码在所有name的开头最小,同理 作为name的开头编码最大,因此被排在了最后面。如果我们的记录都是以张三开头,然后结尾是字母的话,则按照 name进行排序的确可以帮助我们将 张三 排到最前面:

    在这里插入图片描述
    问题的关键是如何让查询结果按照匹配度进行排序。下面介绍一些可以用来当做匹配度的函数:

    匹配度量化-字符串长度char_length()

    我们可以对记录的字符长度进行排序,如下:

    SELECT name FROM user
    WHERE name LIKE CONCAT("%","张三","%")
    ORDER BY CHAR_LENGTH(name),name;
    

    在这里插入图片描述
    当我们根据查询条件 name LIKE CONCAT("%","张三","%")进行模糊查询的时候,返回记录的结果有四种样式:

    • 张三
    • 张三%
    • %张三
    • %张三%

    可以看到,除了第二种和第三种条件之外,我们能够根据字符串的长度将结果大致分开。即匹配度和字符串长度呈现相关联的关系。

    匹配度量化-匹配结果在记录中位置locate(),instr(),position()

    其实使用 char_length() 就已经能够解决大部分问题了,如果感觉效果还是不够好的话还可以搭配使用locate(),instr(),position()之一对排序结果进行进一步的处理。

    locate(subStr,string):返回subStrstring中出现的位置

    locate()函数会返回一个字符串在另一个字符串中出现的位置。如果包含,则返回对应的索引位置(从1开始),反之则返回 0。

     SELECT name,locate('张三',name) loc
     FROM user 
     WHERE name LIKE "%张三%" 
     ORDER BY CHAR_LENGTH(name),locate('张三',name);
    

    在这里插入图片描述

    instr(str,substr):返回subStrstring中出现的位置

    instr() 函数与 locate()函数效果基本相同,这里就不做过多的介绍了。

     SELECT name,instr(name,'张三') loc
     FROM user 
     WHERE name LIKE "%张三%" 
     ORDER BY CHAR_LENGTH(name),instr(name,'张三');
    

    position(substr IN str):返回subStrstring中出现的位置

     SELECT name,position('张三' IN name) loc
     FROM user 
     WHERE name LIKE "%张三%" 
     ORDER BY CHAR_LENGTH(name),position('张三' IN name);
    

    参考资料

    Mysql匹配度排序
    MYSQL 模糊查询按着匹配度排序

    展开全文
  • 一个有意思的需求——中文匹配度

    千次阅读 2017-03-23 11:43:40
     会议上,LZ简单提出了一个解决方案,就是利用分词来计算两者的匹配度,如果匹配度达到一定数值,我们就认为两个字符串是相等的。不过不论算法如何高明,准确率都不可能达到100%,这点也是LZ一再给业务同事强调的,...
    引言

     

      最近LZ带头在做一个互联网项目,互联网的东西总是那么新鲜,这也难怪大部分猿友都喜欢互联网。这个互联网项目不仅让LZ开发了一个HBase大数据应用,近期的一次需求讨论会上,又出来一个小需求,蛮有意思的。这些需求在之前枯燥的企业内部应用开发中,还是很难见到的,毕竟内部应用更多的是业务流程的体现。

      具体的需求这里不方便透露,但简单的描述一下需求,就是如何判断两个公司名是一个。这其实就是Java当中字符串的相等判断,最简单的当然是用equals来判断。但是由于实际情况是,公司名是由客户手动输出的,难免有小小的偏差,因此equals自然就不适用了。比如“博客园科技发展有限公司”和“博客园科技发展(北京)有限公司”,这两个显然应该是一个公司,但是如果用equals,自然结果会是false。

      

    方案提出

     

      会议上,LZ简单提出了一个解决方案,就是利用分词来计算两者的匹配度,如果匹配度达到一定数值,我们就认为两个字符串是相等的。不过不论算法如何高明,准确率都不可能达到100%,这点也是LZ一再给业务同事强调的,否则到时候匹配错了,他们找LZ的茬可咋办。不过好在业务同事只是希望有一个提示功能,并不做严格的判断标准,所以系统需要做的只是初步的判断,因此准确率要求并不是特别的高,只能说越高越好。

      由于这个项目是LZ以PM介入开发的,而且LZ一直都兼任SM,所以技术方案自然是LZ说了算了。没有讨论,没有异议,方案就这么在会议上定了。

     

    小研究

     

      由于LZ最近负责的事情比较多,所以上班的时候自然是没有时间研究这些东西,只能趁着周末小小研究一下。其实LZ对于分词并不是特别了解,这些东西与算法的关联度比较高,而LZ的算法基础只能说“呵呵”。不过不管怎样,作为一个项目的领头人,总得向前冲。如果到时候算法的时间、空间成本太高,或者准确率太低,等着后续寻找大神优化也不晚。

      这件事的思路比较清晰,LZ需要做的就是两件事,第一件事就是“分词”,第二件事就是“匹配”。

     

    分词

     

      分词是比较简单的一步,有很多现成的类库可以使用,只要选择一个使用就可以了。Lucene是LZ第一个想到的,毕竟LZ也算是Apache的脑残粉,因此话不多说,第一时间就下载Lucene,开始了探究之旅。

      以下是LZ在网络上找到的示例,稍微进行了一点修改。

    package com.creditease.borrow.lucene;
    
    import java.io.IOException;
    
    import org.apache.lucene.analysis.TokenStream;
    import org.apache.lucene.analysis.cn.smart.SmartChineseAnalyzer;
    import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
    import org.apache.lucene.util.Version;
    
    public class App 
    {
        public static void main( String[] args ) throws IOException
        {
            String text = "博客园科技发展(北京)有限公司";
            SmartChineseAnalyzer smartChineseAnalyzer = new SmartChineseAnalyzer(Version.LUCENE_47);
            TokenStream tokenStream = smartChineseAnalyzer.tokenStream("field", text);
            CharTermAttribute charTermAttribute = tokenStream.getAttribute(CharTermAttribute.class);
            tokenStream.reset();
            while (tokenStream.incrementToken()) {
                System.out.print(charTermAttribute.toString() + "  ");
            }
            tokenStream.end();
            tokenStream.close();
            smartChineseAnalyzer.close();
        }
        
    }

      输出结果为以下内容。

    博  客  园  科技  发展  北京  有限公司  

      这种分词结果勉强可以接受了,最理想的应该是将“博客”放在一起,不过看来Lucene的字典里没有这个词。没关系,这对我们的计划并不影响,我们接下来开始着手匹配的事。

     

    匹配

     

      有了分词,我们要做的,就是匹配两个字符串数组,并得到一个匹配度。既然是匹配度,那么肯定就有分母和分子。我们可以挑其中一个数组的长度为分母,以另外一个数组中的元素找到匹配分词的个数作为分子。为了减少程序的复杂度,我们采用Set集合的去重特点来进行计算。就像以下程序这样。

    package com.creditease.borrow.lucene;
    
    import java.io.IOException;
    import java.util.HashSet;
    import java.util.Set;
    
    import org.apache.lucene.analysis.TokenStream;
    import org.apache.lucene.analysis.cn.smart.SmartChineseAnalyzer;
    import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
    import org.apache.lucene.util.Version;
    
    public class App 
    {
        
        private static SmartChineseAnalyzer smartChineseAnalyzer = new SmartChineseAnalyzer(Version.LUCENE_47);
        
        public static void main( String[] args ) throws IOException
        {
            String text1 = "博客园科技发展(北京)有限公司";
            String text2 = "博客园科技发展有限公司";
            System.out.println(oneWayMatch(text1, text2));
        }
        
        public static double oneWayMatch(String text1,String text2) {
            try {
                Set<String> set = new HashSet<String>(10);
                TokenStream tokenStream = smartChineseAnalyzer.tokenStream("field", text1);
                CharTermAttribute charTermAttribute = tokenStream.getAttribute(CharTermAttribute.class);
                tokenStream.reset();
                while (tokenStream.incrementToken()) {
                    set.add(charTermAttribute.toString());
                }
                int denominator = set.size();
                tokenStream.end();
                tokenStream.close();
                tokenStream = smartChineseAnalyzer.tokenStream("field", text2);
                charTermAttribute = tokenStream.getAttribute(CharTermAttribute.class);
                tokenStream.reset();
                while (tokenStream.incrementToken()) {
                    set.add(charTermAttribute.toString());
                }
                int numerator = set.size() - denominator;
                double unmatchRate = ((double)numerator)/denominator;
                tokenStream.end();
                tokenStream.close();
                return unmatchRate;
            } catch (IOException e) {
                return 1D;
            }
            
        }
        
    }

      输出的结果为0,也就是说匹配度为100%。这显然是不对的,两个字符串很明显不是一模一样,得到匹配度为100%说明我们的算法还是有问题。

      仔细分析一下,问题就出在我们是拿text2中不匹配的分词作为分子,而text2中的分词在text1中全部都包含,因此分子最终会是0,那么不匹配度自然就是0(unmatchRate)。为了弥补这一缺陷,LZ想来想去最终还是决定采取“双向”(twoWay)的办法解决这个问题,可以看到LZ给上面那个方法取的名字为“单向”匹配(oneWay)。

      双向匹配其实就是将两者顺序颠倒,再进行一次匹配而已,因此我们的程序可以简单的更改为以下形式。

    package com.creditease.borrow.lucene;
    
    import java.io.IOException;
    import java.util.HashSet;
    import java.util.Set;
    
    import org.apache.lucene.analysis.TokenStream;
    import org.apache.lucene.analysis.cn.smart.SmartChineseAnalyzer;
    import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
    import org.apache.lucene.util.Version;
    
    public class App 
    {
        
        private static SmartChineseAnalyzer smartChineseAnalyzer = new SmartChineseAnalyzer(Version.LUCENE_47);
        
        public static void main( String[] args ) throws IOException
        {
            String text1 = "博客园科技发展(北京)有限公司";
            String text2 = "博客园科技发展有限公司";
            System.out.println(twoWayMatch(text1, text2));
        }
        
        public static double twoWayMatch(String text1,String text2) {
            return (oneWayMatch(text1, text2) + oneWayMatch(text2, text1));
        }
        
        public static double oneWayMatch(String text1,String text2) {
            try {
                Set<String> set = new HashSet<String>(10);
                TokenStream tokenStream = smartChineseAnalyzer.tokenStream("field", text1);
                CharTermAttribute charTermAttribute = tokenStream.getAttribute(CharTermAttribute.class);
                tokenStream.reset();
                while (tokenStream.incrementToken()) {
                    set.add(charTermAttribute.toString());
                }
                int denominator = set.size();
                tokenStream.end();
                tokenStream.close();
                tokenStream = smartChineseAnalyzer.tokenStream("field", text2);
                charTermAttribute = tokenStream.getAttribute(CharTermAttribute.class);
                tokenStream.reset();
                while (tokenStream.incrementToken()) {
                    set.add(charTermAttribute.toString());
                }
                int numerator = set.size() - denominator;
                double unmatchRate = ((double)numerator)/denominator;
                tokenStream.end();
                tokenStream.close();
                return unmatchRate;
            } catch (IOException e) {
                return 1D;
            }
            
        }
        
    }

      该程序的输出结果为0.1666666666...,也就是0.17,也就是说两者的匹配度为83%。这个值显然更加接近实际的情况。可以看到,双向匹配以单向匹配为基础,将顺序颠倒的结果相加,就能得到不匹配度。

      事情原本到此就可以结束了,但是还有一个更大的难点没有处理。那就是匹配度到底设置为多少合适。这个问题到目前为止,LZ还没有更好的办法。按照上面的小例子来讲,自然是设为80%就可以。

      但是看下下面这个例子,就会发现这个数值很不正确,或者说匹配算法还是有问题。

    public static void main( String[] args ) throws IOException
        {
            String text1 = "博客园科技发展(北京)有限公司";
            String text2 = "博客园有限公司";
            System.out.println(twoWayMatch(text1, text2));
        }

      运行的结果为0.75,也就是说匹配度大约只有25%。但是很明显,上面两个公司实际上匹配度是很高的,因为最重要的三个字是匹配的。

      再仔细分析一下,问题就变成权重了。也就是说,每个词的权重应该是不一样的,这样的话,匹配的准确度可能会更高一点。我们稍微改善一下程序。(以下统一使用后面加双斜线的方式表示程序主要改变的地方)

    package com.creditease.borrow.lucene;
    
    import java.io.IOException;
    import java.util.Arrays;
    import java.util.HashSet;
    import java.util.List;
    import java.util.Set;
    
    import org.apache.lucene.analysis.TokenStream;
    import org.apache.lucene.analysis.cn.smart.SmartChineseAnalyzer;
    import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
    import org.apache.lucene.util.Version;
    
    public class App 
    {
        
        private static SmartChineseAnalyzer smartChineseAnalyzer = new SmartChineseAnalyzer(Version.LUCENE_47);
        
        private static List<String> smallWeightWords = Arrays.asList("公司","有限公司","科技","发展","股份");
        
        private static double smallWeight = 0.3D;
        
        public static void main( String[] args ) throws IOException
        {
            String text1 = "博客园科技发展(北京)有限公司";
            String text2 = "博客园有限公司";
            System.out.println(twoWayMatch(text1, text2));
        }
        
        public static double twoWayMatch(String text1,String text2) {
            return (oneWayMatch(text1, text2) + oneWayMatch(text2, text1));
        }
        
        public static double oneWayMatch(String text1,String text2) {
            try {
                Set<String> set = new HashSet<String>(10);
                TokenStream tokenStream = smartChineseAnalyzer.tokenStream("field", text1);
                CharTermAttribute charTermAttribute = tokenStream.getAttribute(CharTermAttribute.class);
                tokenStream.reset();
                while (tokenStream.incrementToken()) {
                    set.add(charTermAttribute.toString());
                }
                int denominator = set.size();
                tokenStream.end();
                tokenStream.close();
                tokenStream = smartChineseAnalyzer.tokenStream("field", text2);
                charTermAttribute = tokenStream.getAttribute(CharTermAttribute.class);
                tokenStream.reset();
                int smallWeightWordsCount = 0;//
                while (tokenStream.incrementToken()) {
                    String word = charTermAttribute.toString();//
                    int tempSize = set.size();//
                    set.add(word);//
                    if (tempSize + 1 == set.size() && smallWeightWords.contains(word)) {//
                        smallWeightWordsCount++;//
                    }//
                }
                int numerator = set.size() - denominator;
                double unmatchRate = (smallWeightWordsCount * smallWeight + numerator - ((double)smallWeightWordsCount))/denominator;//
                tokenStream.end();
                tokenStream.close();
                return unmatchRate;
            } catch (IOException e) {
                return 1D;
            }
            
        }
        
    }

      现在程序的输出结果为0.4,匹配度为60%。从结果来看,依然有点不尽人意。仔细分析一下程序,会发现,我们计算不匹配度的时候,是交叉计算的。也就是说,我们使用一个数组中不匹配的数目去除以另外一个数组的大小,这可能会造成“极端”数值。

      我们需要调整程序,让数组自己与自己计算,这样就不会出现那种情况。如下。

    package com.creditease.borrow.lucene;
    
    import java.io.IOException;
    import java.util.Arrays;
    import java.util.HashSet;
    import java.util.List;
    import java.util.Set;
    
    import org.apache.lucene.analysis.TokenStream;
    import org.apache.lucene.analysis.cn.smart.SmartChineseAnalyzer;
    import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
    import org.apache.lucene.util.Version;
    
    public class App 
    {
        
        private static SmartChineseAnalyzer smartChineseAnalyzer = new SmartChineseAnalyzer(Version.LUCENE_47);
        
        private static List<String> smallWeightWords = Arrays.asList("公司","有限公司","科技","发展","股份");
        
        private static double smallWeight = 0.3D;
        
        public static void main( String[] args ) throws IOException
        {
            String text1 = "博客园科技发展(北京)有限公司";
            String text2 = "博客园有限公司";
            System.out.println(twoWayMatch(text1, text2));
        }
        
        public static double twoWayMatch(String text1,String text2) {
            return (oneWayMatch(text1, text2) + oneWayMatch(text2, text1));
        }
        
        public static double oneWayMatch(String text1,String text2) {
            try {
                Set<String> set = new HashSet<String>(10);
                TokenStream tokenStream = smartChineseAnalyzer.tokenStream("field", text1);
                CharTermAttribute charTermAttribute = tokenStream.getAttribute(CharTermAttribute.class);
                tokenStream.reset();
                while (tokenStream.incrementToken()) {
                    set.add(charTermAttribute.toString());
                }
                int originalCount = set.size();//
                tokenStream.end();
                tokenStream.close();
                tokenStream = smartChineseAnalyzer.tokenStream("field", text2);
                charTermAttribute = tokenStream.getAttribute(CharTermAttribute.class);
                tokenStream.reset();
                int smallWeightWordsCount = 0;
                int denominator = 0;//
                while (tokenStream.incrementToken()) {
                    denominator++;//
                    String word = charTermAttribute.toString();
                    int tempSize = set.size();
                    set.add(word);
                    if (tempSize + 1 == set.size() && smallWeightWords.contains(word)) {
                        smallWeightWordsCount++;
                    }
                }
                int numerator = set.size() - originalCount;
                double unmatchRate = (smallWeightWordsCount * smallWeight + numerator - ((double)smallWeightWordsCount))/denominator;//
                tokenStream.end();
                tokenStream.close();
                return unmatchRate;
            } catch (IOException e) {
                return 1D;
            }
            
        }
        
    }

      程序的输出结果为0.2285714285714286,也就是匹配度大约为77%,这个数值还是比较科学的。这次我们主要调整了分母,将分母调整为不匹配元素自己的数组大小。

      现在我们需要做的就很简单了,就是把有可能改变的地方都在程序当中做成可配置的,比如从数据库读取。需要做成可配置项的内容有以下几个。

      1、低权重的词语,也就是smallWeightWords。

      2、低权重的数值,也就是smallWeight。

      3、匹配度的最小值,也就是说匹配度大于等于多少的时候,我们就认为是一个公司。

      具体如何做成可配置项,这里LZ就不再赘述了,真实的web项目当中有无数种办法可以达到这个目的,最常用的当然是存储到数据库。但第一项更适合放入数据库,后面两项更适合存放在配置文件当中。无论放在哪里,这些配置都要支持动态刷新,这样应用在运行的时候就可以动态调整判断规则了。

      

    小结

     

      LZ的算法不一定是最好的,或者说一定不是最好的。但是有时候慢慢解决一个问题,让答案逐渐靠近自己的判断也是一种乐趣不是吗?

    展开全文
  • 保险公司岗位匹配度自我评价.doc
  • 最新岗位匹配度自我评价学习总结.doc
  • 在区间值模糊推理过程中,为合理地计算输入事实与规则前件的匹配程度,给出区间值模糊集的模糊加权均衡匹配度的定义,不仅考虑了每个前件分量在推理中的不同影响程度,而且考虑到每个分量匹配程度的均衡要求,进而...
  • 项目里有一个新的需求,在检索处原先只有根据各个字段的模糊查询,按照我项目中的例子是 中文名,英文名...那么言归正传,主要就是对order by部分进行匹配度的计算,这里需要用到 case when 表达式 因为我需要匹配好几

    项目里有一个新的需求,在检索处原先只有根据各个字段的模糊查询,按照我项目中的例子是 中文名,英文名以及负责人。那么有时候在匹配的字段很多的情况下,如果只输入’ms’(数据库中刚好有这样的英文名) 这个正好匹配的字段原则上要显示在第一列,或者说匹配程度越好的要显示在越前面,而不仅仅是一连串的返回匹配到的结果而已。查询结果有10多页,那个提需求的老哥 我能感受到他找这条数据的痛苦。。。

    case 表达式

    那么言归正传,主要就是对order by部分进行匹配度的计算,这里需要用到 case when 表达式 因为我需要匹配好几个字段。
    在case 里面可以有多个when then else的三元表达式

    匹配度的计算

    这里首先将字段中我们待查询的子串变为空字符串,然后比较剩余字符串长度 与原来字符串长度的比值

    length(REPLACE(cn.cn_name,‘ms’,’’))/length(cn.cn_name)

    比如说 abcms 在经历 替换以后 变成 abc 比值为 3/5
    以及 amsdsms 在经历 替换以后 变成 ads 比值为 3/7
    可以发现如果结果越小,表示被替换的值就越多,也就是匹配度越高,那么按照order by的升序排列,就会在越前面被显示出来

    SQL语句

    select cn.cn_name,cn.en_name ,cn.maintainer
    from code_repo.code_new as cn
    where
    	
    	cn.cn_name like "%ms%" or
    		cn.en_name like "%ms%" or
    		cn.maintainer like "%ms%" 
    order by
    	case
    	 when cn.cn_name like "%ms%" then length(REPLACE(cn.cn_name,'ms',''))/length(cn.cn_name)
    	 when cn.en_name like "%ms%" then length(REPLACE(cn.en_name,'ms',''))/length(cn.en_name)
    	 when cn.maintainer like "%ms%" then length(REPLACE(cn.maintainer,'ms',''))/length(cn.maintainer)
    	end
    	
    

    结果如下图所示:
    在这里插入图片描述

    展开全文
  • Mysql匹配度排序

    2019-10-24 15:45:21
    我们在用Mysql进行模糊查询的时候,Mysql自己做不到按照匹配度去排序,那么要按匹配度排序的话,我们自己要自己对sql进行改造 正常模糊查询sql如下 运行sql可以看到,包含罗马的信息有很多,但是我只搜了罗马,而...
  • sql模糊查询并按匹配度排序

    热门讨论 2010-06-18 11:49:12
    select Top 20 * from [dbo].[core_product_main] where (1=1) and 字段名 like '%字段值%' order by abs(len(字段名)-len('字段值'))
  • C#图像识别轮廓并计算匹配度

    热门讨论 2012-04-26 11:27:16
    C#应用emgu进行图像处理及其界面显示
  • 【Oracle】模糊查询&按匹配度排序

    千次阅读 2019-12-17 20:47:15
    select t.zh_name from psn_ins t where t.ins_id = 857 and t.zh_name like '%' || '肖锐' || '%'; select t.zh_name from sie2.psn_ins t where t.ins_id = 857 and t.zh_name like '%' || '肖锐' || '%' ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 404,615
精华内容 161,846
关键字:

匹配度

友情链接: MyFaceRec.rar