Вопросы Теги

Python - объединение общих элементов в список списков [duplicate]

Это одно из мест, с помощью которого привязка данных, используемая во многих новых фреймворках JavaScript, будет очень полезна для вас ...

Итак, если вы используете Angular, React или любые другие фреймворки, которые делают два способа связывания данных, эта проблема просто исправлена ​​для вас, поэтому простым языком ваш результат undefined на первом этапе, поэтому вы получили result = undefined до получения данных, а затем, как только вы получите результат , он будет обновляться и присваиваться новому значению, которое отвечает на ваш вызов Ajax ...

Но как вы можете сделать это в чистом javascript или jQuery, например, как вы задали этот вопрос?

Вы можете использовать обратный вызов, обещание и недавно наблюдаемое, чтобы обрабатывать его для вас, например, в обещаниях мы имеем некоторые функции, такие как success () или then (), которые будут выполняться, когда ваши данные будут готовы для вас, с функцией обратного вызова или подписки на наблюдаемые.

Например, в вашем случае, в котором вы используете jQuery, вы можете сделать что-то вроде этого: 

$(document).ready(function(){
    function foo() {
        $.ajax({url: "api/data", success: function(data){
            fooDone(data); //after we have data, we pass it to fooDone
        }});
    };

    function fooDone(data) {
        console.log(data); //fooDone has the data and console.log it
    };

    foo(); //call happens here
});

Для получения дополнительной информации n изучение обещаний и наблюдаемых, которые являются новыми способами для создания асинхронных материалов.

3
задан Kasramvd 19 November 2014 в 13:27
поделиться

2 ответа

Интересная проблема!

Вот моя попытка, я уверен, что это не самый эффективный способ 

a = [(1, 5), (4, 2), (4, 3), (5, 4), (6, 3), (7, 6), (8, 9)]
# a = [(1, 5), (4, 2), (4, 3), (5, 4), (6, 3), (7, 6)]

d = {tuple(t): set(t) for t in a}  # forces keys to be unique

while True:
    for tuple_, set1 in d.items():
        try:
            match = next(k for k, set2 in d.items() if k != tuple_ and set1 & set2)
        except StopIteration:
            # no match for this key - keep looking
            continue
        else:
            print('merging', tuple(set1), match)
            d[tuple_] = set1 | d.pop(match)
            break
    else:
        # no match for any key - we are done!
        break

output = sorted(tuple(s) for s in d.values())
print(output)

Результат был таким: 

merging (4, 5) (1, 5)
merging (1, 4, 5) (4, 3)
merging (1, 3, 4, 5) (6, 3)
merging (1, 3, 4, 5, 6) (7, 6)
merging (1, 3, 4, 5, 6, 7) (4, 2)
[(1, 2, 3, 4, 5, 6, 7), (8, 9)]
4
ответ дан wim 24 August 2018 в 03:20
поделиться

Взгляните на эту реализацию, это быстро, потому что она использует Disjoint set с сжатием пути, и операции поиска и слияния - log (n): 

class DisjointSet(object):

    def __init__(self,size=None):
        if size is None:
            self.leader = {}  # maps a member to the group's leader
            self.group = {}  # maps a group leader to the group (which is a set)
            self.oldgroup = {}
            self.oldleader = {}
        else:
            self.group = { i:set([i]) for i in range(0,size) }
            self.leader = { i:i for i in range(0,size) }
            self.oldgroup = { i:set([i]) for i in range(0,size) }
            self.oldleader = { i:i for i in range(0,size) }                

    def add(self, a, b):
        self.oldgroup = self.group.copy()
        self.oldleader = self.leader.copy()
        leadera = self.leader.get(a)
        leaderb = self.leader.get(b)
        if leadera is not None:
            if leaderb is not None:
                if leadera == leaderb:
                    return  # nothing to do
                groupa = self.group[leadera]
                groupb = self.group[leaderb]
                if len(groupa) < len(groupb):
                    a, leadera, groupa, b, leaderb, groupb = b, leaderb, groupb, a, leadera, groupa
                groupa |= groupb
                del self.group[leaderb]
                for k in groupb:
                    self.leader[k] = leadera
            else:
                self.group[leadera].add(b)
                self.leader[b] = leadera
        else:
            if leaderb is not None:
                self.group[leaderb].add(a)
                self.leader[a] = leaderb
            else:
                self.leader[a] = self.leader[b] = a
                self.group[a] = set([a, b])

    def connected(self, a, b):
        leadera = self.leader.get(a)
        leaderb = self.leader.get(b)
        if leadera is not None:
            if leaderb is not None:
                return leadera == leaderb
            else:
                return False
        else:
            return False

    def undo(self):        
        self.group = self.oldgroup.copy()
        self.leader = self.oldleader.copy()


def test():
    x = DisjointSet()
    x.add(0,1)
    x.add(0,2)
    x.add(3,4)
    x.undo()
    print x.leader
    print x.group

if __name__ == "__main__":
    test()

Вы также можете отменить последнее добавление. В вашем случае вы можете сделать следующее: 

import DisjointSet
a = [(1, 5), (4, 2), (4, 3), (5, 4), (6, 3), (7, 6)]
d = DisjointSet()
for e in a:
    d.add(*e)
print d.group
print d.leader
1
ответ дан linello 24 August 2018 в 03:20
поделиться
Другие вопросы по тегам:

Похожие вопросы: