from sortedcontainers import SortedList # http://www.grantjenks.com/docs/sortedcontainers/ for case in range(int(input())): N, K = map(int, input().split()) lst = SortedList([N]) for _ in range(K - 1): s = lst.pop() l, r = s // 2, (s - 1) // 2 if l != 0: lst.add(l) if r != 0: lst.add(r) s = lst.pop() l, r = s // 2, (s - 1) // 2 ans1 = max(l, r) ans2 = min(l, r) print('Case #%d: %s %s' % (case + 1, ans1, ans2))
def test_setitem_valueerror2(): slt = SortedList(range(10)) slt[0] = 10
def test_reversed(): slt = SortedList(range(10000)) rev = reversed(slt) assert all(tup[0] == tup[1] for tup in zip(range(9999, -1, -1), rev))
def test_setitem_slice_bad2(): slt = SortedList(range(100)) slt._reset(17) slt[20:30] = range(10, 20)
def test_setitem_extended_slice_bad2(): slt = SortedList(range(100)) slt._reset(17) slt[40:90:5] = list(range(10))
def test_setitem_slice_aliasing(): slt = SortedList([0]) slt[1:1] = slt assert slt == [0, 0]
def test_setitem_slice_bad(): slt = SortedList(range(100)) slt._reset(17) slt[:10] = list(reversed(range(10)))
def generate_drums(): """Generate a new drum groove by querying the model.""" global drums_bundle global generated_drums global playable_notes global seed_drum_sequence global num_steps global qpm global total_seconds global temperature drums_config_id = drums_bundle.generator_details.id drums_config = drums_rnn_model.default_configs[drums_config_id] generator = drums_rnn_sequence_generator.DrumsRnnSequenceGenerator( model=drums_rnn_model.DrumsRnnModel(drums_config), details=drums_config.details, steps_per_quarter=drums_config.steps_per_quarter, checkpoint=melody_rnn_generate.get_checkpoint(), bundle=drums_bundle) generator_options = generator_pb2.GeneratorOptions() generator_options.args['temperature'].float_value = temperature generator_options.args['beam_size'].int_value = 1 generator_options.args['branch_factor'].int_value = 1 generator_options.args['steps_per_iteration'].int_value = 1 if seed_drum_sequence is None: primer_drums = magenta.music.DrumTrack([frozenset([36])]) primer_sequence = primer_drums.to_sequence(qpm=qpm) local_num_steps = num_steps else: primer_sequence = seed_drum_sequence local_num_steps = num_steps * 2 tempo = primer_sequence.tempos.add() tempo.qpm = qpm step_length = 60. / qpm / 4.0 total_seconds = local_num_steps * step_length # Set the start time to begin on the next step after the last note ends. last_end_time = (max( n.end_time for n in primer_sequence.notes) if primer_sequence.notes else 0) generator_options.generate_sections.add(start_time=last_end_time + step_length, end_time=total_seconds) generated_sequence = generator.generate(primer_sequence, generator_options) generated_sequence = sequences_lib.quantize_note_sequence( generated_sequence, 4) if seed_drum_sequence is not None: i = 0 while i < len(generated_sequence.notes): if generated_sequence.notes[i].quantized_start_step < num_steps: del generated_sequence.notes[i] else: generated_sequence.notes[i].quantized_start_step -= num_steps generated_sequence.notes[i].quantized_end_step -= num_steps i += 1 drum_pattern = [(n.pitch, n.quantized_start_step, n.quantized_end_step) for n in generated_sequence.notes] # First clear the last drum pattern. if len(playable_notes) > 0: playable_notes = SortedList( [x for x in playable_notes if x.type != 'drums'], key=lambda x: x.onset) for p, s, e in drum_pattern: playable_notes.add( PlayableNote(type='drums', note=[], instrument=DRUM_MAPPING[p], onset=s))
def cc_event(addr, tags, args, source): """Handler for `/ccevent` messages from SuperCollider. Logic for dealine with the volume knob in the iRig mini keyboard. - If in lowest position (0): mode = 'tap'. - Else if in lower half of range, mode = 'bass'. - Else if in upper half (but not max), mode = 'chords'. - Else if at highest position (127): mode = 'improv'. Args: addr: Address message sent to. tags: Tags in message. args: Arguments passed in message. source: Source of sender. """ global nanokontrol_id global mode global playable_instruments global time_signature global qpm global last_tap_onset global beat_length global last_first_beat_for_record global bass_line global playable_notes global seed_drum_sequence global temperature global bass_volume global num_bars global chords_volume global improv_volume global play_loop if not args: return cc_num, cc_chan, cc_src, cc_args = args if nanokontrol_id is None: nanokontrol_id = cc_args return if cc_args == nanokontrol_id: channel_name = nanokontrolmap.cc_messages[cc_chan][0] lowest_value = nanokontrolmap.cc_messages[cc_chan][2][0] highest_value = nanokontrolmap.cc_messages[cc_chan][2][1] # Logic for setting tempo, time signature, and looper. if channel_name == 'play' and cc_num == highest_value: play_loop = True elif channel_name == 'stop' and cc_num == highest_value: play_loop = False elif channel_name == 'track1_mute' and cc_num == highest_value: if 'click' in playable_instruments: playable_instruments.remove('click') else: playable_instruments.add('click') elif channel_name == 'track1_solo' and cc_num == highest_value: if last_tap_onset is None: last_tap_onset = time.time() return curr_time = time.time() time_delta = curr_time - last_tap_onset last_tap_onset = curr_time if time_delta > MAX_TAP_DELAY: return if beat_length is None: beat_length = time_delta else: beat_length += time_delta beat_length /= 2 qpm = 60.0 / beat_length elif channel_name == 'track1_knob': qpm = 300 * cc_num / float(highest_value) elif channel_name == 'track_left' and cc_num == highest_value: time_signature.numerator = max(2, time_signature.numerator - 1) set_click() elif channel_name == 'track_right' and cc_num == highest_value: time_signature.numerator += 1 set_click() elif channel_name == 'marker_left' and cc_num == highest_value: time_signature.denominator = max(4, time_signature.denominator / 2) set_click() elif channel_name == 'marker_right' and cc_num == highest_value: time_signature.denominator = min(16, time_signature.denominator * 2) set_click() elif channel_name == 'rew' and cc_num == highest_value: num_bars = max(1, num_bars - 1) set_click() elif channel_name == 'ff' and cc_num == highest_value: num_bars = min(4, num_bars + 1) set_click() # Logic for controlling the bass. elif channel_name == 'track2_slider': bass_volume = 5.0 * cc_num / float(highest_value) print_status() elif channel_name == 'track2_mute' and cc_num == highest_value: if 'bass' in playable_instruments: playable_instruments.remove('bass') else: playable_instruments.add('bass') elif channel_name == 'track2_record' and cc_num == highest_value: mode = 'bass' last_first_beat_for_record = None # Clear off last bass line. playable_notes = SortedList( [x for x in playable_notes if x.type != 'bass'], key=lambda x: x.onset) bass_line = [] # Logic for controlling drums. elif channel_name == 'track3_solo' and cc_num == highest_value: mode = 'free' # Clear off last drum groove. playable_notes = SortedList( [x for x in playable_notes if x.type != 'drums'], key=lambda x: x.onset) seed_drum_sequence = music_pb2.NoteSequence() # First add a kick on each downbeat and hi-hats for each click. for playable_note in playable_notes: if playable_note.type != 'click': continue drum_note = seed_drum_sequence.notes.add() pitch = 42 if playable_note.instrument == 'click2' else 36 drum_note.pitch = pitch drum_note.quantized_start_step = playable_note.onset drum_note.quantized_end_step = playable_note.onset + 4 drum_note.is_drum = True playable_notes.add( PlayableNote(type='drums', note=[], instrument=DRUM_MAPPING[pitch], onset=playable_note.onset)) # Now add snare hits that match the bass line. for bass_note in bass_line: drum_note = seed_drum_sequence.notes.add() pitch = 38 drum_note.pitch = pitch drum_note.quantized_start_step = bass_note.onset drum_note.quantized_end_step = bass_note.onset + 4 # A quarter note. drum_note.is_drum = True playable_notes.add( PlayableNote(type='drums', note=[], instrument='snare', onset=bass_note.onset)) elif channel_name == 'track3_mute' and cc_num == highest_value: if 'drums' in playable_instruments: playable_instruments.remove('drums') else: playable_instruments.add('drums') elif channel_name == 'track3_record' and cc_num == highest_value: mode = 'free' dt = threading.Thread(target=generate_drums) dt.start() elif channel_name == 'track3_knob': temperature = max(0.01, cc_num / float(highest_value) * 5.0) # Logic for controlling chords. elif channel_name == 'track4_slider': chords_volume = 5.0 * cc_num / float(highest_value) print_status() elif channel_name == 'track4_mute' and cc_num == highest_value: if 'chords' in playable_instruments: playable_instruments.remove('chords') else: playable_instruments.add('chords') elif channel_name == 'track4_record' and cc_num == highest_value: mode = 'chords' # Clear off last chords line. playable_notes = SortedList( [x for x in playable_notes if x.type != 'chords'], key=lambda x: x.onset) last_first_beat_for_record = None # Logic for controlling improv. elif channel_name == 'track5_slider': improv_volume = 5.0 * cc_num / float(highest_value) print_status() elif channel_name == 'track5_solo' and cc_num == highest_value: mode = 'free' elif channel_name == 'track5_record' and cc_num == highest_value: mode = 'improv' print_status()
segment = {'img_id': img_id, 'top': lines[i], 'bottom': lines[j], 'height': lines[j] - lines[i], 'ann_ids': annids} if lines[i] == 0: top_segs.append(segment) elif lines[j] == 2048: bot_segs.append(segment) else: mid_segs.append(segment) i=j+1 top_segs = SortedList(top_segs, key=lambda seg: seg['height']) bot_segs = SortedList(bot_segs, key=lambda seg: seg['height']) mid_segs = SortedList(mid_segs, key=lambda seg: seg['height']) mid_tot=len(mid_segs) mid_heights = np.array([seg['height'] for seg in mid_segs]) mid_weights = np.sqrt(mid_heights) prefix_sum = np.array(mid_weights) for i in range(1, mid_tot): prefix_sum[i] = prefix_sum[i - 1] + prefix_sum[i] def cut_image(gen_image, segment, img_id, ann_id, current_height): image_info = img_info[segment['img_id']] ori_anns = coco.load_anns(segment['ann_ids']) anns=copy.deepcopy(ori_anns)
class TimeSignature: numerator = 7 denominator = 8 time_signature = TimeSignature() qpm = magenta.music.DEFAULT_QUARTERS_PER_MINUTE num_bars = 2 num_steps = int(num_bars * time_signature.numerator * 16 / time_signature.denominator) PlayableNote = collections.namedtuple('playable_note', ['type', 'note', 'instrument', 'onset']) playable_notes = SortedList(key=lambda x: x.onset) play_loop = False seed_drum_sequence = None last_tap_onset = None beat_length = None last_first_beat = 0.0 # Last time we passed the first beat during playback. # Last first beat from the moment the bass started playing. last_first_beat_for_record = None bass_line = [] bass_volume = 1.0 chords_volume = 1.0 improv_volume = 1.0 MAX_TAP_DELAY = 5.0 # Robot improv specific variables. min_primer_length = 20
from enum import Enum from sortedcontainers import SortedList from sortiton import * import random from pprint import pprint import numpy as np import ecdsa import hashlib import secrets import pickle import sys import os.path from keygen import * import config eventQ = SortedList() allNodes = [] delays = [] blockDelays=[] sk_List = [] pk_List = [] w_list = [] ctx_Weight = {} INVOKE_BA_START_COUNT_VOTE_ONE = 1 INVOKE_BA_START_COUNT_VOTE_TWO = 2 INVOKE_BA_START_COUNT_VOTE_THREE = 3 DO_NOT_INVOKE_ANY_MORE_COUNT_VOTE = 0
def __init__(self, m: int, k: int): from sortedcontainers import SortedList self.m, self.k = m, k self.queue = deque() self.sl = SortedList() self.total = self.left_k = self.right_k = 0
from datetime import datetime import logging import threading import tbapy from sortedcontainers import SortedList # Define variables logger = logging.getLogger('FRCMatchFinderLogger') tba = tbapy.TBA( '9YP15wdwpFPjJri1tGj6BGwWCkHxNVaM9xKmv2Z0aYikXOXOKtOKol9gD5yntLJ5') sync_cond = threading.Condition() watcher_lock = threading.Condition() # Needed lists teams = [] matches = SortedList() current = [] upcoming = [] # Range in seconds to check current matches within MATCH_RANGE = 150 # Range in seconds to check upcoming matches within UPCOMING_RANGE = 3600 # file for default teams to find TEAMS_FILE = 'teams.txt' def main(): try:
def test_getitem_indexerror2(): slt = SortedList(range(100)) slt[200]
def __init__(self, n: int): self.data = SortedList((i, i) for i in range(1, n+1))
def test_getitem_indexerror3(): slt = SortedList(range(100)) slt[-101]
# find the 25 closest users to user i movies_i = user2movie[i] movies_i_set = set(movies_i) # calculate avg and deviation ratings_i = {movie: usermovie2rating[(i, movie)] for movie in movies_i} avg_i = np.mean(list(ratings_i.values())) dev_i = {movie: (rating - avg_i) for movie, rating in ratings_i.items()} dev_i_values = np.array(list(dev_i.values())) sigma_i = np.sqrt(dev_i_values.dot(dev_i_values)) # save these for later use averages.append(avg_i) deviations.append(dev_i) sl = SortedList() for j in range(N): # don't include yourself if j != i: movies_j = user2movie[j] movies_j_set = set(movies_j) common_movies = (movies_i_set & movies_j_set) # intersection if len(common_movies) > limit: # calculate avg and deviation ratings_j = { movie: usermovie2rating[(j, movie)] for movie in movies_j } avg_j = np.mean(list(ratings_j.values())) dev_j = { movie: (rating - avg_j)
def test_setitem_empty_slice(): sl = SortedList(['a']) sl[1:0] = ['b'] assert sl == ['a', 'b']
def test_remove_valueerror1(): slt = SortedList() slt.remove(0)
def test_setitem_slice_bad1(): slt = SortedList(range(100)) slt._reset(17) slt[10:20] = range(20, 30)
def test_remove_valueerror2(): slt = SortedList(range(100)) slt._reset(10) slt.remove(100)
def test_setitem_extended_slice_bad1(): slt = SortedList(range(100)) slt._reset(17) slt[20:80:3] = list(range(10))
def test_remove_valueerror3(): slt = SortedList([1, 2, 2, 2, 3, 3, 5]) slt.remove(4)
def test_setitem_valueerror1(): slt = SortedList(range(10)) slt[9] = 0
def test_getitem_slicezero(): slt = SortedList(range(100)) slt._reset(17) slt[::0]
def test_iter(): slt = SortedList(range(10000)) itr = iter(slt) assert all(tup[0] == tup[1] for tup in zip(range(10000), itr))
def test_getitem_indexerror1(): slt = SortedList() slt[5]
def test_reverse(): slt = SortedList(range(10000)) slt.reverse()
import time from sortedcontainers import SortedList # This opens a handle to your file, in 'r' read mode file_handle = open('input.txt', 'r') lines_list = file_handle.readlines() int_list = [] for val in lines_list: int_list.append(int(val)) #int_list = [+3, +3, +4, -2, -4] print(sum(int_list)) sum_list = SortedList([]) temp_value = int_list[0] index = 1 start = time.time() while temp_value not in sum_list: sum_list.add(temp_value) temp_value += int_list[index] index += 1 if index == len(int_list): index = 0 #print(len(sum_list)) end = time.time() print(f"value: {temp_value}") print(f"time: {end - start}")