标签: duplicates

我有一个对象数组需要删除/过滤重复项.我只是在Object元素上覆盖equals&hachCode,然后将它们粘贴在Set中......但我认为我至少应该轮询stackoverflow以查看是否有其他方法,或许某些其他API的聪明方法？

我有一个生成测试并预测输出的工具.我的想法是,如果我失败了,我可以将预测与实际输出进行比较,看看它们分歧的地方.问题是实际输出包含两行,这令人困惑diff.我想删除重复项,以便我可以轻松地比较它们.基本上,类似sort -u但没有排序的东西.

是否有任何unix命令行工具可以执行此操作？

我有一个表在Name列中有很多重复.我想每个只保留一行.

下面列出了重复项,但我不知道如何删除重复项,只保留一个副本:

SELECT name FROM members GROUP BY name HAVING COUNT(*) > 1;

谢谢.

我对特定视图的SQL查询返回3个不同的行.

 select * from vwSummary
 where vidate >= '10-15-2010' and vidate <= '10-15-2010'
 and idno = '0330'
 order by viDate

但是,如果我通过我的实体框架运行相同的查询,我得到3行,但所有3行都相同,相当于第三行.

        firstVisibleDate = new DateTime(2010, 10, 15);

        lastVisibleDate = new DateTime(2010, 10, 15);

var p1 = (from v in db.vwSummary
                     where v.viDate >= firstVisibleDate && v.viDate <= lastVisibleDate
                     && v.IDNo == "0330"
                          select v).ToList();

有人可以帮我解决这个问题.

编辑: 我改变了我的查询,这是有效的.但是我仍然想回到上面显示的那个,因为我必须再次迭代以进行更多处理.

List<objectName> p1 = (from v in db.vwSummary
                     where v.viDate >= firstVisibleDate && v.viDate <= lastVisibleDate
                     && v.IDNo == "0330"
                          select new <ObjectName>
{ …

在阅读了这个有趣的问题之后,我想起了曾经有过一次我从未满意地回答的棘手面试问题:

给出一个n个32位无符号整数的数组,其中每个元素(除了一个)重复三次.在O(n)时间内并使用尽可能少的辅助空间,找到不出现三次的数组的元素元素.

举个例子,给定这个数组:

1 1 2 2 2 3 3 3 3 3 3

给定数组时,我们输出1

3 2 1 3 2 1 2 3 1 4 4 4 4

我们输出4.

这可以通过使用哈希表计算每个元素的频率在O(n)时间和O(n)空间中轻松解决,但我强烈怀疑,因为问题语句特别提到数组包含32位无符号整数有一个更好的解决方案(我猜O(1)空间).

有没有人对如何解决这个问题有任何想法？

我想用ManyToMany关系来保持我的实体.但是在持久化过程中我遇到了一些问题.

我的实体:

@Entity
@Table(name = "USER")
public class User implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id
    @Column(name = "ID")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    Long userId;

    @Column(name = "NAME", unique = true, nullable = false)
    String userName;

    @Column(name = "FORNAME")
    String userForname;

    @Column(name = "EMAIL")
    String userEmail;

    @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    @JoinTable(name = "USER_USER_ROLES", joinColumns = @JoinColumn(name = "ID_USER"), inverseJoinColumns = @JoinColumn(name = "ID_ROLE"))
    List<UserRoles> userRoles = new ArrayList<UserRoles>();

    // getter et setter
}

和

@Entity …

可能重复:
在MySQL中查找重复记录

我在MySQL中有一个像这样的表:

ID    name    email
1    john     abc@abc.com
2    johnny   abc@abc.com
3    jim      eee@eee.com
4    Michael  abec@awwbc.com

我怎么能有MySQL查询将列出这样的重复一个？

重复搜索的结果:

ID    name    email         Duplicate
1    john     abc@abc.com      2
2    johnny   abc@abc.com      2

我正在处理与sqlalchemy的多对多关系.我的问题是如何避免在多对多关系表中添加重复的对值.

为了使事情更清楚,我将使用官方SQLAlchemy文档中的示例.

Base = declarative_base()

Parents2children = Table('parents2children', Base.metadata,                                                                                                                                                                                                     
  Column('parents_id', Integer, ForeignKey('parents.id')),                                                                                                                                                                                                       
  Column('children_id', Integer, ForeignKey('children.id'))
)

class Parent(Base):
    __tablename__ = 'parents'
    id = Column(Integer, primary_key=True)
    parent_name = Column(String(45))
    child_rel = relationship("Child", secondary=Parents2children, backref= "parents_backref") 

    def __init__(self, parent_name=""):
        self.parent_name=parent_name
    def __repr__(self):
        return "<parents(id:'%i', parent_name:'%s')>" % (self.id, self.parent_name)

class Child(Base):
    __tablename__ = 'children'
    id = Column(Integer, primary_key=True)
    child_name = Column(String(45))

    def __init__(self, child_name=""):
        self.child_name= child_name
    def __repr__(self):
        return "<experiments(id:'%i', child_name:'%s')>" % (self.id, self.child_name)

###########################################

def setUp():
    global Session
    engine=create_engine('mysql://root:root@localhost/db_name?charset=utf8', pool_recycle=3600,echo=False)
    Session=sessionmaker(bind=engine)

def …

我有2,500,000个产品名称,我想尝试将它们组合在一起,即找到名称相似的产品.例如,我可以有三种产品:

• 亨氏焗豆400克;
• Hz Bkd Beans 400g;
• 亨氏豆400克.

这实际上是相同的产品,可以合并在一起.

我的计划是使用Jaro Winkler的距离算法来实现匹配.该过程如下:

• 列出内存中所有产品名称的大清单;
• 选择列表中的第一个产品;
• 将它与列表中的每个产品进行比较并计算出"Jaro分数";
• 报告任何具有高匹配(例如0.95f或更高)的产品;
• 转到下一个产品.

所以这有一些优化,因为它只对每个产品进行单向匹配,节省了一半的处理时间.

我把它编码并测试了它.它运作完美,并发现了数十个匹配的调查.

将1个产品与2,500,000个其他产品进行比较需要大约20秒钟,并计算出"Jaro评分".假设我的计算是正确的,这意味着它将花费一年的最佳时间来完成处理.

显然这不实用.

我让同事们查看代码,他们设法将Jaro分数计算部分的速度提高了20%.他们使这个过程成为多线程,并使其更快一点.我们还删除了一些存储的信息,将其简化为产品名称和唯一标识符列表; 这似乎对处理时间没有任何影响.

通过这些改进,我们仍然认为这需要几个月的时间来处理,我们需要花费数小时(或最多几天).

我不想详细介绍,因为我认为这不是完全相关的,但我将产品详细信息加载到列表中:

private class Product
{
    public int MemberId;
    public string MemberName;
    public int ProductId;
    public string ProductCode;
    public string ProductName;
}
private class ProductList : List<Product> { }
private readonly ProductList _pl = new ProductList();

然后我使用以下处理每个产品:

{Outer loop...
var match = _pl[matchCount];

for (int count = 1; count < _pl.Count; count++)
{
    var search = _pl[count];
    //Don't match …

我收到了这个问题进行练习，措词使我感到困惑，因为我看到了可能想要的2个结果。

无论哪种方式，我都希望看到两种解决方案。

例如，如果我有一个数组：

let arr = [1, 2, 4, 2, 3, 3, 4, 5, 5, 5, 8, 8, 9, 10];

我认为这是想要最终结果的一种：

let finalResult = [1, 2, 3, 4, 5, 8, 9, 10];

要么：

let finalResult = [1, 9, 10];

两者之间的区别在于，一个只是删除所有重复的数字，剩下其余部分，第二个只是想要任何非重复的数字。

无论哪种方式，我都想编写两个函数，每个函数执行一个。

这是别人给的，这是我的第二个解决方案。

let elems = {},

arr2 = arr.filter(function (e) {
   if (elems[e] === undefined) {
       elems[e] = true;
    return true;
  }
  return false;
});
console.log(arr2);

我不确定第一个功能（删除所有重复项）。