def add(self, *args): """ Add new elements to the list :param \*args: List of new elements """ for arg in args: _id = getattr(arg, 'id') if _id in self.map['id']: continue self.objects[_id] = arg _main = reduce(self._iter_func, self.main_sort.split('.'), arg) _sec = reduce(self._iter_func, self.break_tie_sort.split('.'), arg) _pos = bisect_left(self.main, _main) main_pos_r = bisect_right(self.main, _main) if _pos == main_pos_r: self.list.insert(_pos, _id) self.main.insert(_pos, _main) self.secondary.insert(_pos, _sec) else: _pos = bisect_left(self.secondary[_pos:main_pos_r], _sec) + _pos self.list.insert(_pos, _id) self.main.insert(_pos, _main) self.secondary.insert(_pos, _sec) self.map_insert(self.map['id'], self.map['pos'], _pos, _id)
def get_xic(self, min_mz, max_mz, min_rt=0.0, max_rt=0.0, ms_level=1): """ eXtracted Ion Chromatogram :param min_mz: :param max_mz: :param min_rt: :param max_rt: :param ms_level: :return: """ min_mz_rs = self.run_slices_begin_mz[bisect_left(self.run_slices_begin_mz, min_mz) - 1] max_mz_rs = self.run_slices_begin_mz[bisect_left(self.run_slices_begin_mz, max_mz) - 1] # print "min max rs", min_mz_rs, max_mz_rs if min_mz_rs == max_mz_rs: sql_query = """SELECT bounding_box.id, data, run_slice_id, first_spectrum_id FROM bounding_box, run_slice WHERE run_slice.ms_level = ? AND bounding_box.run_slice_id = run_slice.id AND run_slice.begin_mz = ?;""" self.cursor.execute(sql_query, (ms_level, min_mz_rs)) else: sql_query = """SELECT bounding_box.id, data, run_slice_id, first_spectrum_id FROM bounding_box, run_slice WHERE run_slice.ms_level = ? AND bounding_box.run_slice_id = run_slice.id AND (run_slice.begin_mz = ? OR run_slice.begin_mz = ?);""" self.cursor.execute(sql_query, (ms_level, min_mz_rs, max_mz_rs)) intensities_by_scan_time = ddict(int) for row in self.cursor: scan_slices = bb_to_scan_slices(row[1][:], row[2], self.struct_by_scan_id) for ss in scan_slices: time = self.rt_by_scan_id_by_ms_level[ms_level][ss.scan_id] mzs = ss.mzs min_idx = bisect_left(mzs, min_mz) max_idx = bisect_left(mzs, max_mz) ints = ss.ints[min_idx: max_idx] if not ints: continue m = max(ints) # if m > intensities_by_scan_time[time]: intensities_by_scan_time[time] = m times = sorted(intensities_by_scan_time.viewkeys()) intensities = [intensities_by_scan_time[t] for t in times] return times, intensities
def index(a, x): 'Locate the leftmost value exactly equal to x' i = bisect_left(a, x) if i != len(a) and a[i] == x: return i else: return -1
def removePeakFromOneCluster(self): idx=self.view.treeView_3.selectedIndexes()[0]#supposed the selection exists if not idx.isValid(): return model=idx.model() #copy the item itemToDelete = model.itemFromIndex(idx) item = QStandardItem(itemToDelete) #no need to select already selected, then removing self.view.treeView_3.removeSelected() #putting the copied item in view parentIndex = idx.parent().parent().parent() sample = self.currentSample[3]#self.model.sample(parentIndex.data().toString(), #fullNameEntry=False) if sample is None: print "Unknown error" return data = map(str, item.text().split('/'))[:2] dataParent = map(str, idx.parent().parent().data().toString().split('/')) sample.mappedPeaks.sample=sample; sample.rawPeaks.sample=sample#du to one bug don't know why goodPeak = sample.mappedPeaks.peakAt(*map(float, dataParent)) fragPeak = sample.rawPeaks.peakAt(*map(float, data)) try: goodPeak.fragCluster.remove(fragPeak) goodPeak.isoCluster.remove(fragPeak) except ValueError: pass #adding item to the treeView parentItem = model.itemFromIndex(parentIndex) index = bisect_left(sample.mappedPeaks.masses(), float(item.text().split('/')[0])) #model.insertRow(index, item) parentItem.insertRow(index, item) self.view.treeView_3.update()
def compareTwoCellForFirstAndGetComment(scale, Nodes1, Nodes2,threshold): yKey = [item[1] for item in Nodes2] newNodes = [] for item in Nodes1: left=bisect_left(yKey,item[1]-threshold) right=bisect_right(yKey,item[1]+threshold) ySatisList = Nodes2[left: right+1]; for node in ySatisList: if node[2]<(item[2]+threshold) and node[2]>(item[2]-threshold) and node[0]<(item[0]+threshold) and node[0]>(item[0]-threshold): #z= int((item[0])/scale[0]) # y= int((item[1])/scale[1]) #x= int((item[2])/scale[2]) #ide= int(item[3]) #cellname = item[4] newnode = [] #newnode.append(z) #newnode.append(y) #newnode.append(x) newnode.append(item[3]) #newnode.append(cellname) newnode.append(" from " + node[4]) newNodes.append(newnode) return newNodes
def compareTwoCellandReturnMidPoint(Nodes1, Nodes2,threshold, i): yKey = [item[1] for item in Nodes2] newNodes = [] for item in Nodes1: left=bisect_left(yKey,item[1]-threshold) right=bisect_right(yKey,item[1]+threshold) ySatisList = Nodes2[left: right+1]; for node in ySatisList: if node[2]<(item[2]+threshold) and node[2]>(item[2]-threshold) and node[0]<(item[0]+threshold) and node[0]>(item[0]-threshold): z= int((node[0]+item[0])/52) y= int((node[1]+item[1])/26.4) #IMPORT FIX!!!!!!!!! x= int((node[2]+item[2])/26.4) ide= i cellname = item[4]+"--"+node[4] newnode = [] newnode.append(z) newnode.append(y) newnode.append(x) newnode.append(ide) newnode.append(cellname) newNodes.append(newnode) i = i+1 return newNodes
def insort_left(a, x, lo=0, hi=-1): """Insert item x in list a, and keep it sorted assuming a is sorted. If x is already in a, insert it to the left of the leftmost x. Optional args lo (default 0) and hi (default len(a)) bound the slice of a to be searched.""" n = bisect_left(a, x, lo, hi) a.insert(n, x)
def can_place_point(point, W, D): checkW = W[:] checkW.insert(bisect_left(W, point), point) CWD = distances(checkW) UCWD = unique_elements(CWD) for i in UCWD: if (count(i, CWD) > count(i, D)): return False return True
def autoc_matrix(v, D): A = numpy.zeros((len(v), len(v))) Dl = list(set(D)) for i in range(0, len(v)): for j in range(0, len(v)): z = abs(v[j][1] - v[i][1]) k = bisect_left(Dl, z) if (k < len(v) and v[k][1] == z): A[k][j] += v[i][0] return A
def get_substring(k): insertion = bisect_left(rank, k) if insertion == len(rank): return None suffix_index = rank[insertion] suffix = arr_suffix[insertion] if suffix_index == k: return suffix else: return suffix[:k - suffix_index]
def lookup(self, prefix, lo=0, hi=None): """See if prefix is in dictionary, as a full word or as a prefix. Return two values: the first is the lowest i such that words[i].startswith(prefix), or is None; the second is True iff prefix itself is in the Wordlist.""" words = self.words i = bisect.bisect_left(words, prefix, lo, hi) if i < len(words) and words[i].startswith(prefix): return i, (words[i] == prefix) else: return None, False
def takeClosest(self, myList, myNumber): pos = bisect_left(myList, myNumber) if pos == 0: return myList[0], myList[1] if pos == len(myList): return myList[-1], myList[-2] before = myList[pos - 1] after = myList[pos] if after - myNumber < myNumber - before: return after, before else: return before, after
def solution(line): data, total = line.split(';') data = [int(x) for x in data.split(',')] total = int(total) result = [] for i in range(len(data)): if data[i] * 2 >= total: break target = total - data[i] j = bisect_left(data, target, i+1) if j != len(data) and data[j] == target: result.append((data[i], data[j])) if not result: return 'NULL' return ';'.join('{},{}'.format(x[0], x[1]) for x in result)
def solution(line): data, total = line.split(';') data = [int(x) for x in data.split(',')] total = int(total) result = [] for i in range(len(data)): if data[i] * 2 >= total: break target = total - data[i] j = bisect_left(data, target, i + 1) if j != len(data) and data[j] == target: result.append((data[i], data[j])) if not result: return 'NULL' return ';'.join('{},{}'.format(x[0], x[1]) for x in result)
def cutCell2(nodes, ratio1, ratio2): aArray = nodes.sort(key = lambda x:x[2]) #print aArray xKey = [] for item in aArray: xKey.append(item[2]) #xKey = [thing[2] for thing in aArray] xTop = bisect_left(xKey, int(ratio2 * len(aArray))) xBot = bisect_left(xKey, int(ratio1 * len(aArray))) #xSatisList = aArray[0: cutVal] xSatisList1 = aArray[:xTop] xSatisList2 = xSatisList1[xBot:] return xSatisList2
def get_scan_for_time(self, time, ms_level=1): """ retrun the closest scan in time specified by time parameter ms_level is kw argument if a ms2 or ms1 scan is wanted :param time: :param ms_level: :return: """ rt_by_scan_id = self.rt_by_scan_id_by_ms_level[ms_level] pairs = rt_by_scan_id.items() times = [t[1] for t in pairs] idx = bisect_left(times, time) idx_p = idx - 1 scan_id = pairs[idx][0] if abs(times[idx] - time) < abs(times[idx_p] - time) else pairs[idx_p][0] return self.get_scan(scan_id)
def _sub_paths(self, path): """ Generator for sub-paths of path in the index, in index order. This assumes that the index key order matches python's sort order. """ keys = self.index.keys() # bisect to find the first index with key "greater than or equal to" # path, then scan forward checking that sub-paths start with path i = bisect_left(keys, path) while i < len(keys): key = keys[i] if key.startswith(path): yield key i += 1 else: break
def cutCellX(nodes, cutVal): newDict = {} for item in nodes.keys(): newDict.setdefault(item) aArray = nodes[item].sort(key = lambda x:x[2]) xKey = [thing[2] for thing in aArray] x = bisect_left(xKey, cutVal) #xSatisList = aArray[0: cutVal] xSatisList = aArray[x:] newDict[item] = xSatisList return newDict
def _prefiltering(self, candidates, spectrum, AAmass=constants.AA_MASSES, tol=0.2): """ Filter candidates prior to validation. The best 1000 candidates will be returned for further validation. """ if len(candidates) <= 1000: return candidates mz, n = np.sort(spectrum[:, 0]), spectrum.shape[0] mh, mh2o = constants.FIXED_MASSES["H"], constants.FIXED_MASSES["H2O"] # quick annotations simply using b and y ions. num_ions = [] for candidate in candidates: # get residue masses seq_mass = np.array([AAmass[a].mono for a in candidate.seq]) # singly charged terminal adducts in [N-terminus, C-terminus] term_mass = [mh, mh2o + mh] for mod in candidate.mods: if isinstance(mod.site, int): seq_mass[mod.site - 1] += mod.mass else: term_mass[0 if mod.site == "nterm" else 1] += mod.mass # singly charged y and b ion m/z ybs = np.concatenate( (np.cumsum(seq_mass[:-1]) + term_mass[0], np.cumsum(seq_mass[::-1][:-1]) + term_mass[1]), axis=0) ybs.sort() # do quick annotation mix = [bisect_left(mz, m) for m in ybs] nk = sum((k > 0 and m - mz[k - 1] <= tol) or ( k < n and mz[k] - m <= tol) for k, m in zip(mix, ybs)) num_ions.append(nk) # retain candidates with 1000 highest number of y and b ions annotated. sorted_ix = np.argsort(num_ions)[::-1] return [candidates[i] for i in sorted_ix[:1000]]
def get_results(query): query = make_normal(query) index = defaultdict(list) for k, q in enumerate(query): # находим положения слов в источнике try: w = Word.objects.get(pk=q) l = Lexeme.objects.get(pk=w.lexeme) t = list(map(int, l.index.split())) for i in range(0, len(t), 2): index[t[i]].append((t[i + 1], k)) except ObjectDoesNotExist: try: w = Dict.objects.get(pk=q) l = Lexeme.objects.get(pk=w.lexeme) # если такая лексема уже существует Word(word=w, lexeme=w.lexeme).save() # добавляем слово в базу t = list(map(int, l.index.split())) for i in range(0, len(t), 2): index[t[i]].append((t[i + 1], k)) except ObjectDoesNotExist: pass results = [] for src in index: # для каждого источника определяем релевантность запросу и позицию index[src].sort() r, p = check(index[src], len(query)) results.append((r, src, p)) if results: results.sort() # упорядочиваем результаты по релевантности results = results[results_limit:] # нас интересуют только надежные t = (results[0][0] // 2,) # порог отсечения по релевантности results = results[bisect_left(results, t):] # (можно и не отсекать) return results[::-1] # в порядке убывания релевантности
def removePeakFromOneCluster(self): idx = self.view.treeView_3.selectedIndexes()[ 0] #supposed the selection exists if not idx.isValid(): return model = idx.model() #copy the item itemToDelete = model.itemFromIndex(idx) item = QStandardItem(itemToDelete) #no need to select already selected, then removing self.view.treeView_3.removeSelected() #putting the copied item in view parentIndex = idx.parent().parent().parent() sample = self.currentSample[ 3] #self.model.sample(parentIndex.data().toString(), #fullNameEntry=False) if sample is None: print "Unknown error" return data = map(str, item.text().split('/'))[:2] dataParent = map(str, idx.parent().parent().data().toString().split('/')) sample.mappedPeaks.sample = sample sample.rawPeaks.sample = sample #du to one bug don't know why goodPeak = sample.mappedPeaks.peakAt(*map(float, dataParent)) fragPeak = sample.rawPeaks.peakAt(*map(float, data)) try: goodPeak.fragCluster.remove(fragPeak) goodPeak.isoCluster.remove(fragPeak) except ValueError: pass #adding item to the treeView parentItem = model.itemFromIndex(parentIndex) index = bisect_left(sample.mappedPeaks.masses(), float(item.text().split('/')[0])) #model.insertRow(index, item) parentItem.insertRow(index, item) self.view.treeView_3.update()
def __contains__(self, word): return self.words[bisect.bisect_left(self.words, word)] == word
import bisect from _bisect import bisect_left, bisect_right def GenerateFibNumbers(n): a, b = 1, 1 while b < n: yield b a, b = b, a + b FibNumbers = list(GenerateFibNumbers(10**100)) while True: start, end = map(int, input().split()) if start == 0 and end == 0: # invalid input break left = bisect_left(FibNumbers, f) # finds start position right = bisect_right(FibNumbers, s) # finds end position # calculate the difference to get the number of values bewtween them print(right - left)
#https://www.hackerrank.com/challenges/playing-with-numbers from _bisect import bisect_left def calcSum(start, end, query): result = 0 if end == start : return 0 if start == 0 : result = abs(pre_sum[end - 1] + query * end) else : result = abs(pre_sum[end - 1] - pre_sum[start - 1] + query * (end - start )) return result n = input() nums = map(int, raw_input().split(' ')) nums.sort() pos_zero = bisect_left(nums, 0, 0, n) pre_sum = [0] * n total = 0 for idx, el in enumerate(nums): total += el pre_sum[idx] = total qn = input() queries = map(int, raw_input().split(' ')) t_q = 0 for q in queries: t_q += q pos = bisect_left(nums, t_q, 0, n) pos_abs = bisect_left(nums, abs(t_q), 0, n) pos_abs_negative = bisect_left(nums, - abs(t_q), 0, n)
def CLM_NcRead_1file(ncfile, varnames_print, keep_vars, chunk_keys, \ startdays, enddays, adspinup, vars_all): odata = {} odata_dims = {} odata_tunits = '' try: startdays = float(startdays) except ValueError: startdays = -9999 try: enddays = float(enddays) except ValueError: enddays = -9999 try: f = Dataset(ncfile, 'r') if varnames_print: print('FILE: ' + ncfile + ' ------- ') except: return odata, odata_dims # If key is on the keep list and in nc file, uniquely add to a dictionary for key in f.variables.keys(): # print out all variables contained in nc files if varnames_print: print(key) if (key not in keep_vars) and (not vars_all): continue #cycle the loop, if not required by users and NOT all_vars option if (key not in f.variables or f.variables[key].size <= 0): continue #cycle the loop, if no data if (len(chunk_keys) <= 0) or ( key not in chunk_keys ): # only needs to read data once, if more than one available odata_dims[key] = f.variables[key].dimensions key_val = np.asarray(f.variables[key]) if (hasattr(f.variables[key], '_FillValue')): v_missing = f.variables[key]._FillValue if isinstance(v_missing, (np.float, np.float16, np.float32)): key_val[key_val == v_missing] = np.nan odata[key] = key_val else: continue if ('time' not in odata_dims[key]): continue #cycle the loop, if not time-series dataset # timing option - we do checking thereafter # because we want to have those CONSTANTs read-out, some of which ONLY available in the first CLM nc file. tt = np.asarray( f.variables['time']) # days since model simulation starting time if (odata_tunits == ''): odata_tunits = f.variables['time'].units tdays1 = min(tt) tdays2 = max(tt) if (startdays >= 0): if (startdays > tdays2): odata = {} odata_dims = {} return odata, odata_dims, odata_tunits else: s_index = int(bisect_left(tt, startdays)) odata[key] = odata[key][s_index:, ] if (enddays > 0): if (enddays < tdays1): odata = {} odata_dims = {} return odata, odata_dims, odata_tunits else: e_index = int(bisect_right(tt, enddays)) odata[key] = odata[key][:e_index, ] #ad-spinup run, recal. each component of totsomc_vr, if needed if adspinup: if key in totsomc_vr: sub_indx = totsomc_vr.index(key) odata[key] = odata[key] * ad_factor[sub_indx] if key in totsomn_vr: sub_indx = totsomn_vr.index(key) odata[key] = odata[key] * ad_factor[sub_indx] # summing up of total liter/som C/N, if needed and available if 'TOTLITC_vr' in keep_vars: indx = keep_vars.index('TOTLITC_vr') subs = totlitc_vr for isub in subs: if isub in odata.keys(): if keep_vars[indx] not in odata: odata[keep_vars[indx]] = odata[isub] odata_dims[keep_vars[indx]] = odata_dims[isub] else: odata[ keep_vars[indx]] = odata[keep_vars[indx]] + odata[isub] if 'TOTLITN_vr' in keep_vars: indx = keep_vars.index('TOTLITN_vr') subs = totlitn_vr for isub in subs: if isub in odata.keys(): if keep_vars[indx] not in odata: odata[keep_vars[indx]] = odata[isub] odata_dims[keep_vars[indx]] = odata_dims[isub] else: odata[ keep_vars[indx]] = odata[keep_vars[indx]] + odata[isub] if 'TOTSOMC_vr' in keep_vars: indx = keep_vars.index('TOTSOMC_vr') subs = totsomc_vr for isub in subs: if isub in odata.keys(): if keep_vars[indx] not in odata: odata[keep_vars[indx]] = odata[isub] odata_dims[keep_vars[indx]] = odata_dims[isub] else: odata[ keep_vars[indx]] = odata[keep_vars[indx]] + odata[isub] if 'TOTSOMN_vr' in keep_vars: indx = keep_vars.index('TOTSOMN_vr') subs = totsomn_vr for isub in subs: if isub in odata.keys(): if keep_vars[indx] not in odata: odata[keep_vars[indx]] = odata[isub] odata_dims[keep_vars[indx]] = odata_dims[isub] else: odata[ keep_vars[indx]] = odata[keep_vars[indx]] + odata[isub] # convert 'soilliq' to 'saturation_lia', if available # sat = h2osoi_liq(c,j) / (watsat(c,j)*dz(c,j)*denh2o) denh2o = 1000.0 #kg/m3 if 'SOILSAT_LIQ' in keep_vars: if 'SOILLIQ' in odata.keys(): dary = np.array(odata['SOILLIQ']) dvec = np.array(porosity * dz * denh2o) if (len(dvec.shape) == 2): odata['SOILSAT_LIQ'] = dary / dvec[None, :, :] elif (len(dvec.shape) == 3): odata['SOILSAT_LIQ'] = dary / dvec[None, :, :, :] else: odata['SOILSAT_LIQ'] = dary / dvec odata_dims['SOILSAT_LIQ'] = odata_dims['SOILLIQ'] denice = 917.0 #kg/m3 if 'SOILSAT_ICE' in keep_vars: if 'SOILICE' in odata.keys(): dary = np.array(odata['SOILICE']) dvec = np.array(porosity * dz * denice) if (len(dvec.shape) == 2): odata['SOILSAT_ICE'] = dary / dvec[None, :, :] elif (len(dvec.shape) == 3): odata['SOILSAT_ICE'] = dary / dvec[None, :, :, :] else: odata['SOILSAT_ICE'] = dary / dvec odata_dims['SOILSAT_ICE'] = odata_dims['SOILICE'] # out datasets return odata, odata_dims, odata_tunits
def preprocess(path, electrode_list, frequency_component): """ 1. reads the mat files 2. extract the coherence spectra and comprehension and frequencies scores 3. restricts the coherence spectra to only the specified electrodes and frequencies and to be z-scored Args: path: location of the .mat files electrode_list: list of electrodes to be used for classification frequency_component: the frequency component to be used (+-1) Returns: standardized and filtered coherence spectrum, comprehension scores """ coherence_spectra = [] comprehension_scores = [] frequencies = [] # extract the data set from .mat files for mat_file in sorted(os.listdir(path)): mat_contents = sio.loadmat(os.sep.join([path, mat_file])) for i in range(0, 2): electrodes = [] cluster_indexes = [] session_i = mat_contents['conn'][0, i][0] # get the electrode names label_struct = session_i['labelcmb'][0] for label in label_struct: electrodes = np.append(electrodes, label[0]) # filter for the electrodes to be used for el in electrode_list: cluster_indexes.append(np.where(electrodes == el)[0][0]) # get the coherence spectra and slice to use the specified electrodes only coherence_spectra.append( session_i['cohspctrm'][0][:, cluster_indexes, :]) # get the comprehension scores for j in range(0, len(session_i['trialinfo'][0])): comprehension_scores.append(session_i['trialinfo'][0][j][2]) # get the available frequencies if len(frequencies) == 0: frequencies = session_i['freq'] frequencies = np.concatenate([x for x in frequencies]).flatten() # adjust the shape to be (no_trials, no_electrodes, no_frequencies) coherence_spectra = np.concatenate([x for x in coherence_spectra]) comprehension_scores = np.array(comprehension_scores) # filter for the desired frequencies using binary search if frequency_component is not None: if frequency_component < 1 or frequency_component > 50: raise Exception("Select a frequency between 1 and 50 Hz!") else: lower = frequency_component - 1 upper = frequency_component + 1 idx_lower = bisect_right(frequencies, lower) idx_upper = bisect_left(frequencies, upper) # slice the coherence spectra according to the frequencies to be used coherence_spectra = coherence_spectra[:, :, [ x for x in range(idx_lower, idx_upper + 1) ]] # standardize the coherence spectra coherence_spectra = (coherence_spectra - np.mean(coherence_spectra) ) / np.std(coherence_spectra) return coherence_spectra, comprehension_scores
# 判断元素是否是列表中 from _bisect import bisect_left lst = [1, 3, 4, 5, 7, 8] for i in lst: if i == 8: print('存在') if 4 in lst: print('存在') # set / bisect ============================== list_set = [1, 6, 3, 5, 3, 4] list_bisect = [1, 6, 3, 5, 3, 4] lst = set(list_set) print(lst) for i in lst: if i == 6: print('存在') if 4 in lst: print('存在') list_bisect.sort() if bisect_left(list_bisect, 6): print('存在')
def _extract(self): run_slice_it = RunSliceIterator(self.reader, ms_level=1) # init some variables all_peaks = [] peaks_idx_by_scan_id = {scan_id: PeakIndex() for scan_id in self.scan_ids} curr_rsh, curr_ss = run_slice_it.next() prev_rsh, prev_ss = None, None # next_rsh, next_ss = None, None # init with first rs peaks for curr_s in curr_ss: curr_peaks = curr_s.to_peaks(self.rt_by_scan_id) peaks_idx_by_scan_id[curr_s.scan_id].update(curr_peaks, update_min=True) map(all_peaks.append, curr_peaks) mass_traces = [] already_used_peaks = set() # i = 0 while run_slice_it.has_next(): logging.info("Processing runslice id #{}".format(curr_rsh.id)) next_rsh, next_ss = run_slice_it.next() for next_s in next_ss: next_peaks = next_s.to_peaks(self.rt_by_scan_id) peaks_idx_by_scan_id[next_s.scan_id].update(next_peaks, update_max=True) map(all_peaks.append, next_peaks) # slightly more efficient to iterate over this variable than allpeaks # since it contains less data points not_seen_yet = list(set(all_peaks) - already_used_peaks) # heapq.heapify(not_seen_yet) # logging.info("Sort #{} peaks by intensity".format(len(not_seen_yet))) not_seen_yet.sort(key=lambda p: p.intensity, reverse=True) # all_peaks.sort(key=lambda p: p.intensity, reverse=True) #attrgetter('intensity'), reverse=True) for peak in not_seen_yet: # heapq.nlargest(len(not_seen_yet), not_seen_yet): if peak in already_used_peaks: continue mass_trace = MassTrace() mass_trace.apex_peak = peak already_used_peaks.add(peak) scan_id = peak.scan_id curr_mz = mass_trace.mz_centroid # peak.mz tol = curr_mz * self.mz_tol_ppm * self.PPM # note: surprisingly the dict approach is slower than working directly on the index # with bisect: # next_scan_id, prev_scan_id = self.prev_next_scan_ids_by_scan_id[scan_id] scan_id_idx = bisect_left(self.scan_ids, scan_id) # previous index prev_scan_id_idx = scan_id_idx - 1 prev_scan_id = self.scan_ids[prev_scan_id_idx] if prev_scan_id_idx >= 0 else None # next index next_scan_id_idx = scan_id_idx + 1 next_scan_id = self.scan_ids[next_scan_id_idx] if next_scan_id_idx < self.n else None # to the right right_gap = 0 while next_scan_id is not None: peaks_idx = peaks_idx_by_scan_id[next_scan_id] p = peaks_idx.get_nearest_entity(curr_mz, tol, already_used_peaks) if p is None: # or p in already_used_peaks: right_gap += 1 if right_gap > self.gap_allowed: break else: mass_trace.append(p) already_used_peaks.add(p) next_scan_id_idx -= 1 next_scan_id = self.scan_ids[next_scan_id_idx] if next_scan_id_idx < self.n else None # to the left left_gap = 0 while prev_scan_id is not None: peaks_idx = peaks_idx_by_scan_id[prev_scan_id] p = peaks_idx.get_nearest_entity(curr_mz, tol, already_used_peaks) if p is None: # or p in already_used_peaks: left_gap += 1 if left_gap > self.gap_allowed: break else: mass_trace.append_left(p) already_used_peaks.add(p) prev_scan_id_idx -= 1 prev_scan_id = self.scan_ids[prev_scan_id_idx] if prev_scan_id_idx >= 0 else None if mass_trace.length > 4: # and mass_trace.snr > self.min_snr: mass_traces.append(mass_trace) # end for logging.info("#{} detected mass traces".format(len(mass_traces))) # clear some data points in the set buffer peaks_to_remove = {p for p in all_peaks if prev_rsh is not None and p.rs_id == prev_rsh.id} # clean already used peaks already_used_peaks = already_used_peaks - peaks_to_remove # remove prev rs peaks from all peaks all_peaks = list(set(all_peaks) - peaks_to_remove) # remove peak from the index if prev_rsh is not None: min_mz, max_mz = self.rs_mzs_by_rs_id[prev_rsh.id] for idx in peaks_idx_by_scan_id.viewvalues(): idx.remove_by_mass(min_mz, max_mz) # reassignment to good variables preparing for the next turn of the loop prev_rsh, prev_ss = curr_rsh, curr_ss curr_rsh, curr_ss = next_rsh, next_ss # i += 1 # end while return mass_traces
return summations def find_contiguous_set(keys: list, our_sum: int) -> int: for number in itertools.count(2): for count in range(len(keys) - 1): group = keys[count:count + number] if sum(group) == our_sum: return min(group) + max(group) if __name__ == '__main__': puzzle = open_puzzle("09-encoding-error.txt") puzzle = [int(line.strip()) for line in puzzle] window = 25 current_decryption_window = sorted(puzzle[:window]) part_one_answer = 0 for count in range(window, len(puzzle)): current_summation = calc_sum(current_decryption_window) del current_decryption_window[bisect_left(current_decryption_window, puzzle[count - window])] if puzzle[count] not in current_summation: part_one_answer = puzzle[count] insort_left(current_decryption_window, puzzle[count]) print(part_one_answer) print(find_contiguous_set(puzzle, part_one_answer))
''' Created on Aug 1, 2016 @author: Md. Rezwanul Haque ''' import bisect from _bisect import bisect_left, bisect_right def Fib(n): a,b = 1,1 while b<n: yield b a,b = b, a+b FibA = list(Fib(10**100)) while True: f,s = map(int, input().split()) if f == 0 and s == 0: break left = bisect_left(FibA,f) right = bisect_right(FibA,s) print(right - left)
# list 에서 아이템을 검색하는 작업은 index 메서드를 호출할 때 리스트의 길이에 비례한 선형적 시간이 걸린다. from _bisect import bisect_left x = list(range(10**6)) i = x.index(991234) # bisect_left 같은 bisect 모듈의 함수는 정렬된 아이템 시퀀스를 대상으로 한 효율적인 바이너리 검색을 제공한다. # bisect_left 가 반환한 인덱스는 시퀀스에 들어간 값의 삽입 지점이다. i = bisect_left(x, 991234) print(i) # 바이너리 검색의 복잡도는 로그 형태로 증가한다. 다시 말해 아이템 백만 개를 담은 리스트를 bisect 로 검색할 때 # 걸리는 시간은 아이템 14개를 담은 리스트를 index 로 순차 검색할 떄 걸리는 시간과 거의 같다.
def test_bisect_left(self): from _bisect import bisect_left a = [0, 5, 6, 6, 6, 7] assert bisect_left(a, None) == 0 assert bisect_left(a, -3) == 0 assert bisect_left(a, 0) == 0 assert bisect_left(a, 3) == 1 assert bisect_left(a, 5) == 1 assert bisect_left(a, 5.5) == 2 assert bisect_left(a, 6) == 2 assert bisect_left(a, 6.0) == 2 assert bisect_left(a, 6.1) == 5 assert bisect_left(a, 7) == 5 assert bisect_left(a, 8) == 6 a = [] assert bisect_left(a, 123) == 0 a = [9] assert bisect_left(a, -123) == 0 assert bisect_left(a, 9) == 0 assert bisect_left(a, 123) == 1 a = [9, 9] assert bisect_left(a, -123) == 0 assert bisect_left(a, 9) == 0 assert bisect_left(a, 123) == 2 a = [4, 6, 6, 9] assert bisect_left(a, 6, 0) == 1 assert bisect_left(a, 6, 1) == 1 assert bisect_left(a, 6, 2) == 2 assert bisect_left(a, 6, 3) == 3 assert bisect_left(a, 6, 4) == 4 assert bisect_left(a, 6, 0, 0) == 0 assert bisect_left(a, 6, 0, 1) == 1 assert bisect_left(a, 6, 0, 2) == 1 assert bisect_left(a, 6, 0, 3) == 1 assert bisect_left(a, 6, 0, 4) == 1 raises(ValueError, bisect_left, [1, 2, 3], 5, -1, 3)
def delete_from_leaf(self, key): i = bisect_left(self.keys, key) val = self.values[i] del self.keys[i] del self.values[i] return val