Vfrdtyky

Ive been given a problem where given two lists, returns the list of all the elements that occur multiple times in both lists. The returned list should be in ascending order, without duplicates. Your main program will allow the enter two lists of numbers on one line separated by a semicolon and end input with a blank line. For example

Lists: 1 3 4 2 1 2 1 3; 4 4 2 4 3 2 4 4 3 1 3

List1: 1 3 4 2 1 2 1 3

List 2: 4 4 2 4 3 2 4 4 3 1 3

The result for this example would be: [2, 3]

I have a majority of the programming working, its just that after implementing the first for loop in the calculator function, I get an error.
ValueError: invalid literal for int() with base 10: '3;'

It may be a possibility that due to my inexperience there is a syntax error somewhere. Any help or advice is greatly appreciated.

def calculator(userinput):

    marker = ":"



    for x in userinput:

        if x == ";":

            marker = ";" 

        elif marker != ";":  

            numlist1 = [int(x) for x in userinput]

        elif marker == ";":  numlist2

            numlist2 = [int(x) for x in userinput]

        else:

            pass



    for y in numlist1:

        list1 = numlist1.count(y)

        list2 = numlist2.count(y)

        if list1 > 1 and list2 > 1:

            if y not in multiples:

                multiples.append(int(y))

            else:

                continue



    multiples.sort()

    print(multiples)



while True:



    multiples = 



    userinput = input("Lists: ").split() # asks for first input from user

    if len(userinput) == 0:  # breaks if user inputs nothing

        break



    calculator(userinput)  # calls the calculator function

I believe this does what you want …

$ cat intersec_two_list.py

#!/bin/env python



import sys

import collections



def intersect_list(lst1, lst2):

    return sorted(list(set(lst1) & set(lst2)))



def find_mult(lst1, lst2):

    c1 = collections.Counter(lst1)

    mc1 = [mc[0] for mc in c1.items() if mc[1] > 1]

    c2 = collections.Counter(lst2)

    mc2 = [mc[0] for mc in c2.items() if mc[1] > 1]

    return intersect_list(mc1, mc2)



def main(l1,l2):

        print find_mult(l1,l2)



if __name__ == "__main__":

        user_input = sys.argv[1:][0]

        [s1, s2] = user_input.split(';')

        s1 = s1.strip()

        s2 = s2.strip()

        l1 = s1.split(' ')

        l2 = s2.split(' ')

        main(l1,l2)

You would execute like so ...

$ ./intersec_two_list.py "1 3 4 2 1 2 1 3; 4 4 2 4 3 2 4 4 3 1 3"

['2', '3']

Here is some explanation of the code above:

def intersect_list(lst1, lst2):

    return sorted(list(set(lst1) & set(lst2)))

In this method I set() to remove duplications from the lists.

>>> list = [ 1,2,3,3,3,3,4,5,6,6,6]

>>> set(list)

{1, 2, 3, 4, 5, 6} 

Then we use & like so set(lst1) & set(lst2) to get a intersection of the two sets then convert that back to a list with list(set(lst1) & set(lst2)) and then we return a sorted list.

In this method …

def find_mult(lst1, lst2):

    c1 = collections.Counter(lst1)

    mc1 = [mc[0] for mc in c1.items() if mc[1] > 1]

    c2 = collections.Counter(lst2)

    mc2 = [mc[0] for mc in c2.items() if mc[1] > 1]

    return intersect_list(mc1, mc2)

… use make use of Counter's. What a counter does is this:

>>> from collections import Counter

>>> list1 = [1,2,3,3,3,3,4,5,6,6,6]

>>> Counter(list1)

>>> Counter({3: 4, 6: 3, 1: 1, 2: 1, 4: 1, 5: 1})

It counts the elements of a list. This way we can get rid of all the elements in out list that did not occur more than once like so:

mc1 = [mc[0] for mc in c1.items() if mc[1] > 1]

The above is list comprehension which a short had for this python code:

mc1 = 

for mc in c1.items():

    if mc[1] > 1:

        mc1.append(mc[0])

Then key to above code is c1.items(). c1 is a collection and collections have a method items() which return a list of (elem, cnt) pairs from the collections. So if mc[1] > 1 means the element occurred more than once and mc[0] is the element. We save these elements in a list called mc1.

We do the same process on lst2. We create collection, c2 and create a list mc2. Now we get the intersection of mc1 and mc2 and return that and BAM! your done.