def ini_placements(W, req, D): if (len(W) <= (1 + sqrt(len(D) * 8 + 1)) / 2): return W, req D1 = mset(D) D2 = mset(distances(W)) D3 = mset(distances(req)) UD = unused_distances(D3, D) k = max(UD) if (index(W, k) > -1 and index(W, D[len(D) - 1] - k) > -1): return W, req elif (index(W, k) > -1): req.append(k) req.sort() return ini_placements(possible_placements(req, D), req, D) elif (index(W, D[len(D) - 1] - k) > -1): req.append(D[len(D) - 1] - k) req.sort() return ini_placements(possible_placements(req, D), req, D) return W, req for j in range(0, len(D)): if (D[j] not in UD or (j > 0 and D[j] == D[j - 1])): continue i = D[j] cd2 = D2[i] if (cd2 == D1[i] and D3[i] != cd2): V = place_points_with_d(i, W, req) Wn = possible_placements(V, D) if (Wn == W): return W, req return ini_placements(Wn, V, D)
def get_extra_nt(singular, plural): """ Returns either n or t that has to be in plural.""" difference = mset(plural) - mset(singular) if difference['н'] != 0: return 'н' else: return 'т'
def common_words(title, save_title, with_spelling, remove_stopwords): same = np.zeros((nbr_duplicates, 1)) different = np.zeros((nbr_nonduplicates, 1)) same_index = 0 different_index = 0 all_is_stop_count = 0 for i in range(0, len(q1_arr)): str1 = q1_arr[i] str2 = q2_arr[i] q1 = str_to_array(str1) q2 = str_to_array(str2) if remove_stopwords: q1 = remove_stop(q1) q2 = remove_stop(q2) # Finds the common words common = list((mset(q1) & mset(q2)).elements()) if len(q1) + len(q2) == 0: all_is_stop_count += 1 continue if labels[i] == 0: different[different_index, 0] = len(common)/max(len(q1), len(q2)) different_index += 1 else: same[same_index, 0] = len(common)/max(len(q1), len(q2)) same_index += 1 bins = np.linspace(0, 1, 100) print(all_is_stop_count) plt.title(title) plt.hist(same, bins, alpha=0.5, label="is_duplicate=1") plt.hist(different, bins, alpha=0.5, label="is_duplicate=0") plt.legend(loc='upper right') plt.savefig('../Visualization/' + save_title) plt.show()
def problem5(): factors = mset() for i in range(21): pf = mset(hf.primeFactorization(i)) a = pf - factors factors += a b = list(factors.elements()) return reduce(lambda x,y: x*y, b)
def problem5(): factors = mset() for i in range(21): pf = mset(hf.primeFactorization(i)) a = pf - factors factors += a b = list(factors.elements()) return reduce(lambda x, y: x * y, b)
def clist_manager(Scenario_Outcomes, Scenarios, Uncertain_Parameters, Parameters, cuts, i, sets, use_sets): new_set_hold = {} mst = set() ### Combine groups for v in i: if v != None: if not use_sets: new_sets = [[j,] for j in Scenarios] Remaining_Realizations = copy.deepcopy(cuts) ### This builds sets from the ground up, not ideal for c in v: Remaining_Realizations.remove(c) ## Convert to Group Combine Form (1_2_3, 1_1_2, 1_0_1) RR = copy.deepcopy(Remaining_Realizations) for up in Uncertain_Parameters: ll = 0 if up.Realization_Type == 'gradual': for k in Remaining_Realizations: if k == str(up.Name): idx = RR.index(k) RR[idx] = RR[idx] + '_' + str(ll) + '_' + str(ll + 1) ll += 1 new_sets = Combine_Group(new_sets,Scenario_Outcomes,RR, Parameters) else: Remaining_Realizations = copy.deepcopy(cuts) for c in v: Remaining_Realizations.remove(c) RR = copy.deepcopy(Remaining_Realizations) for up in Uncertain_Parameters: ll = 0 if up.Realization_Type == 'gradual': for k in Remaining_Realizations: if k == str(up.Name): idx = RR.index(k) RR[idx] = RR[idx] + '_' + str(ll) + '_' + str(ll + 1) ll += 1 for sl in sets: if len(list((mset(v) & mset(sl)).elements())) == len(v) - 1: ## Convert this new_sets = Combine_Group(sets[sl],Scenario_Outcomes,RR, Parameters) break if 'new_sets' not in locals(): print(mset(v)) new_set_hold[tuple(v)] = copy.deepcopy(new_sets) for ss in new_sets: NAC_add = Subset_MST(ss,Scenario_Outcomes,mst) mst = mst.union(set(NAC_add)) return mst,new_set_hold
def findMaxSizeWords(wordlist, letters): words, size = [], 0 #test if each word's non-unique intersection is the same length as the word for w in wordlist: if len(list((mset(w) & mset(letters)).elements())) == len(w) >= size: if len(w) > size: size, words = len(w), [] words.append(w) else: words.append(w) return words, size
def find_words(letters): res = [] bits = bitify(letters) for key in hash: if letters[4] not in key: continue if hash[key] & bits == hash[key]: a = mset(key) b = mset(letters) if a & b == a: res.append(key) return sorted(res)
def killdup(A,B): aa=mset(A) bb=mset(B) cc=aa & bb aa.subtract(cc) bb.subtract(cc) aa = list(aa.elements()) aa.sort(reverse=True) bb = list(bb.elements()) bb.sort(reverse=True) cc = list(cc.elements()) cc.sort(reverse=True) return([aa,bb,cc])
def NERPass(self, text, id): Preprocessed = defaultdict() java_object = DynammicClustering.gateway.entry_point.getStack( text.lower()) # return {A: "adjective list",N:"nouns list....} keysToMatch = {'#', 'V', 'T'} nounKeys = {'N', '^', 'Z', 'M', 'S'} removeables = {'!', '~', 'G', 'E', '#'} slangs = [] if 'U' in java_object: #lematization does better preprocessing for more matches Preprocessed['U'] = mset( self.lmtz.lemmatize(word, 'v') for word in re.split(" ", java_object['U'])) #match { '#', 'V', 'T'} for key in keysToMatch: if (key in java_object): Preprocessed[key] = mset( self.lmtz.lemmatize(word, 'v') for word in re.split(" ", java_object[key])) sett = None #match Nouns (all kinds in here) for key in nounKeys: if (key in java_object): if sett is None: sett = mset( self.lmtz.lemmatize(word, 'v') for word in re.split(" ", java_object[key])) else: sett = sett | mset( self.lmtz.lemmatize(word, 'v') for word in re.split(" ", java_object[key])) if sett != None: Preprocessed['N'] = sett sett = None #slangs and emotican in the tweets for key in removeables: if (key in java_object): if sett is None: sett = set( self.lmtz.lemmatize(word, 'v') for word in re.split(" ", java_object[key])) else: sett = sett | set( self.lmtz.lemmatize(word, 'v') for word in re.split(" ", java_object[key])) if sett != None: self.slang_writer.writerow({'id': id, 'slangs': list(sett)}) return Preprocessed
def get_target_reservation_uniform(self, reservations): # First check whether there are reservations whose target replica osds aren't in the most recently used osd list # If yes, then grant those in FCFS order. Else, grant reservation in reverse most recently used order target_reservation = None target_reservation_alt = None target_reservation_alt_min = None for i in range(len(reservations)): if len( set([osd.id for osd in reservations[i].pg.replica_osd]) & set(self.mru_osd)) == 0: target_reservation = reservations[i] # Found a reservation, so break break # Alternate reservation is none, so use FCFS elif target_reservation_alt is None: # Have a list of target reservations, and append according to how recently used the osd was target_reservation_alt = reservations[i] target_reservation_alt_min = list((mset(self.mru_osd) & mset([ osd.id for osd in target_reservation_alt.pg.replica_osd ])).elements()) # If minimum intersection of current reservation is lesser than or equal to target_reservation_alt else: intersection = list((mset(self.mru_osd) & mset([ osd.id for osd in target_reservation_alt.pg.replica_osd ])).elements()) if len(intersection) < len(target_reservation_alt_min): target_reservation_alt_min = intersection target_reservation_alt = reservations[i] elif len(intersection) == len(target_reservation_alt_min): if intersection == target_reservation_alt_min: # Same, so FCFS break else: # Check how recently used the intersecting osds were for i in range(len(intersection)): # More recently used will be later on in the list if self.mru_osd.index( intersection[i]) < self.mru_osd.index( target_reservation_alt_min[i]): target_reservation_alt_min = intersection[i] target_reservation_alt = reservations[i] break if target_reservation is None: target_reservation = target_reservation_alt return target_reservation
def solution(str1, str2): s1_l = [str1[i:i + 2].upper() for i in range(0, len(str1) - 1) if not re.findall('[^a-zA-Z]+', str1[i:i + 2])] s2_l = [str2[i:i + 2].upper() for i in range(0, len(str2) - 1) if not re.findall('[^a-zA-Z]+', str2[i:i + 2])] if len(s1_l) == 0 and len(s2_l) == 0: return 65536 mset_s1 = mset(s1_l) mset_s2 = mset(s2_l) interSetLen = len(list((mset_s1 & mset_s2).elements())) unionSetLen = len(list((mset_s1 | mset_s2).elements())) return int(interSetLen / unionSetLen * 65536)
def NERPass(text): Preprocessed = defaultdict() java_object = gateway.entry_point.getStack( text.lower()) # return {A: "adjective list",N:"nouns list....} keysToMatch = {'N', '^', 'Z', 'M', '#', 'V', 'T'} if 'U' in java_object: Preprocessed['U'] = mset( lmtz.lemmatize(word, 'v') for word in re.split(" ", java_object['U'])) for key in keysToMatch: if (key in java_object): Preprocessed[key] = mset( lmtz.lemmatize(word, 'v') for word in re.split(" ", java_object[key])) return Preprocessed
def compare_genotype(ref_vcf, eval_vcf): ref_alt = ref_vcf["ALT"].split(",") ref_gt = re.split("[/|]", ref_vcf['GT']) ref_alt.insert(0,ref_vcf['REF']) #use the GT indices as array indices as VCF intends - Ref = index 0, all alts = indices 1..n ref_genotype = [ref_alt[int(ref_gt[0])],ref_alt[int(ref_gt[1])]] eval_alt = eval_vcf["ALT"].split(",") eval_gt = re.split("[/|]", eval_vcf['GT']) eval_alt.insert(0, eval_vcf['REF']) eval_genotype = [eval_alt[int(eval_gt[0])],eval_alt[int(eval_gt[1])]] shared_allele_counts = mset(ref_genotype) & mset(eval_genotype) number_of_alleles_matched = sum(shared_allele_counts.values()) if number_of_alleles_matched < 2: print ref_genotype, eval_genotype, shared_allele_counts, number_of_alleles_matched return number_of_alleles_matched
def getConcepts(input_file): """ get concepts from file """ concepts = mset() # use Counter for concepts cached_indices = {} with codecs.open(input_file, 'r', 'utf-8') as infile: for line in infile: line = line.strip() if line == '' and cached_indices: cached_indices = {} continue if line.startswith('(') and line.endswith(')'): line = line[1:-1] # remove parentheses triple = re.sub(r'[0-9A-Za-z\-]+ \/ ', '', line) try: c1, _, c2 = triple.split(', ') idx1, idx2 = re.findall(r'([0-9A-Za-z]+) \/', line) if idx1 not in cached_indices: cached_indices[idx1] = 1 concepts[c1.lower()] += 1 if idx2 not in cached_indices: cached_indices[idx2] = 1 concepts[c2.lower()] += 1 except ValueError: pass return concepts
def gcd(number1, number2): factor1 = factorize(number1) factor2 = factorize(number2) commonfactors = list((mset(factor1) & mset(factor2)).elements()) gcd = 1 # the following loop takes each element in common factors # and makes gcd = gcd * e # the short form of which is gcd *= e for e in commonfactors: gcd *= e return gcd
def p_keepdrop_expr(self, p): """dice_expr : dice_expr KEEPHIGHEST expression | dice_expr KEEPLOWEST expression | dice_expr DROPHIGHEST expression | dice_expr DROPLOWEST expression | dice_expr KEEPHIGHEST | dice_expr KEEPLOWEST | dice_expr DROPHIGHEST | dice_expr DROPLOWEST""" rollList = p[1] op = p[2] if len(p) > 3: keepDrop = self._sumDiceRolls(p[3]) else: # default to 1 if no right arg was given keepDrop = 1 # filter dice that have already been dropped validRolls = [r for r in rollList.rolls if not r.dropped] # if it's a drop op, invert the number into a keep count if op.startswith('d'): opType = 'drop' keepDrop = len(validRolls) - keepDrop else: opType = 'keep' if len(validRolls) < keepDrop: raise InvalidOperandsException(u'attempted to {} {} dice when only {} were rolled'.format(opType, keepDrop, len(validRolls))) if op == 'kh' or op == 'dl': keptRolls = heapq.nlargest(keepDrop, validRolls) elif op == 'kl' or op == 'dh': keptRolls = heapq.nsmallest(keepDrop, validRolls) else: raise NotImplementedError(u"operator '{}' is not implemented (also, this should be impossible?)") # determine which rolls were dropped, and mark them as such dropped = list((mset(validRolls) - mset(keptRolls)).elements()) for drop in dropped: index = rollList.rolls.index(drop) rollList.rolls[index].dropped = True p[0] = rollList
def solution(str1, str2): str1_set = [str1[i:i + 2].lower() for i in range(0, len(str1) - 1)] str2_set = [str2[i:i + 2].lower() for i in range(0, len(str2) - 1)] filtered_str1 = [i for i in str1_set if len(filter_text(i)) == 2] filtered_str2 = [i for i in str2_set if len(filter_text(i)) == 2] intersection_count = len( list((mset(filtered_str1) & mset(filtered_str2)).elements())) union_count = len(filtered_str1) + len(filtered_str2) - intersection_count if union_count == 0: return 65536 answer = int((intersection_count / union_count) * 65536) return answer
def insert_rule(lhs, rhs): nodes = lhs.split(",") outer_verts = {} inner_verts = {} i = 0 if 'S' in lhs: outer_verts['S'] = 'S' else: for x in nodes: outer_verts[x] = num_to_word(i) i += 1 total_in_cluser = i rhs_list = [] i = 1 for x in rhs: if isinstance(x, str): # hyperedge rhs_l = [] for y in x.split(","): if y in outer_verts: y = outer_verts[y] elif y in inner_verts: y = inner_verts[y] else: inner_verts[y] = str(i) y = str(i) i += 1 rhs_l.append(y) rhs_list.append("("+",".join(sorted(rhs_l))+":N)") else: rhs_l = [] for y in x: # x is a terminal edge (tuple) y = str(y) if y in outer_verts: y = outer_verts[y] elif y in inner_verts: y = inner_verts[y] else: inner_verts[y] = str(i) y = str(i) i += 1 rhs_l.append(y) rhs_list.append("("+",".join(sorted(rhs_l))+":T)") lhs_str = ",".join(sorted(outer_verts.values())) rhs_str = "".join(sorted(rhs_list)) #print lhs_str + " => " + rhs_str if lhs_str in production_rules: production_rules[lhs_str][rhs_str] += 1 else: rhs_mset = mset() rhs_mset[rhs_str] += 1 production_rules[lhs_str] = rhs_mset uncompressed_rule.append((lhs, lhs_str, (total_in_cluser, rhs_str))) return len(uncompressed_rule) - 1
def is_multisyllabic(word): """ Returns true if word has 3 or more vowels, otherwise returns false. For example Zora is 2-syllabic (False), Nebojsa is 3-syllabic (True). """ multiset = mset(word) sum = 0 for vowel in defs.VOWELS: sum += multiset[vowel] if sum >= 3: return True return False
def getHint(self, secret, guess): """ :type secret: str :type guess: str :rtype: str """ #bulls = [val for i, val in enumerate(secret) if secret[i] == guess[i]] #print bulls #print filter(lambda (i, val): val == secret[i], enumerate(guess)) #cow_candidates = [(val, guess[i]) for i, val in enumerate(secret) if secret[i] != guess[i]] #print cow_candidate bulls = [val for i, val in enumerate(secret) if secret[i] == guess[i]] secret_cow_candidates = [val for i, val in enumerate(secret) if secret[i] != guess[i]] guess_cow_candidates = [val for i, val in enumerate(guess) if secret[i] != guess[i]] #print bulls #print secret_cow_candidates #print guess_cow_candidates cows = list( (mset(secret_cow_candidates) & mset(guess_cow_candidates)).elements() ) return "%dA%dB" % (len(bulls), len(cows))
def rbo(ysess,gsess,topk,RankByG=False,multi=False): wt = 0.8 # newly added to make sure the best score is 1 topk = min(topk,len(gsess)-1) gsess = [url_normalize(t['l']) for t in gsess] if RankByG: ysess = [t for t in gsess if t in ysess] # don't care about the non-overlapping qls ret = 0. for i in xrange(topk+1): if multi: try: capsize = len(sum((mset(ysess[:i+1]) & mset(gsess[:i+1])).values())) except: gstub = gsess[:i+1] ystub = ysess[:i+1] capsize = sum(ystub.count(g) for g in gstub) else: capsize = len(set(ysess[:i+1]).intersection(set(gsess[:i+1]))) ret += capsize * math.pow(wt,i) / (i+1) nf = (1 - math.pow(wt,topk+1))/(1-wt) return ret/nf
def dice_expr(self, p): rollList = p.dice_expr op = p[1] if 'expr' in p._namemap: keepDrop = self._sumDiceRolls(p.expr) else: # default to 1 if no right arg was given keepDrop = 1 # filter dice that have already been dropped validRolls = [r for r in rollList.rolls if not r.dropped] # if it's a drop op, invert the number into a keep count if op.startswith('d'): opType = 'drop' keepDrop = len(validRolls) - keepDrop else: opType = 'keep' if len(validRolls) < keepDrop: raise InvalidOperandsException( 'attempted to {} {} dice when only {} were rolled'.format( opType, keepDrop, len(validRolls))) if op == 'kh' or op == 'dl': keptRolls = heapq.nlargest(keepDrop, validRolls) elif op == 'kl' or op == 'dh': keptRolls = heapq.nsmallest(keepDrop, validRolls) else: raise NotImplementedError( "operator '{}' is not implemented (also, this should be impossible?)" .format(op)) # determine which rolls were dropped, and mark them as such dropped = list((mset(validRolls) - mset(keptRolls)).elements()) for drop in dropped: index = rollList.rolls.index(drop) rollList.rolls[index].dropped = True return rollList
def solution(str1, str2): str1 = str1.lower() str2 = str2.lower() l1 = len(str1) l2 = len(str2) st1 = [] st2 = [] for i in range(l1 - 1): test = str1[i:i + 2] if clean_text(test): st1.append(test) for i in range(l2 - 1): test = str2[i:i + 2] if clean_text(test): st2.append(test) if len(st1) == 0 and len(st2) == 0: return 65536 mst1 = mset(st1) mst2 = mset(st2) inter_lst = list((mst1 & mst2).elements()) len_inter_lst = len(inter_lst) len_union_lst = len(st1) + len(st2) - len_inter_lst return int((len_inter_lst / len_union_lst) * 65536)
def problem12(): flag = True n = 1 i = 2 while True: number = 1 nDiv = mset(hf.primeFactorization(n)) exp = nDiv.most_common() for ex in exp: number *= ex[1] + 1 if number > 500: return n n += i i += 1
def calculate_str_similarity(s1, s2): """ Calculates the percent similarity between two strings. Meant to be a replacement for PHP's similar_text function, which old GeneWeaver uses to determine the right microarray platform to use. This algorithm uses digram intersections determine percent similarity. It is calculated as: sim(s1, s2) = (2 * intersection(digrams(s1), digrams(s2)) / |digrams(s1) + digrams(s2)| arguments s1: string #1 s2: string #2 returns a float indicating the percent similarity between two strings """ sd1 = make_digrams(s1) sd2 = make_digrams(s2) intersect = list((mset(sd1) & mset(sd2)).elements()) return (2 * len(intersect)) / float(len(sd1) + len(sd2))
def getEWcnt(text, dic="1111", flag=0): # text_word=text.split() dic = int(dic, 2) if int(flag) == 0: text_word = word_tokenize(text) else: text_word = word_tokenize(text.decode("utf8")) text_word = [w.lower() for w in text_word] # print text_word text_cnt = mset(text_word) # print text_cnt # print wn_joy_cnt EWcnt = {} EWcnt["bl_neg"] = sum((text_cnt & bl_neg_cnt).values()) EWcnt["bl_pos"] = sum((text_cnt & bl_pos_cnt).values()) EWcnt["fmn_emo"] = sum((text_cnt & fmn_emo_cnt).values()) EWcnt["mpqa_neg"] = sum((text_cnt & mpqa_neg_cnt).values()) EWcnt["mpqa_pos"] = sum((text_cnt & mpqa_pos_cnt).values()) EWcnt["wn_anger"] = sum((text_cnt & wn_anger_cnt).values()) EWcnt["wn_disgust"] = sum((text_cnt & wn_disgust_cnt).values()) EWcnt["wn_fear"] = sum((text_cnt & wn_fear_cnt).values()) EWcnt["wn_joy"] = sum((text_cnt & wn_joy_cnt).values()) EWcnt["wn_sadness"] = sum((text_cnt & wn_sadness_cnt).values()) EW = [] if (dic & 8) > 0: EW.append(EWcnt["bl_neg"]) EW.append(EWcnt["bl_pos"]) if (dic & 4) > 0: EW.append(EWcnt["fmn_emo"]) if (dic & 2) > 0: EW.append(EWcnt["mpqa_neg"]) EW.append(EWcnt["mpqa_neg"]) if (dic & 1) > 0: EW.append(EWcnt["wn_anger"]) EW.append(EWcnt["wn_disgust"]) EW.append(EWcnt["wn_fear"]) EW.append(EWcnt["wn_joy"]) EW.append(EWcnt["wn_sadness"]) # return EWcnt return EW
def solution(n, stages): answer = [] f_rate = [] stageSet = mset(stages) for stage in range(0, n): t = 0 fin = 0 for key in stageSet.keys(): if key - 1 == stage: t += stageSet[key] elif key - 1 > stage: fin += stageSet[key] if (t + fin) != 0: f_rate.append([stage + 1, t / (t + fin)]) else: f_rate.append([stage + 1, 0]) #print(f_rate) answer = [x[0] for x in sorted(f_rate, key=functools.cmp_to_key(compare))] return answer
def getEWcnt(text, dic='1111', flag=0): #text_word=text.split() dic = int(dic, 2) if int(flag) == 0: text_word = word_tokenize(text) else: text_word = word_tokenize(text.decode('utf8')) text_word = [w.lower() for w in text_word] #print text_word text_cnt = mset(text_word) #print text_cnt #print wn_joy_cnt EWcnt = {} EWcnt['bl_neg'] = sum((text_cnt & bl_neg_cnt).values()) EWcnt['bl_pos'] = sum((text_cnt & bl_pos_cnt).values()) EWcnt['fmn_emo'] = sum((text_cnt & fmn_emo_cnt).values()) EWcnt['mpqa_neg'] = sum((text_cnt & mpqa_neg_cnt).values()) EWcnt['mpqa_pos'] = sum((text_cnt & mpqa_pos_cnt).values()) EWcnt['wn_anger'] = sum((text_cnt & wn_anger_cnt).values()) EWcnt['wn_disgust'] = sum((text_cnt & wn_disgust_cnt).values()) EWcnt['wn_fear'] = sum((text_cnt & wn_fear_cnt).values()) EWcnt['wn_joy'] = sum((text_cnt & wn_joy_cnt).values()) EWcnt['wn_sadness'] = sum((text_cnt & wn_sadness_cnt).values()) EW = [] if (dic & 8) > 0: EW.append(EWcnt['bl_neg']) EW.append(EWcnt['bl_pos']) if (dic & 4) > 0: EW.append(EWcnt['fmn_emo']) if (dic & 2) > 0: EW.append(EWcnt['mpqa_neg']) EW.append(EWcnt['mpqa_neg']) if (dic & 1) > 0: EW.append(EWcnt['wn_anger']) EW.append(EWcnt['wn_disgust']) EW.append(EWcnt['wn_fear']) EW.append(EWcnt['wn_joy']) EW.append(EWcnt['wn_sadness']) #return EWcnt return EW
def solution(N, stages): answer = [] failureRateLst = [] stage = mset(stages) for stage in range(0, N): tryer = 0 finisher = 0 for key in stage.keys(): if key - 1 == stage: tryer += stage[key] elif key - 1 > stage: finisher += stage[key] if (tryer + finisher) != 0: failureRateLst.append([stage + 1, tryer / (tryer + finisher)]) else: failureRateLst.append([stage + 1, 0]) print(failureRateLst) answer = [ x[0] for x in sorted(failureRateLst, key=functools.cmp_to_key(kcomp)) ] return answer
import sys import os import operator from collections import Counter as mset from nltk.tokenize import word_tokenize dicDir = "./Dictionaries" blDIR = os.sep.join([dicDir, "Bingliu"]) fmnDIR = os.sep.join([dicDir, "Framenet"]) mpqaDIR = os.sep.join([dicDir, "MPQA"]) wnDIR = os.sep.join([dicDir, "Wordnet"]) Max_ch = 7 bl_neg_list = open(os.sep.join([blDIR, "list_negative-words.txt"])).readlines() bl_neg_list = [word.rstrip("\n") for word in bl_neg_list] bl_neg_cnt = mset(bl_neg_list) for i in range(1, Max_ch): bl_neg_cnt += bl_neg_cnt bl_pos_list = open(os.sep.join([blDIR, "list_positive-words.txt"])).readlines() bl_pos_list = [word.rstrip("\n") for word in bl_pos_list] bl_pos_cnt = mset(bl_pos_list) for i in range(1, Max_ch): bl_pos_cnt += bl_pos_cnt fmn_emo_list = open(os.sep.join([fmnDIR, "list_emotions.txt"])).readlines() fmn_emo_list = [word.rstrip("\n") for word in fmn_emo_list] fmn_emo_cnt = mset(fmn_emo_list) for i in range(1, Max_ch): fmn_emo_cnt += fmn_emo_cnt
def smallest_divisible(min_, max_): facts = mset() for i in range(min_, max_+1): facts += mset(factors(i)) - facts return reduce(mul, facts.elements(), 1)
def new_elements(a, b): union = mset(a) + mset(b) inter = mset(a) & mset(b) new = union - inter c = list(new.elements()) return c
def has_extra_nt(singular, plural): """ Returns true if non-nominative forms add n or t. """ difference = mset(plural) - mset(singular) return difference['н'] != 0 or difference['т'] != 0
import sys import os import operator from collections import Counter as mset from nltk.tokenize import word_tokenize dicDir = "./Dictionaries" blDIR = os.sep.join([dicDir, "Bingliu"]) fmnDIR = os.sep.join([dicDir, "Framenet"]) mpqaDIR = os.sep.join([dicDir, "MPQA"]) wnDIR = os.sep.join([dicDir, "Wordnet"]) Max_ch = 7 bl_neg_list = open(os.sep.join([blDIR, "list_negative-words.txt"])).readlines() bl_neg_list = [word.rstrip('\n') for word in bl_neg_list] bl_neg_cnt = mset(bl_neg_list) for i in range(1, Max_ch): bl_neg_cnt += bl_neg_cnt bl_pos_list = open(os.sep.join([blDIR, "list_positive-words.txt"])).readlines() bl_pos_list = [word.rstrip('\n') for word in bl_pos_list] bl_pos_cnt = mset(bl_pos_list) for i in range(1, Max_ch): bl_pos_cnt += bl_pos_cnt fmn_emo_list = open(os.sep.join([fmnDIR, "list_emotions.txt"])).readlines() fmn_emo_list = [word.rstrip('\n') for word in fmn_emo_list] fmn_emo_cnt = mset(fmn_emo_list) for i in range(1, Max_ch): fmn_emo_cnt += fmn_emo_cnt
from collections import Counter as mset a = [int(i) for i in input().split()] b = [int(i) for i in input().split()] inters = list(mset(a) & mset(b)) inters.sort() print(*inters, sep=' ')
def find_common_in_lists(list_1, list_2): intersection = mset(list_1) & mset(list_2) return list(intersection.elements())
factor = list() if number == 1: factor.append(1) cn = number while cn > 1: sf = smallestFactor(cn) factor.append(sf) cn = cn / sf return factor number1 = input('Give a number') number2 = input('Give another number') factor1 = factorize(number1) factor2 = factorize(number2) commonfactors = list((mset(factor1) & mset(factor2)).elements()) gcd = 1 # the following loop takes each element in common factors # and makes gcd = gcd * e # the short form of which is gcd *= e for e in commonfactors: gcd *= e print "The GCD of the two numbers is: " + str(gcd)
lis = responses.split("{'title': ") for Recipe in lis: one = Recipe.split(": '") one[0] = one[0][0:-8] #название one[1] = one[1][0:-16] #ссылка one[2] = one[2][0:-14] #игредиенты one.pop() #убираем картинку Ingr = one[2].split(", ") #Ingr - now, lis - main Ingr.sort() lisF.sort() if list( (mset(lisF) & mset(Ingr)).elements() ) == Ingr: #проверяю кол-во элементов в ingr и если оно меньше текущего, кидаю туда if len(Ingr) < CountOfIngr: #print(one) #print(len(Ingr)) BestOut = one CountOfIngr = len(Ingr) url = url1 #for qwe in BestOut: # print(qwe) print( "Самый простой рецепт по запросу - {}. \nОн содержит следующие ингредиенты: {} \nСсылка: {}" .format(BestOut[0], BestOut[2], BestOut[1]))
from collections import Counter as mset from functools import reduce from time import clock start = clock() factors = mset() # Empty range = list(range(1,20+1)) # This program finds the smallest multiple using the highest multiplicity of each prime # Code based on Problem 3 from Project Euler for num in range: i = 1 tempFactors = mset() while (i < num): i += 1 if (num % i == 0): # Factor of our number while (num % i == 0): # Multiple factors tempFactors[i] += 1 num = num/i factors = factors | tempFactors # Union factors = list(factors.elements()) output = reduce(lambda x,y: x*y, factors) print(factors) print(output) end = clock() print('Computation Time:',end-start,'seconds')