Your task is to remove all duplicate words from a string, leaving only single (first) words entries.

Example:

Input:

'alpha beta beta gamma gamma gamma delta alpha beta beta gamma gamma gamma delta'

Output:

'alpha beta gamma delta'

Difficulty: introductory

Starter code:

def remove_duplicate_words(s):
	

Solutions:
def remove_duplicate_words(s):
    return ' '.join(dict.fromkeys(s.split()))

def remove_duplicate_words(s):
    s = s.split(" ")
    words = []
    for item in s:
        if item not in words:
            words.append(item)
    return " ".join(words)


def remove_duplicate_words(s):
    return ' '.join(sorted(set(s.split()), key = s.index))

def remove_duplicate_words(s):
    a=[]
    [a.append(v) for v in s.split(" ") if v not in a]
    return str(" ").join(a)

def remove_duplicate_words(s):
    def f():
        seen = set()
        for word in s.split():
            if word in seen:
                continue
            seen.add(word)
            yield word
    return ' '.join(f())

from collections import OrderedDict
remove_duplicate_words=lambda s:' '.join(OrderedDict.fromkeys(s.split(' ')))


def remove_duplicate_words(s):
    new_list = []
    for word in s.split():
        if word not in new_list:
            new_list.append(word)
    return " ".join(new_list)

d = {}
remove_duplicate_words = lambda s: " ".join(d.setdefault(w, w) for w in s.split() if w not in d)

remove_duplicate_words=lambda s:(lambda x:' '.join(e for i,e in enumerate(x)if e not in x[:i]))(s.split())

def remove_duplicate_words(s):
    return ' '.join({i:0 for i in s.split()})

def remove_duplicate_words(s):
    res = {}
    for i,n in enumerate(s.split()):
        if n not in res:
            res[n] = i
    
    return ' '.join(sorted(res, key=res.get))

def remove_duplicate_words(s):
    return ' '.join(((s.split())[i] for i in range(len(s.split())) if (s.split())[i] not in (s.split())[0:i]))

def remove_duplicate_words(s):
    present = []
    for word in s.split(" "):
        if word not in present: present.append(word)
    return " ".join(present)

def remove_duplicate_words(s):
    seen = set()
    result = []
    for word in list(s.split(" ")):
        if word not in seen:
            seen.add(word)
            result.append(word)
    return " ".join(result)

def remove_duplicate_words(s):
    l = s.split()
    words = []
    for elt in l:
        if elt not in words:
            words.append(elt)
    return " ".join(words)

def remove_duplicate_words(s):
    s_list = s.split()
    new_list = []
    for word in s_list:
        if word not in new_list:
            new_list.append(word)
    return ' '.join(new_list)

def remove_duplicate_words(s):
    s = s.split()
    unique = []
    for word in s:
        if word not in unique:
            unique.append(word)
    s = ' '.join(unique)


    return s

def remove_duplicate_words(s):
    final = []
    for s in s.split():
        if s not in final:
            final.append(s)
    return ' '.join(final)

def remove_duplicate_words(s):
    tot = []
    for i in s.split():
        if i not in tot:
            tot.append(i)
    return ' '.join(tot)
    
    return ' '.join(tot)

from functools import reduce
def remove_duplicate_words(s):
    return ' '.join(reduce(lambda l, x: l+[x] if x not in l else l, s.split(' '), []))

def remove_duplicate_words(s):
    arr = s.split()
    arr1 = []
    for el in arr:
        if not el in arr1:
            arr1.append(el)
    return " ".join(arr1)


def remove_duplicate_words(s):
    ss=list(set(s.split()))
    ss.sort(key=s.index)
    return ' '.join(ss)

def remove_duplicate_words(s):
    o = []
    x = s.split()
    for y in x:
        if(y not in o):
            o.append(y)
    return ' '.join(o)

def remove_duplicate_words(s):
    result = []
    [result.append(w) for w in s.split(' ') if not w in result]
    return ' '.join([x for x in result])

remove_duplicate_words = lambda s:" ".join(dict.fromkeys(s.split()))

def remove_duplicate_words(s):
    a = []
    for i in s.split():
        if i not in a:
            a.append(i)
    return " ".join(a)

def remove_duplicate_words(s):
    array = s.split()
    output = []
    for word in array:
        if word not in output:
            output.append(word)
    return ' '.join(output)

def remove_duplicate_words(s):
    result_list = []
    for word in s.split():
        if word not in result_list:
            result_list.append(word)
    return ' '.join(result_list)


def remove_duplicate_words(s):
    my_set = []
    for word in s.split(" "):
        try:
            my_set.index(word)
        except ValueError:
            my_set.append(word)
    return " ".join(my_set)

def remove_duplicate_words(s):
    already = []
    for i in s.split():
        if i in already:
            continue
        if i not in already:
            already.append(i)
    return ' '.join(already)


def remove_duplicate_words(s):
    output = []
    s = s.split()
    for word in s:
        if word not in output:
            output.append(word)
    return " ".join(output)

def remove_duplicate_words(s):
    d=s.split()
    d=list(dict.fromkeys(d))
    print(d)
    anwser = " ".join(d)
    return anwser

def remove_duplicate_words(s):
    lt = []
    for i in s.split():
        if i not in lt:
            lt.append(i)
    return " ".join(lt)

from functools import reduce

def remove_duplicate_words(s):
    return reduce(lambda res, curr: res if curr in res else res + ' ' + curr, s.split(), '').lstrip()

def remove_duplicate_words(s):
    removed = s.split()
    newlist = []
    for i in removed:
        if(i not in newlist):
            newlist.append(i)
    newstring = " ".join(newlist)
    return newstring
            



def remove_duplicate_words(s):
    arr=s.split()
    new=[]
    for i in arr:
        if i not in new:
            new.append(i)
    return " ".join(new)

def remove_duplicate_words(s):
    arr = s.split()
    res_list = []
    for elem in arr:
        if not elem in res_list:
            res_list.append(elem)
    return " ".join(res_list)

def remove_duplicate_words(s):
    arr = s.split()
    new_arr = []
    for el in arr:
        if not el  in new_arr:
            new_arr.append(el)
    return  ' '.join(new_arr)
 
        


def remove_duplicate_words(s):
    
    l = []
    
    for i in s.split():
        if not i in l:
            l.append(i)
        else:
            pass
    return ' '.join(l)

def remove_duplicate_words(s):
    split = s.split(' ')
    end = []
    for word in split: 
        if word in end:
            continue;
        end.append(word)
    return ' '.join(end)


def remove_duplicate_words(s):
    single=[]
    for x in s.split():
        if x not in single:
            single.append(x)
    return ' '.join(single)


def remove_duplicate_words(s):
    lst = s.split()
    lst_new = []
    for i in lst:
        if i not in lst_new:
            lst_new.append(i)
    
    
    return ' '.join(lst_new)

def remove_duplicate_words(s):
    s_list = s.split()
    result_list = []
    
    for word in s_list:
        if word not in result_list:
            result_list.append(word)
    
    return " ".join(result_list)

def remove_duplicate_words(s):
    cadena = s.split()
    cadena2 = []
    cadena3 = " "
    for i in cadena:
        if i in cadena2:
            pass
        else:
            cadena2.append(i)
    cadena3 = cadena3.join(cadena2)
    return cadena3

def remove_duplicate_words(s):
    new = ''
    sSplit = s.split(' ')
    print(sSplit)
    for i in sSplit:
        if i not in new:
            new += i + " "

    return new.rstrip()

def remove_duplicate_words(s):
    s = s.split(' ')
    a = ''
    for x in range(len(s)):
        if s[x] not in a:
            a += s[x]+' '
    return a[:-1]

def remove_duplicate_words(s):
    x=[s for s in s.split()]
    ans=[]
    for y in x:
        if y not in ans:
            ans.append(y)
    return "".join( x +" " for x in ans)[:-1]

def remove_duplicate_words(s):
    list_of_words = s.split()
    compressed = []
    for word in list_of_words:
        if word not in compressed:
            compressed.append(word)
        else:
            pass

    compressed_to_string = ' '.join(compressed)
    return compressed_to_string

def remove_duplicate_words(s):
    string = []
    for i in s.split():
        if i not in string:
            string.append(i)
    return ' '.join(string)

#Non-regex solution

def remove_duplicate_words(sentence):
    lst=[sentence][0].split()    #split sentence by words and turn into list
    
    no_dbls=list(dict.fromkeys(lst))  #remove doubles from list
    
    return (' '.join(no_dbls))        #turn list back to sentence

def remove_duplicate_words(s):
    output = []
    for word in s.split():
        if not word in output: output.append(word)
    return ' '.join(output)

def remove_duplicate_words(x):
    y = []
    for i in x.split():
        if i in y:
            pass
        else:
            y.append(i)
    
    return ' '.join(y)

def remove_duplicate_words(s):
    no_dup = []
    no_dup1 = []
    for c in s.split(' '):
        if c not in no_dup:
            no_dup.append(c)
        else:
            no_dup1.append(c)
    return ' '.join(no_dup)

def remove_duplicate_words(s):
    return ' '.join(i for loop, i in enumerate(s.split()) if s.split().index(i) == loop)

def remove_duplicate_words(s):
    words = s.split()
    new_list = []
    for i in words:
        if i not in new_list:
            new_list.append(i)
    new_list = " ".join(new_list)    
    return new_list


def remove_duplicate_words(s):
    return " ".join(list({x:1 for x in s.split(' ')}))

def remove_duplicate_words(s):
    split = s.split()
    newL = []
    for i in split:
        if i not in newL:
            newL.append(i)
            
    return ' '.join(newL)

def remove_duplicate_words(s):
    seperated = s.split()
    mylist = list( dict.fromkeys(seperated))
    return ' '.join(mylist)

def remove_duplicate_words(s):
    s1 = s.split()
    return ' '.join([s1[i] for i in range(len(s1)) if s1[i] not in s1[:i]])

from collections import Counter
def remove_duplicate_words(strr):
    input = strr.split(" ") 
    for i in range(0, len(input)): 
        input[i] = "".join(input[i]) 
    UniqW = Counter(input) 
    s = " ".join(UniqW.keys()) 
    return s

def remove_duplicate_words(s):
    undupped = []
    for i in s.split():
        if i not in undupped:
            undupped.append(i)
    return ' '.join(undupped)


def remove_duplicate_words(s):
    words = set()
    stree = ""
    for word in s.split():
        if word not in words:
            stree += word + " "
            words.add(word)
    return stree[0:-1]

def remove_duplicate_words(s):
    seen = set()
    words = []
    for word in s.split(" "):
        if word not in seen:
            seen.add(word)
            words.append(word)
    return " ".join(words)


def remove_duplicate_words(s):
    result = []
    s = s.split(' ')
    for i, word in enumerate(s):
        if word not in result:
            result.append(word)
        else:
            pass
    return ' '.join(result)

def remove_duplicate_words(s):
    s=s.split()
    m=[]
    for i in s:
        if i not in m:
            m.append(i)
    return " ".join(m)

def remove_duplicate_words(str):
    l=str.split()
    s=[]
    r=[]
    for i in range(len(l)):
        if l[i] not in s:
            s.append(l[i])
            r.append(l[i])
    satr = ' '.join([elem for elem in r])
    return satr 

from collections import OrderedDict
from collections import Counter
def remove_duplicate_words(s):
    s=s.split(" ")
    s = OrderedDict.fromkeys(s)
    return " ".join(s)

from collections import OrderedDict
def remove_duplicate_words(s):
    spliter = s.split()
    return " ".join(OrderedDict.fromkeys(spliter))


def remove_duplicate_words(s):
    d = dict((i,s.split(' ').count(i)) for i in s.split(' '))
    return ' '.join(d.keys())

def remove_duplicate_words(s):
    
    z = []
    s = s.split()
    
    for i in s:
        if i not in z:
            z.append(i)
            
    return " ".join(z)

def remove_duplicate_words(s):
    s1 = []
    [s1.append(x) for x in s.split() if x not in s1]
    return ' '.join(s1)

def remove_duplicate_words(s):
    res = []
    s = s.split()
    visited = set()
    for w in s:
        if w not in visited:
            res.append(w)
            visited.add(w)
    return " ".join(res)


def remove_duplicate_words(s):
    list = s.split()
    new = []
    for x in list:
        if x not in new and new.count(x) ==0:
            new.append(x)
    s=" "
    return (s.join(new)) 


def remove_duplicate_words(s):
    final = []
    for w in s.split(' '):
        if w not in final:
            final.append(w)
    return ' '.join(final)
        


def remove_duplicate_words(s):
    
    D = []
    words = s.split(" ")
    
    for word in words:
        
        if word not in D:
            D.append(word)
        else:
            pass
        
    return " ".join(D)


import re
def remove_duplicate_words(s):
    s_list = []
    s_2 = ''
    all = s.split()
    for word in s.split():
        if word not in s_list:
            s_2 += ' ' + word
            s_list.append(word)

    return s_2.strip()

def remove_duplicate_words(s):
    q = ""
    a = s.split(" ")
    for i in a:
        if i not in q:
            q += i + " "
    return q[:-1]

def remove_duplicate_words(s):
    s = s.split(" ")
    lst = []
    for item in s:
        if item not in lst:
            lst.append(item)
    return " ".join(lst)

from collections import Counter
def remove_duplicate_words(s):
    new=[]
    for i in Counter(s.split(' ')):
        new.append(i)
    return " ".join(new)

import re
def remove_duplicate_words(s):
    sx=[]
    for i in s.split():
        if i not in sx:
            sx.append(i)
    return " ".join(sx)

def remove_duplicate_words(s):
    
    split_string = s.split()
    
    new_string = ""
    
    for word in split_string:
        if word not in new_string:
            new_string+=word + " "
        else:
            continue
            
    return new_string.rstrip()
    


def remove_duplicate_words(s):
    t = set()
    s = s.split()
    r = []
    for w in s:
        if w not in t : t.add(w); r.append(w)
    return ' '.join(r)

def remove_duplicate_words(s):
    list = s.split()
    index = 0
    empty = []
    while index < len(list):
        if list[index] not in list[0:index]:
            empty.append(list[index])
        index += 1
    return ' '.join(empty)

def remove_duplicate_words(s):
    no_dup=set()
    lstt=[]
    for i in s.split():
        print(i)
        if i not in lstt:
            lstt.append(i)
        
        f=' '.join(lstt)
    return  f  

def remove_duplicate_words(s):
    a=[]
    c=s.split(" ")
    for i in c:
        if i not in a:
            a.append(i)
    return " ".join(a)

def remove_duplicate_words(s):
    nlist = []
    for i in s.split():
        if i not in nlist:
            nlist.append(i)
    return ' '.join(nlist)

def remove_duplicate_words(x):
    a=''
    for i in x.split():
        if i not in a:
            a+=i +' '
    return a[:-1]

def remove_duplicate_words(s):
    nwrd = []
    for i in s.split(' '):
        if i in nwrd:
            pass
        else:
            nwrd.append(i)
    return " ".join(nwrd)

def remove_duplicate_words(s):
    uniq = []
    for word in s.split():
        if word not in uniq:
            uniq.append(word)
    return ' '.join(uniq)

def remove_duplicate_words(s):
    res = []
    s = s.split(' ')
    
    for w in s:
        if w not in res:
            res.append(w)
            
    erg = ""
    for r in res:
        erg += r + " "
        
    return erg[:-1]

def remove_duplicate_words(s):
    dictionary = s.split()
    dictionary = dict.fromkeys(dictionary)
    return ' '.join(dictionary)

def remove_duplicate_words(string):
    string = string.split(" ")
    lst = []
    for word in string:
        if word not in lst:
            lst.append(word)

    return " ".join(lst)


def remove_duplicate_words(s):
    res = ""
    k = s.split()
    for i in k:
        if i not in res:
            res += i + " "
            
    return res.rstrip()

import re

def remove_duplicate_words(s):
    result = []
    s_l = s.split(' ')
    
    for x in s_l:
      if x not in result:
        result.append(x)
    
    result = " ".join(result)
    return result


def remove_duplicate_words(s):
    S = []
    for word in s.split():
        if word in S:
            continue
        S.append(word)
    return ' '.join(S)


from collections import OrderedDict
def remove_duplicate_words(s):
    a = s.split(" ")
    return " ".join(list(OrderedDict.fromkeys(a)))

from collections import OrderedDict

def remove_duplicate_words(s):
    return ' '.join(OrderedDict((x,None) for x in s.split()).keys())

def remove_duplicate_words(s):
    return ' '.join(list({i: True for i in s.split(' ')}))

def remove_duplicate_words(str):
    return " ".join(sorted(set(str.split()), key=str.split().index)) 

def remove_duplicate_words(s):
    list1=[]
    [list1.append(x) for x in s.split() if x not in list1]
    return ' '.join(list1)