def buddyStrings(A, B): """ :type A: str :type B: str :rtype: bool """ ca = C(A) cb = C(B) if ca != cb: return False d = 0 for i in range(len(A)): d += (A[i] != B[i]) if d == 0: flag = 0 for key in ca: if ca[key] > 1: flag = 1 break if flag: return True return False if d == 2: return True return False
def CreateUnigramNLTK(dataset): ug = [] counter = C() ### Get a count of all words, so we only use the words appearing more than once for sents in dataset: for words in sents: counter += C(words) #create counter of words counter = {k: counter[k] for k in counter if counter[k] > 1} #take only words appearing more than once ## Create unigram set for i in range(len(dataset)): bag = C() for d in dataset[i]: bag += C(d) features = {} for word in counter: features['contains(%s)' % word.lower()] = (word.lower() in bag) ug.append([features, targets[i]]) return ug
def analyzeTheWorld(items, fName): featMap = {} cmds = C({}) for v, cnt in items: x = "TheWorld " + v featMap.setdefault('TheWorld ' + fName, set()).add((v, x)) cmds += C({x: cnt}) return [cmds, featMap]
def pair(l): #takes values pair_values = list(i for i in C(l) if C(l)[i] == 2) if 2 in C(l).values(): return True, pair_values, [ item for item in l if item not in set(pair_values) ] else: return False
def three(l): #takes values pair_values = list(i for i in C(l) if C(l)[i] == 3) if 3 in C(l).values(): return True, pair_values[0], [ item for item in l if item not in set(pair_values) ] else: return False
def test_to_taxons(): labels = [ Label("if", [S(1, 1), S(1, 1), S(2, 5)]), Label("comparison_operator:Lt", [S(1, 1), S(3, 3), S(2, 2)]), ] assert t.to_taxons(labels) == [ ("flow/conditional", C({S(1, 1): 2, S(2, 5): 1})), ("test/inequality", C({S(2, 2): 1, S(3, 3): 1, S(1, 1): 1})), ]
def possible_rings(rings): yield C() for k in rings: yield C({"Cost": k[0], "Damage": k[1], "Armor": k[2]}) for k in rings: kk = C({"Cost": k[0], "Damage": k[1], "Armor": k[2]}) for j in rings: if j != k: yield C({"Cost": j[0], "Damage": j[1], "Armor": j[2]}) + kk
def solution(participant, completion): answer = '' C_p = C(participant) C_c = C(completion) C_a = C_p - C_c for k, v in C_a.items(): if v != 0: answer = k return answer
def reorderedPowerOf2(N): """ :type N: int :rtype: bool """ num_str = str(N) for idx in range(30): a = str(2**idx) if C(a) == C(num_str): return True return False
def numSpecialEquivGroups(self, A): s = set() for a in A: x = C(a[::2]) y = C(a[1::2]) x_new = immu(x) y_new = immu(y) print(x, " ", x_new) print(y, " ", y_new) s.add((x_new, y_new)) print() print(s) print() return len(s)
def bazinga(): a,b=map(int, si.readline().split()) d = C(list(si.readline().strip())) for k,v in d.items(): if v > b : return 'NO' else: return 'YES'
def _calc_density(self, x, y): # determine the x and y cells within which each individual's # x and y coordinates fall (the self.x_edge and self.y_edge # corrections determine the correct cells whether the grid # includes cells centered on the landscape edges, # i.e. self.x_edge or y_edge = True, or not) x_cells = (x - self.x_edge * (self.window_width) / 2.) // self.window_width + self.x_edge y_cells = (y - self.y_edge * (self.window_width) / 2.) // self.window_width + self.y_edge # get cell strings from indivudals' cells cells = _make_cell_strings(y_cells, x_cells, self.dim_om) # and get Counter dict of the cell strings counts = C(cells) # use the itemgetter attribute to get the count for each cell grid_counts = self.grid_counter(counts) # reshape them into an ndarray grid_counts = np.reshape(grid_counts, self.gi.shape) # and divide the array values by the appropriate # grid-cell areas to get the densities grid_dens = grid_counts / self.areas return grid_dens
def count_k_most_words(para,k): new = para.split() count = C(new) res = reversed(count.most_common(k)) for x in res: print(x[0], ':' ,x[1])
def p1(): ans = [] for line in open("ac2020.2.txt"): limits, char, key = line.split() ll, ul = map(int, limits.split('-')) ch = char[0] ans.append(ll <= C(key)[ch] <= ul) return sum(ans)
def uniqueOccurrences(self, arr: List[int]) -> bool: hashmap = C(arr) lis = set() c = 0 for k, v in hashmap.items(): c += 1 lis.add(v) if len(lis) == c: return True
def solution(clothes): answer = 1 cloth_li = [] for i in clothes: cloth_li.append(i[1]) cloth_num = C(cloth_li) for type in cloth_num.keys(): answer *= cloth_num[type] + 1 answer -= 1 return answer
def palindromeRearrangin(a): b = list(C(a).values()) hit = 0 for i in b: if (i % 2) != 0: hit += 1 if hit == 2: return False return True
def __init__(self, docs): self.vocabs = {} self.vocab = C() self.sizes = {} self.number = {} for doc, target, num in docs: self.number[target] = num f = open(doc, 'r') l = f.read() w = l.split(',') self.vocabs[target] = C() for i in w: self.vocabs[target].update( {i.split("\'")[1]: int(i.split()[-1])}) self.sizes[target] = sum(self.vocabs[target].values()) self.vocab.update(self.vocabs[target]) f.close() self.size = len(self.vocab.keys()) self.total = sum(self.number.values())
def dice_score(throw): d=dict(C(throw)) p=0 for x in d: if x==1: p+=divmod(d[x], 3)[0]*1000+divmod(d[x], 3)[1]*100 elif x==5: p+=divmod(d[x], 3)[0]*500+divmod(d[x], 3)[1]*50 else: p+=divmod(d[x], 3)[0]*x*100 return p
def solve_part2(data, weapons, armor, rings): user = C({'Hp': 100, 'Damage': 0, 'Armor': 0, 'Cost': 0}) cost = float("-inf") for w in possible_weapons(weapons): uw = user + w for a in possible_armor(armor): ua = uw + a for r in possible_rings(rings): ur = ua + r if not user_wins(ur, data.copy()): cost = max(cost, ur["Cost"]) return cost
def mostCommonWord_2(self, paragraph: str, banned: List[str]) -> str: """ 1. use regex: substutute any character which is not word with space 2. Counter.most_common """ words = [ word for word in re.sub(r'[^\w]', ' ', paragraph).lower().split() if word not in banned ] counts = C(words) return counts.most_common(1)[0][0]
def solve(input, f=0, s=None, u=lambda s, d, k: k in s and {k: -1} or {d: 1}): for d in input.strip().split(','): s = s or C() f = max(f, sum(s.values())) s += u(s, d, w[d][0]) for b, a, c in (v[1:] for v in w.values() if {*v[2:]} <= {*+s}): m = min(s[a], s[c]) s -= { a: m, b: -m, c: m } d = sum(s.values()) return d, max(f, d)
def CreateBOW(counter, dataset, targets, presfreq='freq'): bow = [] ## Create bag of words for i in range(len(dataset)): rep = [targets[i]] #add polarity bag = C() for d in dataset[i]: bag += C(d) for w in counter: if w in bag: if presfreq == 'freq': #if we want the frequency of words, retrieve it from counter rep.append(bag[w]) elif presfreq == 'pres': #else just write 1 rep.append(1) else: rep.append(0) bow.append(rep) #append polarity + text as 1 row return bow
def test_call(): programs = [ Program( name="algo1", labels=[ Label("if", [S(1, 1), S(1, 1), S(2, 5)]), Label("if_else", [S(1, 1), S(2, 5)]), Label("comparison_operator:Lt", [S(1, 1), S(3, 3), S(2, 2)]), ], taxons=[], addition={}, deletion={}, ), Program( name="algo2", labels=[ Label("member_call:difference_update", [S(1, 1), S(1, 1), S(2, 5)]), Label("literal:Set", [S(1, 1), S(2, 5)]), ], taxons=[], addition={}, deletion={}, ), ] result = {program.name: t.to_taxons(program.labels) for program in programs} print(result) assert result == { "algo1": [ ("flow/conditional", C({S(1, 1): 1})), ("flow/conditional/else", C({S(1, 1): 1, S(2, 5): 1})), ("test/inequality", C({S(2, 2): 1, S(3, 3): 1, S(1, 1): 1})), ], "algo2": [ ("call/function/builtin/casting/set", C({S(1, 1): 1, S(2, 5): 1})), ("type/non_sequence/set", C({S(1, 1): 3, S(2, 5): 2})), ], }
def firstUniqChar(self, s): """ :type s: str :rtype: int """ from collections import Counter as C c = C(s) for i, v in enumerate(s): if c[v] == 1: return i return -1
def update(self, spp): # get a copy of the previous counts copy = np.copy(self.counts) # get the species, then get a counter of number of individuals # within each cell counter = C([(int(x), int(y)) for x, y in zip(spp._get_x(), spp._get_y())]) # convert that counter into an array of cell counts for i in range(self.dim[0]): for j in range(self.dim[1]): self.update_counts_cell(i, j, counter.get((j, i), 0)) # update diff self.diff = self.counts - copy # update stats for fn, v in self.stats.items(): self.stats[fn].append(fn(self.diff))
def shadow(): for gi, name in enumerate(glob.glob('out/*')): day = re.search('out/(.*?_.*?_.*?)_(.*?$)', name).group(1) who = re.search(':\d\d_(.*?$)', name).group(1) f = open(name, 'r') c = json.loads(f.read()) try: favs = c['favs'] fr = c['fr'] txt = c['txt'] except: continue oneshot = {'___META_FR___': fr, "___META_ID___%s" % who: 1} oneshot.update(dict(C(m.parse(txt).strip().split()))) db.put(bytes(name.split('/')[-1], 'utf-8'), pickle.dumps(oneshot)) if gi % 1000 == 0: print(gi, day, name) print(favs, oneshot)
def test_deduplicated_taxons(): assert t.deduplicated_taxons([]) == [] taxons = [ ("flow/conditional", C({S(1, 1): 2, S(2, 5): 1})), ("flow/conditional/else", C({S(1, 1): 1, S(2, 5): 1})), ("test/inequality", C({S(2, 2): 1, S(3, 3): 1, S(1, 1): 1})), ] result = t.deduplicated_taxons(taxons) print(result) assert result == [ ("flow/conditional", C({S(1, 1): 1})), ("flow/conditional/else", C({S(1, 1): 1, S(2, 5): 1})), ("test/inequality", C({S(2, 2): 1, S(3, 3): 1, S(1, 1): 1})), ]
def calc_pi(mod, nonneut_loc, window_width=6): print("\nCalculating nucleotide diversity (WILL TAKE A WHILE)...\n") # make speciome speciome = mod.comm[0]._get_genotypes() # create data structure to store pi value for each genomic window pi_vals = [] # for each locus for loc in range(speciome.shape[1]): # get 5-locus window around the locus start = max(loc-window_width, 0) # add 6 so that the resulting interval includes 5 loci on either # side of focal locus stop = min(loc+window_width+1, speciome.shape[1]) print('\tcalculating for interval [%i, %i)' % (start, stop)) # get all individs' genotypes for that interval of loci interval_idxs = list(range(start, stop)) # NOTE: get rid of locus 50 itself, if in there, because it is the only # non-segregating locus, so it creates an artefactual depression in # nucleotide diversity in the area surrounding it #if nonneut_loc in interval_idxs: # interval_idxs = [n for n in interval_idxs if n != nonneut_loc] intervalome = speciome[:, interval_idxs, :] # break into a list by seq (i.e. melt down to 2 seqs per individ) intervalome = np.vstack([intervalome[:, :, i] for i in (0, 1)]) # get freq of each unique sequence seq_counts = C([''.join([str(n) for n in seq]) for seq in intervalome]) seq_freqs = {seq: ct / intervalome.shape[0] for seq, ct in seq_counts.items()} # get all pairwise combos of seqs combos = [*combinations([*seq_freqs], 2)] # get number of nucleotide differences per nucleotide site for each # pairwise combo of seqs pi_ij = [np.mean([i != j for i, j in zip(c[0], c[1])]) for c in combos] # get sum across all pairwise seq combos of mean number of nucleotide # differences multiplied by frequencies of each of the two seqs pi = 2 * sum([seq_freqs[c[0]] * seq_freqs[c[1]] * pi_ij[n] for n, c in enumerate(combos)]) pi_vals.append(pi) return pi_vals
def _make_von_mises_multimodal_sampler(neigh, dirs, vm_distr_kappa=12, approx_len=5000): # Returns a lambda function that is a quick and reliable way to simulate # draws from a Von Mises mixture distribution: # 1.) Chooses a direction by neighborhood-weighted probability # 2.) Makes a random draw from a Von Mises dist centered on the direction, # with a vm_distr_kappa value set such that the net effect, # when doing this a ton of times for a given neighborhood and then # plotting the resulting histogram, gives the visually/heuristically # satisfying approximation of a Von Mises mixture distribution # NOTE: Just visually, heuristically, vm_distr_kappa = 10 seemed # like a perfect middle value (vm_distr_kappa ~3 gives too # wide of a Von Mises variance and just chooses values around # the entire circle regardless of neighborhood # probability, whereas vm_distr_kappa ~20 produces noticeable reductions # in probability of moving to directions between the 8 queen's # neighborhood directions (i.e. doesn't simulate the mixing well enough) # and would generate artefactual movement behavior); 12 also # seemed to really well in generating probability valleys # when tested on neighborhoods that should generate bimodal distributions d = list(dirs.ravel()) n = list(neigh.ravel()) del d[4] del n[4] sum_n = float(sum(n)) if sum_n > 0: n_probs = [i / sum_n for i in n] else: n_probs = [.125] * 8 loc_choices = r.choice(d, approx_len, replace=True, p=n_probs) loc_choices = list(C(loc_choices).items()) approx = np.hstack([ s_vonmises.rvs(vm_distr_kappa, loc=loc, scale=1, size=size) for loc, size in loc_choices ]) return approx