id
stringlengths 1
7
| text
stringlengths 6
1.03M
| dataset_id
stringclasses 1
value |
|---|---|---|
148234
|
#!/usr/bin/env python3
import unittest
import learn2learn as l2l
TOO_BIG_TO_TEST = [
'tiered-imagenet',
]
class UtilTests(unittest.TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def test_tasksets(self):
names = l2l.vision.benchmarks.list_tasksets()
for name in names:
if name in TOO_BIG_TO_TEST:
continue
tasksets = l2l.vision.benchmarks.get_tasksets(name, root='./data')
self.assertTrue(hasattr(tasksets, 'train'))
batch = tasksets.train.sample()
self.assertTrue(batch is not None)
self.assertTrue(hasattr(tasksets, 'validation'))
batch = tasksets.validation.sample()
self.assertTrue(batch is not None)
self.assertTrue(hasattr(tasksets, 'test'))
batch = tasksets.test.sample()
self.assertTrue(batch is not None)
del tasksets, batch
if __name__ == '__main__':
unittest.main()
|
StarcoderdataPython
|
1726342
|
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from bin.comparing.task import Task
from bin.comparing.satellite import Satellite
from bin.comparing.bnb import BnB
from operator import itemgetter
from json import loads
from json import load
from bin.config import Config
import os
# find and remember the root path of the app
root_dir = os.path.dirname(os.path.realpath(__file__))
# working dir is set to root path of the app
os.chdir(root_dir)
config = Config(root_dir)
json_file = 'instance22.json'
print(json_file)
observations = 0
uplinks = 0
downlinks = 0
emergency = 0
visibility = 0
window= 0
priority = 0
with open(json_file) as f:
duration = 0
tasks = load(f).get('tasks')
for task in tasks:
if task.get('task_type') == 'O':
observations += 1
elif task.get('task_type') == 'U':
uplinks += 1
elif task.get('task_type') == 'D':
downlinks += 1
if task.get('emergency') == True:
emergency += 1
visibilities = task.get('visible_at')
duration = task.get('w_end') - task.get('w_start')
visibility += len(visibilities)
window += duration
priority += task.get('priority') or 0
print({"o": observations})
print({"u": uplinks})
print({"d": downlinks})
print({"e": emergency})
print({"v": visibility})
print({"w": window})
print({"w": window})
print({"p": priority})
|
StarcoderdataPython
|
1604761
|
<filename>pkg/matcher.py
import math
import typing
from pathlib import Path
import cv2
import numpy as np
import unidecode
from matplotlib import pyplot as plt
from .image import Image
from .misc import deduplicate_list, cosine_similarity, find_better_word
# FLANN_INDEX_LSH = 6
class Matcher():
"""
Matches a single image against a set of images
"""
# index_params = dict(algorithm=FLANN_INDEX_LSH,
# table_number=6, # 12
# key_size=12, # 20
# multi_probe_level=1) # 2
# search_params = dict(checks=50)
def __init__(self, language: typing.Optional[str] = None):
print("[I] Initializing Matcher...")
self.language = language
self.matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=False)
self._candidate_images: typing.List[Image] = []
self._training_bags = []
self._dictionary = []
@classmethod
def from_paths(self, language: typing.Optional[str] = None, *candidate_images_paths: typing.List[Path]):
return Matcher.from_images(language, *[Image(training_image_path) for training_image_path in candidate_images_paths])
@classmethod
def from_images(self, language: typing.Optional[str] = None, *candidate_images: typing.List[Path]):
matcher = Matcher(language)
matcher.set_candidate_images(candidate_images)
return matcher
def set_candidate_images(self, images: typing.List[Image]):
self._candidate_images = []
self._training_bags = []
self._dictionary = []
self.matcher.clear()
for image in images:
print("\t[D] Adding candidate image: ", image.image_path)
# print("Shape", image.image_data.shape)
# plt.imshow(image.image_data)
# plt.show()
image.get_bag_of_words(self.language)
image.get_keypoints_and_descriptors()
self._candidate_images.append(image)
self.matcher.add([image.descriptor])
self._training_bags.append(image.bag)
self._dictionary.extend(list(image.bag.keys()))
self.matcher.train()
self._deduplicate_dictionary()
def _deduplicate_dictionary(self):
self._dictionary = deduplicate_list(self._dictionary)
def match(self, query_image: Image, do_keypoints: bool = True, do_text: bool = True, keypoints_weight: float = 1, text_weight: float = 1):
assert len(self._candidate_images) > 0, "Matcher has no candidate images"
assert do_text or do_keypoints, "At least one matching method is required"
# query_image.reset()
# query_image.get_keypoints_and_descriptors()
# query_image.ocr_preprocessing()
if do_keypoints:
keypoints_score, matches = self._match_keypoints(query_image)
if do_text:
text_score = self._match_text(query_image)
scores = [0] * len(self._candidate_images)
for i in range(len(self._candidate_images)):
# scores[i] = (keypoints_weight * keypoints_score[i] + text_weight * text_score[i]) / (keypoints_weight + text_weight)
scores[i] = 0
total_weight = 0
if do_keypoints:
scores[i] += keypoints_score[i] * keypoints_weight
total_weight += keypoints_weight
if do_text:
scores[i] += text_score[i] * text_weight
total_weight += text_weight
scores[i] /= total_weight
if not do_keypoints:
matches = []
return Match(query_image, self._candidate_images, scores, matches)
def _match_keypoints(self, query_image: Image) -> typing.Tuple[typing.List[int], typing.List[typing.Any]]:
"""
Match query image to candidate images using keypoints.
Returns array of scores per image
"""
query_image.get_keypoints_and_descriptors()
# matches = self.matcher.match(query_image.descriptor)
matches = self.matcher.knnMatch(query_image.descriptor, k=2)
good = []
for m_n in matches:
if len(m_n) == 1:
good.append(m_n[0])
continue
elif len(m_n) != 2:
continue
(m, n) = m_n
if m.distance < 0.7 * n.distance:
good.append(m)
images_scores = [0] * len(self._candidate_images)
images_matches = [None] * len(self._candidate_images)
for image_index, image in enumerate(self._candidate_images):
matches_scores = []
matches = []
for i, match in enumerate(good):
if match.imgIdx != image_index:
continue
matches.append(match)
matches_scores.append((256 - match.distance) / 256)
match_cnt = len(matches_scores)
if match_cnt <= 0:
continue
images_scores[image_index] = (
0.5 + ((math.tanh(match_cnt / 3 - 1)) / 2)) * (sum(matches_scores) / match_cnt)
images_matches[image_index] = matches
return images_scores, images_matches
def _match_text(self, query_image: Image):
original_query_bag = query_image.get_bag_of_words(self.language)
query_bag = {}
for word, count in original_query_bag.items():
query_bag[find_better_word(word, self._dictionary)] = count
dictionary = self._dictionary.copy()
dictionary.extend(list(query_bag))
dictionary = deduplicate_list(dictionary)
bags = [query_bag]
bags.extend(self._training_bags.copy())
vectors = []
for bag in bags:
vector = [0] * len(dictionary)
for i, word in enumerate(dictionary):
if word in bag:
vector[i] = bag[word]
vectors.append(vector)
query_vector = vectors[0]
train_vectors = vectors[1:]
return [cosine_similarity(query_vector, train_vector) for train_vector in train_vectors]
class Match():
def __init__(self, query_image: Image, images: typing.List[Image], scores: typing.List[float], kp_matches: typing.List[typing.Any]):
if len(kp_matches) <= 0:
kp_matches = [None] * len(images)
self.query_image = query_image
self._best_index: int = -1
self.candidates = list(zip(images, scores, kp_matches))
if len(self.candidates) <= 0:
return
self.candidates.sort(key=lambda c: c[1], reverse=True)
if self.candidates[0][1] != 0:
self._best_index = 0
self.candidates = self.candidates[:3]
# first_zero = self.candidates.index(
# next(filter(lambda c: c != 0, self.candidates)))
# self.candidates = self.candidates[:first_zero]
def best_index(self):
return self._best_index
def best_image(self):
if self._best_index < 0:
return None
return self.candidates[self._best_index][0]
def best_match(self):
if self._best_index < 0:
return None
return self.candidates[self._best_index]
def visualize_best(self):
if self._best_index < 0:
return np.zeros((600, 400))
draw_params = dict(
matchColor=(0, 255, 0), # draw matches in green color
singlePointColor=(255, 0, 0),
# matchesMask = matchesMask, # draw only inliers
flags=2
)
kp_matches = self.candidates[self._best_index][2]
return cv2.drawMatches(self.query_image.image_data, self.query_image.keypoints,
self.best_image().image_data, self.best_image().keypoints, kp_matches, None, **draw_params)
def plot_best(self, window_name="Best match"):
plt.imshow(self.visualize_best())
plt.show()
|
StarcoderdataPython
|
3361165
|
# -*- coding: utf-8 -*-
from pathlib import Path
from example_app_01 import app
from example_app_01.data_fixtures import add_data_fixtures, recreate_db
PROJECT_BASE_FILEPATH = Path(__file__).resolve().parent
APP_01_FILEPATH = Path(PROJECT_BASE_FILEPATH).joinpath('example_app_01')
APP_01_DB_FILEPATH = Path(APP_01_FILEPATH).joinpath(app.config['DATABASE_FILENAME'])
if not APP_01_DB_FILEPATH.exists():
recreate_db()
add_data_fixtures()
app.run(debug=True)
|
StarcoderdataPython
|
1614609
|
<filename>projects/data_generation/synthetic_multi_view_facial_image_generation/algorithm/Rotate_and_Render/models/networks/__init__.py
import torch
from algorithm.Rotate_and_Render.models.networks.base_network import BaseNetwork
from algorithm.Rotate_and_Render.models.networks import loss
from algorithm.Rotate_and_Render.models.networks import discriminator
from algorithm.Rotate_and_Render.models.networks import generator
from algorithm.Rotate_and_Render.models.networks import encoder
from algorithm.Rotate_and_Render.models.networks.render import Render
import algorithm.Rotate_and_Render.util.util as util
__all__ = ['loss', 'discriminator', 'generator', 'encoder', 'Render']
def find_network_using_name(target_network_name, filename):
target_class_name = target_network_name + filename
module_name = 'algorithm.Rotate_and_Render.models.networks.' + filename
network = util.find_class_in_module(target_class_name, module_name)
assert issubclass(network, BaseNetwork), \
"Class %s should be a subclass of BaseNetwork" % network
return network
def modify_commandline_options(parser, is_train):
opt, _ = parser.parse_known_args()
netG_cls = find_network_using_name(opt.netG, 'generator')
parser = netG_cls.modify_commandline_options(parser, is_train)
if is_train:
netD_cls = find_network_using_name(opt.netD, 'discriminator')
parser = netD_cls.modify_commandline_options(parser, is_train)
netE_cls = find_network_using_name('conv', 'encoder')
parser = netE_cls.modify_commandline_options(parser, is_train)
return parser
def create_network(cls, opt):
net = cls(opt)
net.print_network()
if len(opt.gpu_ids) > 0:
assert(torch.cuda.is_available())
net.cuda()
net.init_weights(opt.init_type, opt.init_variance)
return net
def define_G(opt):
netG_cls = find_network_using_name(opt.netG, 'generator')
return create_network(netG_cls, opt)
def define_D(opt):
netD_cls = find_network_using_name(opt.netD, 'discriminator')
return create_network(netD_cls, opt)
def define_E(opt):
# there exists only one encoder type
netE_cls = find_network_using_name('conv', 'encoder')
return create_network(netE_cls, opt)
|
StarcoderdataPython
|
3353162
|
from conans.assets.templates.new_v2_cmake import source_cpp, source_h, test_main
conanfile_sources_v2 = """import os
from conan import ConanFile
from conan.tools.meson import MesonToolchain, Meson
from conan.tools.layout import basic_layout
from conan.tools.files import copy
class {package_name}Conan(ConanFile):
name = "{name}"
version = "{version}"
# Binary configuration
settings = "os", "compiler", "build_type", "arch"
options = {{"shared": [True, False], "fPIC": [True, False]}}
default_options = {{"shared": False, "fPIC": True}}
# Sources are located in the same place as this recipe, copy them to the recipe
exports_sources = "meson.build", "src/*"
def config_options(self):
if self.settings.os == "Windows":
del self.options.fPIC
def layout(self):
basic_layout(self)
def generate(self):
tc = MesonToolchain(self)
tc.generate()
def build(self):
meson = Meson(self)
meson.configure()
meson.build()
def package(self):
meson = Meson(self)
meson.install()
# Meson cannot install dll/so in "bin" and .a/.lib in "lib"
lib = os.path.join(self.package_folder, "lib")
bin = os.path.join(self.package_folder, "bin")
copy(self, "*.so", lib, bin)
copy(self, "*.dll", lib, bin)
def package_info(self):
self.cpp_info.libs = ["{name}"]
"""
test_conanfile_v2 = """import os
from conan import ConanFile
from conans import tools
from conan.tools.meson import MesonToolchain, Meson
from conan.tools.layout import basic_layout
class {package_name}TestConan(ConanFile):
settings = "os", "compiler", "build_type", "arch"
# VirtualBuildEnv and VirtualRunEnv can be avoided if "tools.env.virtualenv:auto_use" is defined
# (it will be defined in Conan 2.0)
generators = "PkgConfigDeps", "MesonToolchain", "VirtualBuildEnv", "VirtualRunEnv"
apply_env = False
def build(self):
meson = Meson(self)
meson.configure()
meson.build()
def layout(self):
basic_layout(self)
def test(self):
if not tools.cross_building(self):
cmd = os.path.join(self.cpp.build.bindirs[0], "example")
self.run(cmd, env="conanrun")
"""
_meson_build_test = """\
project('Test{name}', 'cpp')
{name} = dependency('{name}', version : '>=0.1')
executable('example', 'src/example.cpp', dependencies: {name})
"""
_meson_build = """\
project('{name} ', 'cpp')
library('{name}', 'src/{name}.cpp', install: true, install_dir: 'lib')
install_headers('src/{name}.h')
"""
def get_meson_lib_files(name, version, package_name="Pkg"):
files = {"conanfile.py": conanfile_sources_v2.format(name=name, version=version,
package_name=package_name),
"src/{}.cpp".format(name): source_cpp.format(name=name, version=version),
"src/{}.h".format(name): source_h.format(name=name, version=version),
"meson.build": _meson_build.format(name=name, version=version),
"test_package/conanfile.py": test_conanfile_v2.format(name=name,
version=version,
package_name=package_name),
"test_package/src/example.cpp": test_main.format(name=name),
"test_package/meson.build": _meson_build_test.format(name=name)}
return files
conanfile_exe = """from conan import ConanFile
from conan.tools.meson import MesonToolchain, Meson
class {package_name}Conan(ConanFile):
name = "{name}"
version = "{version}"
# Binary configuration
settings = "os", "compiler", "build_type", "arch"
# Sources are located in the same place as this recipe, copy them to the recipe
exports_sources = "meson.build", "src/*"
def layout(self):
self.folders.build = "build"
def generate(self):
tc = MesonToolchain(self)
tc.generate()
def build(self):
meson = Meson(self)
meson.configure()
meson.build()
def package(self):
meson = Meson(self)
meson.install()
"""
test_conanfile_exe_v2 = """import os
from conan import ConanFile
from conans import tools
class {package_name}TestConan(ConanFile):
settings = "os", "compiler", "build_type", "arch"
# VirtualRunEnv can be avoided if "tools.env.virtualenv:auto_use" is defined
# (it will be defined in Conan 2.0)
generators = "VirtualRunEnv"
apply_env = False
def test(self):
if not tools.cross_building(self):
self.run("{name}", env="conanrun")
"""
_meson_build_exe = """\
project('{name} ', 'cpp')
executable('{name}', 'src/{name}.cpp', 'src/main.cpp', install: true)
"""
def get_meson_exe_files(name, version, package_name="Pkg"):
files = {"conanfile.py": conanfile_exe.format(name=name, version=version,
package_name=package_name),
"src/{}.cpp".format(name): source_cpp.format(name=name, version=version),
"src/{}.h".format(name): source_h.format(name=name, version=version),
"src/main.cpp": test_main.format(name=name),
"meson.build": _meson_build_exe.format(name=name, version=version),
"test_package/conanfile.py": test_conanfile_exe_v2.format(name=name,
version=version,
package_name=package_name)
}
return files
|
StarcoderdataPython
|
3331423
|
import bot.bot_helpers as bot_helpers
if __name__ == '__main__':
updater = bot_helpers.get_configured_updater()
bot_helpers.start_bot(updater)
|
StarcoderdataPython
|
3398955
|
#!/usr/bin/env python
#
# Licensed under the Apache License, Version 2.0 (the "License");
# You may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0OA
#
# Authors:
# - <NAME>, <<EMAIL>>, 2019
import traceback
try:
# python 3
from queue import Queue
except ImportError:
# Python 2
from Queue import Queue
from idds.common.constants import (Sections, RequestStatus, RequestLocking,
WorkprogressStatus)
from idds.common.utils import setup_logging
from idds.core import (requests as core_requests,
workprogress as core_workprogress)
from idds.agents.common.baseagent import BaseAgent
setup_logging(__name__)
class Clerk(BaseAgent):
"""
Clerk works to process requests and converts requests to transforms.
"""
def __init__(self, num_threads=1, poll_time_period=10, retrieve_bulk_size=10, **kwargs):
super(Clerk, self).__init__(num_threads=num_threads, **kwargs)
self.poll_time_period = int(poll_time_period)
self.retrieve_bulk_size = int(retrieve_bulk_size)
self.config_section = Sections.Clerk
self.new_task_queue = Queue()
self.new_output_queue = Queue()
self.running_task_queue = Queue()
self.running_output_queue = Queue()
def get_new_requests(self):
"""
Get new requests to process
"""
# req_status = [RequestStatus.TransformingOpen]
# reqs_open = core_requests.get_requests_by_status_type(status=req_status, time_period=3600)
# self.logger.info("Main thread get %s TransformingOpen requests to process" % len(reqs_open))
req_status = [RequestStatus.New, RequestStatus.Extend]
reqs_new = core_requests.get_requests_by_status_type(status=req_status, locking=True,
bulk_size=self.retrieve_bulk_size)
self.logger.debug("Main thread get %s [New+Extend] requests to process" % len(reqs_new))
if reqs_new:
self.logger.info("Main thread get %s [New+Extend] requests to process" % len(reqs_new))
return reqs_new
def process_new_request(self, req):
try:
req_id = req['request_id']
# workload_id = req['workload_id']
workflow = req['request_metadata']['workflow']
workflows = workflow.get_exact_workflows()
existed_wps = core_workprogress.get_workprogresses(req_id)
existed_workflows = [wp['workprogress_metadata']['workflow'] for wp in existed_wps]
new_workflows = []
for wf in workflows:
if wf not in existed_workflows:
new_workflows.append(wf)
wps = []
for wf in new_workflows:
primary_init_collection = wf.get_primary_initial_collection()
workprogress = {'request_id': req_id,
'scope': primary_init_collection['scope'],
'name': primary_init_collection['name'],
'priority': req['priority'],
'status': req['status'],
'locking': req['locking'],
'expired_at': req['expired_at'],
'errors': None,
'workprogress_metadata': {'workflow': wf},
'processing_metadata': None}
wps.append(workprogress)
ret_req = {'request_id': req['request_id'],
'status': RequestStatus.Transforming,
'processing_metadata': {'total_workprogresses': len(workflows),
'new_workprogresses': len(new_workflows)},
'new_workprogresses': wps}
except Exception as ex:
self.logger.error(ex)
self.logger.error(traceback.format_exc())
ret_req = {'request_id': req['request_id'],
'status': RequestStatus.Failed,
'errors': {'msg': '%s: %s' % (ex, traceback.format_exc())}}
return ret_req
def process_new_requests(self):
"""
Process new request
"""
ret = []
while not self.new_task_queue.empty():
try:
req = self.new_task_queue.get()
if req:
self.logger.info("Main thread processing new requst: %s" % req)
ret_req = self.process_new_request(req)
if ret_req:
ret.append(ret_req)
except Exception as ex:
self.logger.error(ex)
self.logger.error(traceback.format_exc())
return ret
def finish_new_requests(self):
while not self.new_output_queue.empty():
try:
req = self.new_output_queue.get()
self.logger.info("Main thread finished processing requst: %s" % req)
parameter = {'status': req['status'], 'locking': RequestLocking.Idle}
if 'processing_metadata' not in req or not req['processing_metadata']:
processing_metadata = {}
else:
processing_metadata = req['processing_metadata']
parameter['processing_metadata'] = processing_metadata
if 'errors' in req:
parameter['errors'] = req['errors']
if 'new_workprogresses' in req:
new_workprogresses = req['new_workprogresses']
else:
new_workprogresses = []
core_requests.update_request_with_workprogresses(req['request_id'], parameter, new_workprogresses)
except Exception as ex:
self.logger.error(ex)
self.logger.error(traceback.format_exc())
def get_running_requests(self):
"""
Get running requests
"""
req_status = [RequestStatus.Transforming]
reqs = core_requests.get_requests_by_status_type(status=req_status, time_period=self.poll_time_period,
locking=True, bulk_size=self.retrieve_bulk_size)
self.logger.debug("Main thread get %s Transforming requests to running" % len(reqs))
if reqs:
self.logger.info("Main thread get %s Transforming requests to running" % len(reqs))
return reqs
def process_running_request(self, req):
"""
process running request
"""
wps = core_workprogress.get_workprogresses(request_id=req['request_id'])
wps_status = {}
for wp in wps:
status_name = wp['status'].name
if status_name not in wps_status:
wps_status[status_name] = 1
else:
wps_status[status_name] += 1
processing_metadata = req['processing_metadata']
processing_metadata['workprogresses_status'] = wps_status
wps_status_keys = list(wps_status.keys())
if len(wps_status_keys) == 0:
ret_req = {'request_id': req['request_id'],
'status': RequestStatus.Failed,
'processing_metadata': processing_metadata,
'errors': {'msg': 'No transforms founded(no collections founded)'}
}
elif len(wps_status_keys) == 1:
if wps_status_keys[0] in [WorkprogressStatus.New, WorkprogressStatus.New.name,
WorkprogressStatus.Transforming, WorkprogressStatus.Transforming.name,
WorkprogressStatus.Extend, WorkprogressStatus.Extend.name]:
ret_req = {'request_id': req['request_id'],
'status': RequestStatus.Transforming,
'processing_metadata': processing_metadata
}
else:
ret_req = {'request_id': req['request_id'],
'status': dict(RequestStatus.__members__)[wps_status_keys[0]],
'processing_metadata': processing_metadata
}
else:
ret_req = {'request_id': req['request_id'],
'status': RequestStatus.Transforming,
'processing_metadata': processing_metadata
}
return ret_req
def process_running_requests(self):
"""
Process running request
"""
ret = []
while not self.running_task_queue.empty():
try:
req = self.running_task_queue.get()
if req:
self.logger.info("Main thread processing running requst: %s" % req)
ret_req = self.process_running_request(req)
if ret_req:
ret.append(ret_req)
except Exception as ex:
self.logger.error(ex)
self.logger.error(traceback.format_exc())
return ret
def finish_running_requests(self):
while not self.running_output_queue.empty():
req = self.running_output_queue.get()
self.logger.info("finish_running_requests: req: %s" % req)
parameter = {'locking': RequestLocking.Idle}
for key in ['status', 'errors', 'request_metadata', 'processing_metadata']:
if key in req:
parameter[key] = req[key]
core_requests.update_request(req['request_id'], parameter)
def clean_locks(self):
self.logger.info("clean locking")
core_requests.clean_locking()
def run(self):
"""
Main run function.
"""
try:
self.logger.info("Starting main thread")
self.load_plugins()
task = self.create_task(task_func=self.get_new_requests, task_output_queue=self.new_task_queue, task_args=tuple(), task_kwargs={}, delay_time=1, priority=1)
self.add_task(task)
task = self.create_task(task_func=self.process_new_requests, task_output_queue=self.new_output_queue, task_args=tuple(), task_kwargs={}, delay_time=1, priority=1)
self.add_task(task)
task = self.create_task(task_func=self.finish_new_requests, task_output_queue=None, task_args=tuple(), task_kwargs={}, delay_time=1, priority=1)
self.add_task(task)
task = self.create_task(task_func=self.get_running_requests, task_output_queue=self.running_task_queue, task_args=tuple(), task_kwargs={}, delay_time=1, priority=1)
self.add_task(task)
task = self.create_task(task_func=self.process_running_requests, task_output_queue=self.running_output_queue, task_args=tuple(), task_kwargs={}, delay_time=1, priority=1)
self.add_task(task)
task = self.create_task(task_func=self.finish_running_requests, task_output_queue=None, task_args=tuple(), task_kwargs={}, delay_time=1, priority=1)
self.add_task(task)
task = self.create_task(task_func=self.clean_locks, task_output_queue=None, task_args=tuple(), task_kwargs={}, delay_time=1800, priority=1)
self.add_task(task)
self.execute()
except KeyboardInterrupt:
self.stop()
if __name__ == '__main__':
agent = Clerk()
agent()
|
StarcoderdataPython
|
3251832
|
"""
py_pkg
~~~~~~
The py_pkg package - a Python package template project that is intended
to be used as a cookie-cutter for developing new Python packages.
"""
from .osapi import OsApi
from .mampapi import MampApi
|
StarcoderdataPython
|
3354369
|
from itertools import product
from math import sqrt
import numpy as np
def make_anchors(conv_h, conv_w, scale, input_shape=[550, 550], aspect_ratios=[1, 1 / 2, 2]):
prior_data = []
for j, i in product(range(conv_h), range(conv_w)):
x = (i + 0.5) / conv_w
y = (j + 0.5) / conv_h
for ar in aspect_ratios:
ar = sqrt(ar)
w = scale * ar / input_shape[1]
h = scale / ar / input_shape[0]
prior_data += [x, y, w, h]
return prior_data
#---------------------------------------------------#
# 用于计算共享特征层的大小
#---------------------------------------------------#
def get_img_output_length(height, width):
filter_sizes = [7, 3, 3, 3, 3, 3, 3]
padding = [3, 1, 1, 1, 1, 1, 1]
stride = [2, 2, 2, 2, 2, 2, 2]
feature_heights = []
feature_widths = []
for i in range(len(filter_sizes)):
height = (height + 2*padding[i] - filter_sizes[i]) // stride[i] + 1
width = (width + 2*padding[i] - filter_sizes[i]) // stride[i] + 1
feature_heights.append(height)
feature_widths.append(width)
return np.array(feature_heights)[-5:], np.array(feature_widths)[-5:]
def get_anchors(input_shape = [550, 550], anchors_size = [24, 48, 96, 192, 384]):
feature_heights, feature_widths = get_img_output_length(input_shape[0], input_shape[1])
all_anchors = []
for i in range(len(feature_heights)):
anchors = make_anchors(feature_heights[i], feature_widths[i], anchors_size[i], input_shape)
all_anchors += anchors
all_anchors = np.reshape(all_anchors, [-1, 4])
return all_anchors
if __name__ == "__main__":
import matplotlib.pyplot as plt
def decode_boxes(pred_box, anchors, variances = [0.1, 0.2]):
#---------------------------------------------------------#
# anchors[:, :2] 先验框中心
# anchors[:, 2:] 先验框宽高
# 对先验框的中心和宽高进行调整，获得预测框
#---------------------------------------------------------#
boxes = np.concatenate((anchors[:, :2] + pred_box[:, :2] * variances[0] * anchors[:, 2:],
anchors[:, 2:] * np.exp(pred_box[:, 2:] * variances[1])), 1)
return boxes
input_shape = [550, 550]
anchors = get_anchors(input_shape)
print(anchors)
anchors = anchors * np.array([input_shape[1], input_shape[0], input_shape[1], input_shape[0]])
anchors = anchors[-75:, :]
print(anchors)
fig = plt.figure()
ax = fig.add_subplot(121)
plt.ylim(-350,950)
plt.xlim(-350,950)
plt.scatter(anchors[:, 0], anchors[:, 1])
rect1 = plt.Rectangle([anchors[0, 0] - anchors[0, 2] / 2, anchors[0, 1] - anchors[0, 3] / 2], anchors[0, 2], anchors[0, 3], color="r", fill=False)
rect2 = plt.Rectangle([anchors[1, 0] - anchors[1, 2] / 2, anchors[1, 1] - anchors[1, 3] / 2], anchors[1, 2], anchors[1, 3], color="r", fill=False)
rect3 = plt.Rectangle([anchors[2, 0] - anchors[2, 2] / 2, anchors[2, 1] - anchors[2, 3] / 2], anchors[2, 2], anchors[2, 3], color="r", fill=False)
ax.add_patch(rect1)
ax.add_patch(rect2)
ax.add_patch(rect3)
ax = fig.add_subplot(122)
plt.ylim(-350,950)
plt.xlim(-350,950)
plt.scatter(anchors[:, 0], anchors[:, 1])
decode_box = decode_boxes(np.random.uniform(0, 2, np.shape(anchors)), anchors)
rect1 = plt.Rectangle([decode_box[0, 0] - decode_box[0, 2] / 2, decode_box[0, 1] - decode_box[0, 3] / 2], decode_box[0, 2], decode_box[0, 3], color="r", fill=False)
rect2 = plt.Rectangle([decode_box[1, 0] - decode_box[1, 2] / 2, decode_box[1, 1] - decode_box[1, 3] / 2], decode_box[1, 2], decode_box[1, 3], color="r", fill=False)
rect3 = plt.Rectangle([decode_box[2, 0] - decode_box[2, 2] / 2, decode_box[2, 1] - decode_box[2, 3] / 2], decode_box[2, 2], decode_box[2, 3], color="r", fill=False)
ax.add_patch(rect1)
ax.add_patch(rect2)
ax.add_patch(rect3)
plt.show()
|
StarcoderdataPython
|
1682487
|
# vim: tabstop=4 shiftwidth=4 softtabstop=4
# Copyright 2013 Cisco Systems, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
#
# @author: <NAME>, Cisco Systems Inc.
# @author: <NAME>, Cisco Systems Inc.
from mock import patch
from oslo.config import cfg
from neutron.api import extensions as neutron_extensions
from neutron.api.v2 import attributes
from neutron import context
import neutron.db.api as db
from neutron.extensions import portbindings
from neutron.plugins.cisco.db import n1kv_db_v2
from neutron.plugins.cisco.db import network_db_v2 as cdb
from neutron.plugins.cisco import extensions
from neutron.plugins.cisco.extensions import n1kv
from neutron.plugins.cisco.extensions import network_profile
from neutron.plugins.cisco.n1kv import n1kv_client
from neutron.plugins.cisco.n1kv import n1kv_neutron_plugin
from neutron.tests.unit import _test_extension_portbindings as test_bindings
from neutron.tests.unit import test_api_v2
from neutron.tests.unit import test_db_plugin as test_plugin
class FakeResponse(object):
"""
This object is returned by mocked httplib instead of a normal response.
Initialize it with the status code, content type and buffer contents
you wish to return.
"""
def __init__(self, status, response_text, content_type):
self.buffer = response_text
self.status = status
def __getitem__(cls, val):
return "application/xml"
def read(self, *args, **kwargs):
return self.buffer
def _fake_setup_vsm(self):
"""Fake establish Communication with Cisco Nexus1000V VSM."""
self.agent_vsm = True
self._poll_policies(event_type="port_profile")
class NetworkProfileTestExtensionManager(object):
def get_resources(self):
# Add the resources to the global attribute map
# This is done here as the setup process won't
# initialize the main API router which extends
# the global attribute map
attributes.RESOURCE_ATTRIBUTE_MAP.update(
network_profile.RESOURCE_ATTRIBUTE_MAP)
return network_profile.Network_profile.get_resources()
def get_actions(self):
return []
def get_request_extensions(self):
return []
class N1kvPluginTestCase(test_plugin.NeutronDbPluginV2TestCase):
_plugin_name = ('neutron.plugins.cisco.n1kv.'
'n1kv_neutron_plugin.N1kvNeutronPluginV2')
tenant_id = "some_tenant"
DEFAULT_RESP_BODY = ""
DEFAULT_RESP_CODE = 200
DEFAULT_CONTENT_TYPE = ""
fmt = "json"
def _make_test_policy_profile(self, name='service_profile'):
"""
Create a policy profile record for testing purpose.
:param name: string representing the name of the policy profile to
create. Default argument value chosen to correspond to the
default name specified in config.py file.
"""
uuid = test_api_v2._uuid()
profile = {'id': uuid,
'name': name}
return n1kv_db_v2.create_policy_profile(profile)
def _make_test_profile(self, name='default_network_profile'):
"""
Create a profile record for testing purposes.
:param name: string representing the name of the network profile to
create. Default argument value chosen to correspond to the
default name specified in config.py file.
"""
db_session = db.get_session()
profile = {'name': name,
'segment_type': 'vlan',
'physical_network': 'phsy1',
'segment_range': '3968-4047'}
self.network_vlan_ranges = {profile[
'physical_network']: [(3968, 4047)]}
n1kv_db_v2.sync_vlan_allocations(db_session, self.network_vlan_ranges)
return n1kv_db_v2.create_network_profile(db_session, profile)
def setUp(self):
"""
Setup method for n1kv plugin tests.
First step is to define an acceptable response from the VSM to
our requests. This needs to be done BEFORE the setUp() function
of the super-class is called.
This default here works for many cases. If you need something
extra, please define your own setUp() function in your test class,
and set your DEFAULT_RESPONSE value also BEFORE calling the
setUp() of the super-function (this one here). If you have set
a value already, it will not be overwritten by this code.
"""
if not self.DEFAULT_RESP_BODY:
self.DEFAULT_RESP_BODY = (
"""<?xml version="1.0" encoding="utf-8"?>
<set name="events_set">
<instance name="1" url="/api/hyper-v/events/1">
<properties>
<cmd>configure terminal ; port-profile type vethernet grizzlyPP
(SUCCESS)
</cmd>
<id>42227269-e348-72ed-bdb7-7ce91cd1423c</id>
<time>1369223611</time>
<name>grizzlyPP</name>
</properties>
</instance>
<instance name="2" url="/api/hyper-v/events/2">
<properties>
<cmd>configure terminal ; port-profile type vethernet havanaPP
(SUCCESS)
</cmd>
<id>3fc83608-ae36-70e7-9d22-dec745623d06</id>
<time>1369223661</time>
<name>havanaPP</name>
</properties>
</instance>
</set>
""")
# Creating a mock HTTP connection object for httplib. The N1KV client
# interacts with the VSM via HTTP. Since we don't have a VSM running
# in the unit tests, we need to 'fake' it by patching the HTTP library
# itself. We install a patch for a fake HTTP connection class.
# Using __name__ to avoid having to enter the full module path.
http_patcher = patch(n1kv_client.httplib2.__name__ + ".Http")
FakeHttpConnection = http_patcher.start()
# Now define the return values for a few functions that may be called
# on any instance of the fake HTTP connection class.
instance = FakeHttpConnection.return_value
instance.getresponse.return_value = (FakeResponse(
self.DEFAULT_RESP_CODE,
self.DEFAULT_RESP_BODY,
'application/xml'))
instance.request.return_value = (instance.getresponse.return_value,
self.DEFAULT_RESP_BODY)
# Patch some internal functions in a few other parts of the system.
# These help us move along, without having to mock up even more systems
# in the background.
# Return a dummy VSM IP address
get_vsm_hosts_patcher = patch(n1kv_client.__name__ +
".Client._get_vsm_hosts")
fake_get_vsm_hosts = get_vsm_hosts_patcher.start()
fake_get_vsm_hosts.return_value = ["127.0.0.1"]
# Return dummy user profiles
get_cred_name_patcher = patch(cdb.__name__ + ".get_credential_name")
fake_get_cred_name = get_cred_name_patcher.start()
fake_get_cred_name.return_value = {"user_name": "admin",
"password": "<PASSWORD>"}
n1kv_neutron_plugin.N1kvNeutronPluginV2._setup_vsm = _fake_setup_vsm
neutron_extensions.append_api_extensions_path(extensions.__path__)
self.addCleanup(cfg.CONF.reset)
ext_mgr = NetworkProfileTestExtensionManager()
# Save the original RESOURCE_ATTRIBUTE_MAP
self.saved_attr_map = {}
for resource, attrs in attributes.RESOURCE_ATTRIBUTE_MAP.items():
self.saved_attr_map[resource] = attrs.copy()
# Update the RESOURCE_ATTRIBUTE_MAP with n1kv specific extended attrs.
attributes.RESOURCE_ATTRIBUTE_MAP["networks"].update(
n1kv.EXTENDED_ATTRIBUTES_2_0["networks"])
attributes.RESOURCE_ATTRIBUTE_MAP["ports"].update(
n1kv.EXTENDED_ATTRIBUTES_2_0["ports"])
self.addCleanup(self.restore_resource_attribute_map)
self.addCleanup(db.clear_db)
super(N1kvPluginTestCase, self).setUp(self._plugin_name,
ext_mgr=ext_mgr)
# Create some of the database entries that we require.
self._make_test_profile()
self._make_test_policy_profile()
def restore_resource_attribute_map(self):
# Restore the original RESOURCE_ATTRIBUTE_MAP
attributes.RESOURCE_ATTRIBUTE_MAP = self.saved_attr_map
def test_plugin(self):
self._make_network('json',
'some_net',
True,
tenant_id=self.tenant_id,
set_context=True)
req = self.new_list_request('networks', params="fields=tenant_id")
req.environ['neutron.context'] = context.Context('', self.tenant_id)
res = req.get_response(self.api)
self.assertEqual(res.status_int, 200)
body = self.deserialize('json', res)
self.assertIn('tenant_id', body['networks'][0])
class TestN1kvNetworkProfiles(N1kvPluginTestCase):
def _prepare_net_profile_data(self, segment_type):
netp = {'network_profile': {'name': 'netp1',
'segment_type': segment_type,
'tenant_id': self.tenant_id}}
if segment_type == 'vlan':
netp['network_profile']['segment_range'] = '100-180'
netp['network_profile']['physical_network'] = 'phys1'
elif segment_type == 'overlay':
netp['network_profile']['segment_range'] = '10000-10010'
netp['network_profile']['sub_type'] = 'enhanced'
return netp
def test_create_network_profile_plugin(self):
data = self._prepare_net_profile_data('vlan')
net_p_req = self.new_create_request('network_profiles', data)
res = net_p_req.get_response(self.ext_api)
self.assertEqual(res.status_int, 201)
def test_update_network_profile_physical_network_fail(self):
net_p = self._make_test_profile(name='netp1')
data = {'network_profile': {'physical_network': 'some-phys-net'}}
net_p_req = self.new_update_request('network_profiles',
data,
net_p['id'])
res = net_p_req.get_response(self.ext_api)
self.assertEqual(res.status_int, 400)
def test_update_network_profile_segment_type_fail(self):
net_p = self._make_test_profile(name='netp1')
data = {'network_profile': {'segment_type': 'overlay'}}
net_p_req = self.new_update_request('network_profiles',
data,
net_p['id'])
res = net_p_req.get_response(self.ext_api)
self.assertEqual(res.status_int, 400)
def test_update_network_profile_sub_type_fail(self):
net_p_dict = self._prepare_net_profile_data('overlay')
net_p_req = self.new_create_request('network_profiles', net_p_dict)
net_p = self.deserialize(self.fmt,
net_p_req.get_response(self.ext_api))
data = {'network_profile': {'sub_type': 'vlan'}}
update_req = self.new_update_request('network_profiles',
data,
net_p['network_profile']['id'])
update_res = update_req.get_response(self.ext_api)
self.assertEqual(update_res.status_int, 400)
class TestN1kvBasicGet(test_plugin.TestBasicGet,
N1kvPluginTestCase):
pass
class TestN1kvHTTPResponse(test_plugin.TestV2HTTPResponse,
N1kvPluginTestCase):
pass
class TestN1kvPorts(test_plugin.TestPortsV2,
N1kvPluginTestCase,
test_bindings.PortBindingsTestCase):
VIF_TYPE = portbindings.VIF_TYPE_OVS
HAS_PORT_FILTER = False
def test_create_port_with_default_n1kv_policy_profile_id(self):
"""Test port create without passing policy profile id."""
with self.port() as port:
db_session = db.get_session()
pp = n1kv_db_v2.get_policy_profile(
db_session, port['port'][n1kv.PROFILE_ID])
self.assertEqual(pp['name'], 'service_profile')
def test_create_port_with_n1kv_policy_profile_id(self):
"""Test port create with policy profile id."""
profile_obj = self._make_test_policy_profile(name='test_profile')
with self.network() as network:
data = {'port': {n1kv.PROFILE_ID: profile_obj.id,
'tenant_id': self.tenant_id,
'network_id': network['network']['id']}}
port_req = self.new_create_request('ports', data)
port = self.deserialize(self.fmt,
port_req.get_response(self.api))
self.assertEqual(port['port'][n1kv.PROFILE_ID],
profile_obj.id)
self._delete('ports', port['port']['id'])
def test_update_port_with_n1kv_policy_profile_id(self):
"""Test port update failure while updating policy profile id."""
with self.port() as port:
data = {'port': {n1kv.PROFILE_ID: 'some-profile-uuid'}}
port_req = self.new_update_request('ports',
data,
port['port']['id'])
res = port_req.get_response(self.api)
# Port update should fail to update policy profile id.
self.assertEqual(res.status_int, 400)
class TestN1kvNetworks(test_plugin.TestNetworksV2,
N1kvPluginTestCase):
def _prepare_net_data(self, net_profile_id):
return {'network': {'name': 'net1',
n1kv.PROFILE_ID: net_profile_id,
'tenant_id': self.tenant_id}}
def test_create_network_with_default_n1kv_network_profile_id(self):
"""Test network create without passing network profile id."""
with self.network() as network:
db_session = db.get_session()
np = n1kv_db_v2.get_network_profile(
db_session, network['network'][n1kv.PROFILE_ID])
self.assertEqual(np['name'], 'default_network_profile')
def test_create_network_with_n1kv_network_profile_id(self):
"""Test network create with network profile id."""
profile_obj = self._make_test_profile(name='test_profile')
data = self._prepare_net_data(profile_obj.id)
network_req = self.new_create_request('networks', data)
network = self.deserialize(self.fmt,
network_req.get_response(self.api))
self.assertEqual(network['network'][n1kv.PROFILE_ID],
profile_obj.id)
def test_update_network_with_n1kv_network_profile_id(self):
"""Test network update failure while updating network profile id."""
with self.network() as network:
data = {'network': {n1kv.PROFILE_ID: 'some-profile-uuid'}}
network_req = self.new_update_request('networks',
data,
network['network']['id'])
res = network_req.get_response(self.api)
# Network update should fail to update network profile id.
self.assertEqual(res.status_int, 400)
class TestN1kvSubnets(test_plugin.TestSubnetsV2,
N1kvPluginTestCase):
pass
|
StarcoderdataPython
|
1668864
|
<filename>GIMMECore/PlayerStructs.py
import math
import time
import copy
import json
from .InteractionsProfile import InteractionsProfile
class PlayerCharacteristics(object):
def __init__(self, ability = None, engagement = None):
self.ability = 0 if ability==None else ability
self.engagement = 0 if engagement==None else engagement
# self._ability = 0 if ability==None else min(ability, 20.0)
# self._engagement = 0 if engagement==None else min(engagement, 1.0)
def reset(self):
self.ability = 0
self.engagement = 0
return self
# #constraints enforced via properties
# @property
# def ability(self):
# return self._ability
# @property
# def engagement(self):
# return self._engagement
# @ability.setter
# def ability(self, newValue):
# # print(newValue)
# self._ability = min(newValue, 20.0)
# # self._ability = newValue
# return self._ability
# @engagement.setter
# def engagement(self, newValue):
# self._engagement = min(newValue, 1.0)
# # self._engagement = newValue
# return self._engagement
class PlayerState(object):
def __init__(self, stateType = None, profile = None, characteristics = None, dist = None, quality = None, group = None, tasks = None):
self.creationTime = time.time()
self.stateType = 1 if stateType == None else stateType
self.profile = InteractionsProfile() if profile == None else profile
self.characteristics = PlayerCharacteristics() if characteristics == None else characteristics
self.dist = -1 if dist == None else dist
self.quality = -1 if quality == None else quality
self.group = [] if group == None else group
self.tasks = [] if tasks == None else tasks
def reset(self):
self.characteristics.reset()
self.profile.reset()
self.creationTime = time.time()
self.stateType = 1
self.quality = -1
self.dist = -1
self.group = []
self.tasks = []
return self
class PlayerStatesDataFrame(object):
def __init__(self, interactionsProfileTemplate, trimAlg, states = None):
self.interactionsProfileTemplate = interactionsProfileTemplate
self.trimAlg = trimAlg
self.states = [] if states == None else states
#auxiliary stuff
self.flatProfiles = []
self.flatAbilities = []
self.flatEngagements = []
def reset(self):
self.states = []
#auxiliary stuff
self.flatProfiles = []
self.flatAbilities = []
self.flatEngagements = []
return self
def pushToDataFrame(self, playerState):
self.states.append(playerState)
#update tuple representation
self.flatProfiles.append(playerState.profile.flattened())
self.flatAbilities.append(playerState.characteristics.ability)
self.flatEngagements.append(playerState.characteristics.engagement)
# print(json.dumps(self.states, default=lambda o: o.__dict__, sort_keys=True, indent=2))
# print("---------")
# print(self.flatProfiles)
# print(self.flatAbilities)
# print(self.flatEngagements)
trimmedListAndRemainder = self.trimAlg.trimmedList(self.states)
trimmedList = trimmedListAndRemainder[0]
remainderIndexes = trimmedListAndRemainder[1]
# print(remainderIndexes)
self.states = trimmedList
#update tuple representation
for i in remainderIndexes:
self.flatProfiles.pop(i)
self.flatAbilities.pop(i)
self.flatEngagements.pop(i)
def getAllStates(self):
return self.states
def getAllStatesFlatten(self):
return {'profiles': self.flatProfiles, 'abilities': self.flatAbilities, 'engagements': self.flatEngagements}
def getNumStates(self):
return len(self.states)
|
StarcoderdataPython
|
1644402
|
from pyHalo.preset_models import WDMLovell2020, CDM, WDMGeneral, SIDM, ULDM
import numpy.testing as npt
import pytest
class TestPresetModels(object):
def test_CDM(self):
realization_cdm = CDM(0.5, 1.5)
npt.assert_equal(len(realization_cdm.rendering_classes), 3)
def test_WDMLovell20(self):
realization_wdm = WDMLovell2020(0.5, 1.5, 8.)
npt.assert_equal(len(realization_wdm.rendering_classes), 3)
def test_WDMGeneral(self):
realization_wdm = WDMGeneral(0.5, 1.5, 8.)
npt.assert_equal(len(realization_wdm.rendering_classes), 3)
def test_SIDM(self):
realization_SIDM = SIDM(0.5, 1.5, None, None, {}, None, None, None,
None, None, None, sigma_sub=0., LOS_normalization=0.)
npt.assert_equal(len(realization_SIDM.rendering_classes), 3)
def test_ULDM(self):
realization_ULDM = ULDM(0.5,1.5)
npt.assert_equal(len(realization_ULDM.rendering_classes), 3)
if __name__ == '__main__':
pytest.main()
|
StarcoderdataPython
|
40585
|
from django.core.management.base import BaseCommand
import numpy as np
import pandas as pd
from django.conf import settings
from baseball.models import Player, PlayerStats
import sys
import requests
import datetime
HITTING_BASE_URL = 'http://lookup-service-prod.mlb.com/json/named.sport_hitting_tm.bam'
PITCHING_BASE_URL = 'http://lookup-service-prod.mlb.com/json/named.sport_pitching_tm.bam'
class Command(BaseCommand):
def handle(self, *args, **options):
year = datetime.datetime.now().year
players = Player.objects.all()
for player in players:
if player.pro_debut_date:
start_year = player.pro_debut_date.year
for search_year in range(start_year, year):
try:
year_stats = PlayerStats.objects.get(player=player, year=search_year)
except PlayerStats.DoesNotExist:
payload = {
'league_list_id': '\'mlb\'',
'player_id': '\'%s\'' % player.player_id,
'season': '\'%s\'' % search_year,
'game_type': '\'R\''
}
hitting_response = requests.get(HITTING_BASE_URL,
params=payload)
pitching_response = requests.get(PITCHING_BASE_URL,
params=payload)
hitting_data = hitting_response.json().get('sport_hitting_tm').get('queryResults').get('row')
pitching_data = pitching_response.json().get('sport_pitching_tm').get('queryResults').get('row')
if hitting_data or pitching_data:
year_stats = PlayerStats.objects.create(player=player,
year=search_year)
year_stats.hitting_stats = hitting_data
year_stats.pitching_stats = pitching_data
year_stats.save()
print(year_stats)
|
StarcoderdataPython
|
3249342
|
import cv2 as cv
import mediapipe as mp
import numpy as np
import time
import matplotlib.pyplot as plt
import seaborn as sns
import mapping
import csv
import imageio
class poseDetector():
# def __init__(self, mode=False, upBody = False, smooth = True, detectionCon = 0.5, trackCon = 0.5):
def __init__(self,
mode=False,
model_complexity=1,
smooth=True,
enable_segmentation=False,
smooth_segmentation=True,
detectionCon=0.5,
trackCon=0.5):
'''
Initialize the poseDetector
'''
self.mode = mode
self.model_complexity = model_complexity
# self.upBody = upBody
self.smooth = smooth
self.enable_segmentation = enable_segmentation
self.smooth_segmentation = smooth_segmentation
self.detectionCon = detectionCon
self.trackCon = trackCon
self.mpDraw = mp.solutions.drawing_utils
self.mpPose = mp.solutions.pose
# self.pose = self.mpPose.Pose(self.mode, self.upBody, self.smooth, self.detectionCon, self.trackCon)
self.pose = self.mpPose.Pose(self.mode, self.model_complexity, self.smooth, self.enable_segmentation, self.smooth_segmentation, self.detectionCon, self.trackCon)
def findPose(self, img, draw = True):
'''
findPose takes in the img you want to find the pose in, and whether or not you
want to draw the pose (True by default).
'''
imgRGB = cv.cvtColor(img, cv.COLOR_BGR2RGB) #convert BGR --> RGB as openCV uses BGR but mediapipe uses RGB
imgRGB.flags.writeable = False
self.results = self.pose.process(imgRGB) # store our results to the results object
if self.results.pose_landmarks and draw: # if there are pose landmarks in our results object and draw was set to True
self.mpDraw.draw_landmarks(img, self.results.pose_landmarks, self.mpPose.POSE_CONNECTIONS, self.mpDraw.DrawingSpec(color = (255, 255, 255), thickness = 2, circle_radius = 2), self.mpDraw.DrawingSpec(color = (35, 176, 247), thickness = 2, circle_radius = 2)) #draw them
return img #returns the image
def findPosition(self, img, draw=True):
'''
Takes in the image and returns a list of the landmarks
'''
lmList = []
if self.results.pose_landmarks:
for id, lm in enumerate(self.results.pose_landmarks.landmark): #for each landmark
h, w, c = img.shape #grab the image shape
cx, cy = int(lm.x * w), int(lm.y * h) # set cx and cy to the landmark coordinates
# lmList.append([id, cx, cy]) #append the landmark id, the x coord and the y coord
lmList.append(cx) # just looking for x coordinate
if draw:
cv.circle(img, (cx,cy), 5, (0, 0, 255), cv.FILLED) #if we want to draw, then draw
return lmList #returns the list of landmarks
def findAngle(self, p1, p2, p3):
'''
takes in three points and returns the angle between them
'''
self.p1 = np.array(p1) # start point
self.p2 = np.array(p2) # mid point
self.p3 = np.array(p3) # end point
radians = np.arctan2(self.p3[2]-self.p2[2], self.p3[1]-self.p2[1]) - np.arctan2(self.p1[2]-self.p2[2], self.p1[1]-self.p2[1]) #trig
angle = np.abs(radians*180.0/np.pi)
if angle >180.0:
angle = 360-angle
return angle
def main():
saveCSV = False
vid = cv.VideoCapture('videos/small_run.MOV') #open up the video
detector = poseDetector() #create new detector object
pTime = 0 #set our start time (this is for the fps counter)
timeSeries = []
# angleSeries = []
leftAnkle = []
rightAnkle = []
image_lst = []
frame = 0
while True: #infinite loop
frame += 1
success, img = vid.read() #read the image
try:
img = detector.findPose(img) #update image with findPose
except:
break
lmList = detector.findPosition(img, True) #get the landmarks list
if lmList:
leftAnkle.append(lmList[mapping.landmarks["left_ankle"]])
rightAnkle.append(lmList[mapping.landmarks["right_ankle"]])
else:
leftAnkle.append(-1)
rightAnkle.append(-1)
# angle = detector.findAngle(
# lmList[mapping.landmarks["right_hip"]],
# lmList[mapping.landmarks["right_knee"]],
# lmList[mapping.landmarks["right_ankle"]]
# ) #calculate the angle between three points
#not the best way to call the landmarks, but not the highest priority to deal with rn
timeSeries.append(frame * (1/ 30))
# angleSeries.append(angle)
cTime = time.time() # update 2nd time
fps = 1 / (cTime - pTime) #calculate the fps
pTime = cTime #update the first time
# if angle > 90: #this just writes the knee angle to the screen
# cv.putText(img, "Left Elbow Angle:", (10, 100), cv.FONT_HERSHEY_PLAIN, 2, (255,255,255), 2)
# cv.putText(img, str(np.round(angle)), (10, 150), cv.FONT_HERSHEY_PLAIN, 2, (255,255,255), 2)
# else:
# cv.putText(img, "Left Elbow Angle:", (10, 100), cv.FONT_HERSHEY_PLAIN, 2, (21, 26, 171), 2)
# cv.putText(img, str(np.round(angle)), (10, 150), cv.FONT_HERSHEY_PLAIN, 2, (21, 26, 171), 2)
cv.putText(img, "Time: ", (10, 50), cv.FONT_HERSHEY_PLAIN, 2, (0, 0, 255), 2)
cv.putText(img, str(np.round(frame * (1/30), 2)), (100, 50), cv.FONT_HERSHEY_PLAIN, 2, (0, 0, 255), 2)
cv.putText(img, "Frame: ", (10, 100), cv.FONT_HERSHEY_PLAIN, 2, (0, 0, 255), 2)
cv.putText(img, str(int(frame)), (120, 100), cv.FONT_HERSHEY_PLAIN, 2, (0, 0, 255), 2)
cv.imshow("Skating", img) #display our image
image_lst.append(img)
key = cv.waitKey(1)
if key == ord('q') or key == ord(' '):
break
if key == ord('p'):
cv.waitKey(-1) #wait until any key is pressed
cv.destroyAllWindows()
with imageio.get_writer("skate.gif", mode="I") as writer:
for idx, frame in enumerate(image_lst):
print("Adding frame to GIF file: ", idx + 1)
writer.append_data(frame)
if saveCSV:
with open('smallRun.csv', 'w', newline='') as myfile:
wr = csv.writer(myfile, quoting=csv.QUOTE_ALL)
wr.writerow(leftAnkle)
wr.writerow(rightAnkle)
wr.writerow(timeSeries)
# sns.lineplot(timeSeries, leftAnkle)
# plt.show()
# print(lmList.NOSE)
if __name__ == "__main__":
main()
|
StarcoderdataPython
|
1643288
|
<reponame>mserrano07/django-gdpr-assist
# -*- coding: utf-8 -*-
from django.db import migrations
from gdpr_assist.upgrading import MigrateGdprAnonymised
class Migration(migrations.Migration):
dependencies = [
("example", "0001_initial"),
("gdpr_assist", "0002_privacyanonymised"),
]
operations = [
MigrateGdprAnonymised("HealthRecord"),
MigrateGdprAnonymised("MailingListLog"),
MigrateGdprAnonymised("Person"),
MigrateGdprAnonymised("PersonProfile"),
]
|
StarcoderdataPython
|
140201
|
<gh_stars>0
import pdb
import numpy as np
import time
genres = ['Western', 'Comedy', 'Children', 'Crime', 'Musical', 'Adventure', 'Drama', 'Horror', 'War', 'Documentary', 'Romance', 'Animation', 'Film-Noir', 'Sci-Fi', 'Mystery', 'Fantasy', 'IMAX', 'Action', 'Thriller']
# Data is a list of (i, j, r) triples
ratings_small = \
[(0, 0, 5), (0, 1, 3), (0, 3, 1),
(1, 0, 4), (1, 3, 1),
(2, 0, 1), (2, 1, 1), (2, 3, 5),
(3, 0, 1), (3, 3, 4),
(4, 1, 1), (4, 2, 5), (4, 3, 4)]
def pred(data, x):
(a, i, r) = data
(u, b_u, v, b_v) = x
return np.dot(u[a].T,v[i]) + b_u[a] + b_v[i]
# Utilities
import pickle
# After retrieving the output x from mf_als, you can use this function to save the output so
# you don't have to re-train your model
def save_model(x):
pickle.dump(x, open("ALSmodel", "wb"))
# After training and saving your model once, you can use this function to retrieve the previous model
def load_model():
x = pickle.load(open("ALSmodel", "rb"))
return x
# Compute the root mean square error
def rmse(data, x):
error = 0.
for datum in data:
error += (datum[-1] - pred(datum, x))**2
return np.sqrt(error/len(data))
# Counts of users and movies, used to calibrate lambda
def counts(data, index):
item_count = {}
for datum in data:
j = datum[index]
if j in item_count:
item_count[j] += 1
else:
item_count[j] = 1
c = np.ones(max(item_count.keys())+1)
for i,v in item_count.items(): c[i]=v
return c
# The ALS outer loop
def mf_als(data_train, data_validate, k=2, lam=0.02, max_iter=100, verbose=False):
# size of the problem
n = max(d[0] for d in data_train)+1 # users
m = max(d[1] for d in data_train)+1 # items
# which entries are set in each row and column
us_from_v = [[] for i in range(m)] # II (i-index-set)
vs_from_u = [[] for a in range(n)] # AI (a-index set)
for (a, i, r) in data_train:
us_from_v[i].append((a, r))
vs_from_u[a].append((i, r))
# Initial guess at u, b_u, v, b_v
# Note that u and v are lists of column vectors (columns of U, V).
x = ([np.random.normal(1/k, size=(k,1)) for a in range(n)],
np.zeros(n),
[np.random.normal(1/k, size=(k,1)) for i in range(m)],
np.zeros(m))
# Alternation, modifies the contents of x
start_time = time.time()
for i in range(max_iter):
update_U(data_train, vs_from_u, x, k, lam)
update_V(data_train, us_from_v, x, k, lam)
if verbose:
print('train rmse', rmse(data_train, x), 'validate rmse', data_validate and rmse(data_validate, x))
if data_validate == None: # code is slower, print out progress
print("Iteration {} finished. Total Elapsed Time: {:.2f}".format(i + 1, time.time() - start_time))
# The root mean square errors measured on validate set
if data_validate != None:
print('validate rmse=', rmse(data_validate, x))
return x
# X : n x k
# Y : n
def ridge_analytic(X, Y, lam):
(n, k) = X.shape
xm = np.mean(X, axis = 0, keepdims = True) # 1 x n
ym = np.mean(Y) # 1 x 1
Z = X - xm # d x n
T = Y - ym # 1 x n
th = np.linalg.solve(np.dot(Z.T, Z) + lam * np.identity(k), np.dot(Z.T, T))
# th_0 account for the centering
th_0 = (ym - np.dot(xm, th)) # 1 x 1
return th.reshape((k,1)), float(th_0)
# Example from lab handout
Z = np.array([[1], [1], [5], [1], [5], [5], [1]])
b_v = np.array([[3], [3], [3], [3], [3], [5], [1]])
B = np.array([[1, 10], [1, 10], [10, 1], [1, 10], [10, 1], [5, 5], [5, 5]])
# Solution with offsets, using ridge_analytic provided in code file
u_a, b_u_a = ridge_analytic(B, (Z - b_v), 1)
print('With offsets', u_a, b_u_a)
# Solution using previous model, with no offsets
u_a_no_b = np.dot(np.linalg.inv(np.dot(B.T, B) + 1 * np.identity(2)), np.dot(B.T, Z))
print('With no offsets', u_a_no_b)
def update_U(data, vs_from_u, x, k, lam):
(u, b_u, v, b_v) = x
for a in range(len(u)):
if not vs_from_u[a]: continue
V = np.hstack([v[i] for (i, _) in vs_from_u[a]]).T
y = np.array([r-b_v[i] for (i, r) in vs_from_u[a]])
u[a], b_u[a] = ridge_analytic(V, y, lam)
return x
def update_V(data, us_from_v, x, k, lam):
(u, b_u, v, b_v) = x
for a in range(len(v)):
if not us_from_v[a]: continue
V = np.hstack([u[i] for (i, _) in us_from_v[a]]).T
y = np.array([r-b_u[i] for (i, r) in us_from_v[a]])
v[a], b_v[a] = ridge_analytic(V, y, lam)
return x
# Simple test case
# mf_als(ratings_small, ratings_small,lam=0.01, max_iter=10, k=2)
# The SGD outer loop
def mf_sgd(data_train, data_validate, step_size_fn, k=2, lam=0.02, max_iter=100, verbose=False):
# size of the problem
ndata = len(data_train)
n = max(d[0] for d in data_train)+1
m = max(d[1] for d in data_train)+1
# Distribute the lambda among the users and items
lam_uv = lam/counts(data_train,0), lam/counts(data_train,1)
# Initial guess at u, b_u, v, b_v (also b)
x = ([np.random.normal(1/k, size=(k,1)) for j in range(n)],
np.zeros(n),
[np.random.normal(1/k, size=(k,1)) for j in range(m)],
np.zeros(m))
di = int(max_iter/10.)
for i in range(max_iter):
if i%di == 0 and verbose:
print('i=', i, 'train rmse=', rmse(data_train, x),
'validate rmse', data_validate and rmse(data_validate, x))
step = step_size_fn(i)
j = np.random.randint(ndata) # pick data item
sgd_step(data_train[j], x, lam_uv, step) # modify x
print('k=', k, 'rmse', rmse(data_validate, x))
return x
def sgd_step(data, x, lam, step):
(a, i, r) = data
(u, b_u, v, b_v) = x
(lam_u, lam_v) = lam
# predicted rating
pred = np.dot(u[a].T,v[i]) + b_u[a] + b_v[i]
# prediction error
e = r - pred
temp_u = u[a] # so we don't update v with updated u
u[a] = u[a] - step*(-e*v[i] + lam_u[a]*u[a])
b_u[a] = b_u[a] - step*(-e)
v[i] = v[i] - step*(-e*temp_u + lam_v[i]*v[i])
b_v[i] = b_v[i] - step*(-e)
return x
# Simple validate case
print("SGD")
mf_sgd(ratings_small, ratings_small, step_size_fn=lambda i: 0.1,
lam=0.01, max_iter=1000, k=2)
def load_ratings_data_small(path_data='ratings.csv'):
"""
Returns two lists of triples (i, j, r) (training, validate)
"""
# we want to "randomly" sample but make it deterministic
def user_hash(uid):
return 71 * uid % 401
def user_movie_hash(uid, iid):
return (17 * uid + 43 * iid) % 61
data_train = []
data_validate = []
with open(path_data) as f_data:
for line in f_data:
(uid, iid, rating, timestamp) = line.strip().split(",")
h1 = user_hash(int(uid))
if h1 <= 40:
h2 = user_movie_hash(int(uid), int(iid))
if h2 <= 12:
data_validate.append([int(uid), int(iid), float(rating)])
else:
data_train.append([int(uid), int(iid), float(rating)])
print('Loading from', path_data,
'users_train', len(set(x[0] for x in data_train)),
'items_train', len(set(x[1] for x in data_train)),
'users_validate', len(set(x[0] for x in data_validate)),
'items_validate', len(set(x[1] for x in data_validate)))
return data_train, data_validate
def load_ratings_data(path_data='ratings.csv'):
"""
Returns a list of triples (i, j, r)
"""
data = []
with open(path_data) as f_data:
for line in f_data:
(uid, iid, rating, timestamp) = line.strip().split(",")
data.append([int(uid), int(iid), float(rating)])
print('Loading from', path_data,
'users', len(set(x[0] for x in data)),
'items', len(set(x[1] for x in data)))
return data
def load_movies(path_movies='movies.csv'):
"""
Returns a dictionary mapping item_id to item_name and another dictionary
mapping item_id to a list of genres
"""
data = {}
genreMap = {}
with open(path_movies, encoding = "utf8") as f_data:
for line in f_data:
parts = line.strip().split(",")
item_id = int(parts[0])
item_name = ",".join(parts[1:-1]) # file is poorly formatted
item_genres = parts[-1].split("|")
data[item_id] = item_name
genreMap[item_id] = item_genres
return data, genreMap
def baseline(train, validate):
item_sum = {}
item_count = {}
total = 0
for (i, j, r) in train:
total += r
if j in item_sum:
item_sum[j] += 3
item_count[j] += 1
else:
item_sum[j] = r
item_count[j] = 1
error = 0
avg = total/len(train)
for (i, j, r) in validate:
pred = item_sum[j]/item_count[j] if j in item_count else avg
error += (r - pred)**2
return np.sqrt(error/len(validate))
# Load the movie data
# Below is code for the smaller dataset, used in section 3 of the HW
def tuning_als(max_iter_als=20, verbose=True):
b1, v1 = load_ratings_data_small()
print('Baseline rmse (predict item average)', baseline(b1, v1))
print('Running on the MovieLens data')
lams = [0.01, 0.1,1,10,100]
ks = [1,2,3]
for k in ks:
for lam in lams:
print('ALS, k=', k, 'lam', lam)
mf_als(b1, v1, lam = lam, max_iter=max_iter_als, k=k, verbose=verbose)
def compute_and_save_large_model():
data = load_ratings_data()
print('Running ALS on the MovieLens data for 20 iterations.')
x = mf_als(data, None, lam = 1.0, max_iter = 20, k = 10)
print('Saving the model')
save_model(x)
#data = load_ratings_data()
#movies, genres = load_movies()
#model = mf_als(data, None, k = 10, lam=1, max_iter=20)
#save_model(model)
model = load_model()
triple=load_ratings_data(path_data='ratings.csv')
titledict,genredict=load_movies(path_movies='movies.csv')
(u, b_u, v, b_v) = model
print(np.shape(b_v))
#code for computing best genre
#indici={}
#for t in triple:
# if t[0]==270894:
# if t[1] not in indici.keys():
# indici[t[1]]=t[2]
#g_points={}
#for i in indici.keys():
# for x in genredict[i]:
# if x not in g_points.keys():
# g_points[x]=indici[i]
# else:
# g_points[x] += indici[i]
#print(g_points)
#score={}
#for t in triple:
# i=t[1]
# score[i]=np.dot(u[270894],v[i].T)+b_u[270894]+b_v[i]
# print(np.shape(score[i]))
#print(sorted(score, key=score.get, reverse=True)[:5])
#id=2628
#similarities={}
#for i in range(np.shape(b_v)[0]):
# if i==id:
# continue
# similarities[i]=np.dot(v[id].T,v[i])/(np.sqrt(np.dot(v[id].T,v[id])*np.dot(v[i].T,v[i])))
#d=similarities.copy()
#for i in similarities.keys():
# if similarities[i]<0:
# del d[i]
#most_similar=sorted(d, key=d.get, reverse=True)[:np.shape(b_v)[0]]
#final=[]
#print(most_similar[:10])
#k=0
#for i in most_similar:
# if i in genredict.keys():
# final.append(i)
# ok+=1
# if ok==10:
# break
#print(final)
similarities={}
print(genres)
for gen in genres:
suma=0;n=0;
for j in range(np.shape(b_v)[0]):
if j in genredict.keys() and gen in genredict[j] and gen!='Comedy':
for i in range(np.shape(b_v)[0]): # i must be comedy
if i==j or i not in genredict.keys() or 'Comedy' not in genredict[i]: # i don't count the similarity with oneself
continue #don't care about similarity in the same genre
suma+=np.dot(v[j].T,v[i])/(np.sqrt(np.dot(v[j].T,v[j])*np.dot(v[i].T,v[i])))
n+=1
if gen!='Comedy':
similarities[gen]=suma/n
print(sorted(similarities, key=similarities.get, reverse=True))
print(similarities)
#for i in range(np.shape(film_scores+1)[0]):
# scores[i]=film_scores[i]
#best50=sorted(scores, key=scores.get, reverse=True)[:1000]
#print(best50)
#a=0
#ok=0
#for film in best50:
#if ok==50:
#break
#if film in genredict.keys():
#ok+=1
#if 'Animation' in genredict[film]:
#a+=1
#print(a)
|
StarcoderdataPython
|
3399362
|
from scaner.utils import add_metadata
import json
from flask import current_app
@add_metadata('tasks')
def search(*args, **kwargs):
return {'tasks': current_app.tasks.get_task_list()}, 200
@add_metadata('status')
def get(taskId, *args, **kwargs):
return {'status': current_app.tasks.get_task_status(taskId)}, 200
@add_metadata()
def get_emotions_from_twitter(*args, **kwargs):
emotiontask = current_app.tasks.get_emotions_from_tweets.delay()
return {'status': 'Task running in background'}, 200
@add_metadata()
def get_sentiments_from_twitter(*args, **kwargs):
sentiment_task = current_app.tasks.get_sentiments_from_tweets.delay()
return {'status': 'Task running in background'}, 200
@add_metadata()
def get_user_sentiment(*args, **kwargs):
sentiment_task = current_app.tasks.calculate_user_sentiment.delay()
return {'status': 'Task running in background' }, 200
@add_metadata()
def get_user_emotion(*args, **kwargs):
emotion_task = current_app.tasks.calculate_user_emotion.delay()
return {'status': 'Task running in background' }, 200
@add_metadata()
def get_community_emotion(*args, **kwargs):
sentiment_task = current_app.tasks.calculate_community_emotion.delay()
return {'status': 'Task running in background' }, 200
@add_metadata()
def get_community_sentiment(*args, **kwargs):
sentiment_task = current_app.tasks.calculate_community_sentiment.delay()
return {'status': 'Task running in background' }, 200
@add_metadata()
def run_metrics(*args, **kwargs):
metrics_task = current_app.tasks.execute_metrics.delay()
return {'status': 'Task running in background'}, 200
@add_metadata()
def update_users(*args, **kwargs):
update_users_task = current_app.tasks.get_users_from_twitter.delay()
return {'status': 'Task running in background'}, 200
@add_metadata()
def get_tweets_from_twitter(*args, **kwargs):
return {'status': current_app.tasks.get_tweets_by_id.delay()}, 200
@add_metadata()
def compute_communities(*args, **kwargs):
compute_communities_task = current_app.tasks.execute_communities.delay()
return {'status': 'Task running in background'}, 200
|
StarcoderdataPython
|
4809948
|
from PIL import Image, ImageDraw, ImageFont
from alive_progress import alive_bar
def initImg(width, height, bg, font='fonts/FatBoyVeryRoundItalic.ttf', size = 41, verbose=False):
#creating B/W image
img = Image.new('L', (width, height), color=bg)
fnt = ImageFont.truetype('fonts/FatBoyVeryRoundItalic.ttf', 41)
d = ImageDraw.Draw(img)
if verbose:
print("Created image")
return img, fnt, d
def lastLine(string):
i = string.rfind("\n") + 1
return string[i:]
def textWidth(string, cacheTable):
output = 0
for char in string:
output += cacheTable[char]
return output
def wrap(width, maxLines, cacheTable, drawer, font, count, verbose=False):
def logic(bar, count, maxLines):
string = ""
newNum = ""
lines = 0
finished = False
while not finished:
innerFinished = False
while not innerFinished:
if len(newNum)>0:
if textWidth(lastLine(string)+newNum[:2], cacheTable)<=(width+30):
string+=newNum[:1]
newNum = newNum[1:]
bar(text = "dict", incr=1)
else:
string += "\n"
lines += 1
innerFinished = True
else:
newNum += str(count) + " "
count += 1
if lines >= maxLines:
finished = True
return string, count-1
if verbose:
print("Creating text...")
with alive_bar() as bar:
return logic(bar, count, maxLines)
else:
def bar(**kwargs):
pass
return logic(bar, count, maxLines)
def cacheTable(drawer, font, charsToCache, verbose=False):
cacheTable = dict()
for char in charsToCache:
cacheTable[char]=drawer.textsize(char, font)[0]
if verbose:
print("Created cache table")
return cacheTable
def getMaxLines(drawer, font, height, verbose=False):
def logic(bar):
i = 0
pxs = 0
while True:
my_height = drawer.textsize("0\n"*i, font)[1]
if my_height<=height:
i += 1
bar(incr=my_height-pxs)
pxs = my_height
else:
bar(incr=height-pxs)
break
return i
if verbose:
print("Calculating lines quantity...")
with alive_bar(height) as bar:
i = logic(bar)
print("Calculated max number of lines. Its", i, "lines.")
else:
def bar(**kwargs):
pass
i = logic(bar)
return i
def printText(string, drawer, font, colors, cacheTable, verbose = False):
def logic(bar):
lines = string.split("\n")
index = 0
indexinl = 0
for l, line in enumerate(lines):
if l == 1:
h = drawer.textsize("0000"*(l), font)[1]
else:
h = drawer.textsize("0000000\n00000000"*(l-1), font)[1]
indexinl = 0
for char in line:
w = textWidth(line[:indexinl], cacheTable)
drawer.text((w, h), char, font=font, fill=colors[index])
index += 1
indexinl += 1
bar()
if verbose:
print("Printing text on image...")
with alive_bar(len(string.replace("\n", ""))) as bar:
logic(bar)
else:
def bar(**kwargs):
pass
logic(bar)
def save(img, filename, verbose = False):
if verbose:
print("Saving...")
img.save(filename)
if verbose:
print("Saved as", filename)
|
StarcoderdataPython
|
3352464
|
<gh_stars>0
import sqlite3
DB_NAME = 'database.db'
conn = sqlite3.connect(DB_NAME)
conn.cursor().execute('''
CREATE TABLE IF NOT EXISTS users
(
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT,
email TEXT,
password TEXT
)
''')
conn.cursor().execute('''
CREATE TABLE IF NOT EXISTS tasks
(
id INTEGER PRIMARY KEY AUTOINCREMENT,
title TEXT,
description TEXT,
deadline TEXT,
state TEXT,
user_id INTEGER,
FOREIGN KEY(user_id) REFERENCES users(id)
)
''')
conn.commit()
class DB:
def __enter__(self):
self.conn = sqlite3.connect(DB_NAME)
return self.conn.cursor()
def __exit__(self, type, value, traceback):
self.conn.commit()
|
StarcoderdataPython
|
4813665
|
from flask import Flask, render_template, request, redirect, url_for, flash, abort, session, jsonify
import json
import os.path
from werkzeug.utils import secure_filename # to check if the file uploaded is safe or nor
app = Flask(__name__) # name of module that is running flask
app.secret_key = '<KEY>'
@app.route("/")
def home():
return render_template("home.html", codes=session.keys()) # passing cookies for displaying
@app.route("/your-url", methods=["GET", "POST"])
def your_url():
if request.method == 'POST':
urls = {}
file_save_path = "./static/user_files/"
file_path = "./static/user_files/urls.json"
if os.path.exists(file_path):
with open(file_path) as url_file:
urls = json.load(url_file)
if request.form['code'] in urls.keys():
flash('That shortname has already been taken.')
return redirect(url_for("home"))
if 'url' in request.form.keys():
urls[request.form['code']] = {'url': request.form['url']}
else:
f = request.files['file']
full_name = request.form['code'] + secure_filename(f.filename)
f.save(file_save_path + full_name)
urls[request.form['code']] = {'file': full_name}
with open(file_path, 'w') as url_file:
json.dump(urls, url_file)
session[request.form['code']] = True # save the created url in a cookie
return render_template("your_url.html", code=request.form['code'])
#return redirect("/") # changes the url
return redirect(url_for("home")) # calling the function is recommended
# variable route
@app.route('/<string:code>')
def redirect_to_url(code):
file_path = "./static/user_files/urls.json"
if os.path.exists(file_path):
with open(file_path) as urls_file:
urls = json.load(urls_file)
if code in urls.keys():
if 'url' in urls[code].keys():
return redirect(urls[code]['url'])
else:
return redirect(url_for('static', filename='user_files/' + urls[code]['file']))
return abort(404) # return a error page
#return redirect(url_for("home"))
# custom error page
@app.errorhandler(404)
def page_not_found(error):
return render_template("page-not-found.html"), 404
# to generate api
@app.route('/api')
def session_api():
return jsonify(list(session.keys()))
app.run(debug=True)
|
StarcoderdataPython
|
1735790
|
# -*- coding: utf-8 -*-
# Copyright (C) 2020 <NAME> <<EMAIL>>
# Copyright (c) 2020 Ansible Project
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type
DOCUMENTATION = '''
author: <NAME> (@opoplawski)
name: cobbler
short_description: Cobbler inventory source
version_added: 1.0.0
description:
- Get inventory hosts from the cobbler service.
- "Uses a configuration file as an inventory source, it must end in C(.cobbler.yml) or C(.cobbler.yaml) and has a C(plugin: cobbler) entry."
extends_documentation_fragment:
- inventory_cache
options:
plugin:
description: The name of this plugin, it should always be set to C(community.general.cobbler) for this plugin to recognize it as it's own.
required: yes
choices: [ 'cobbler', 'community.general.cobbler' ]
url:
description: URL to cobbler.
default: 'http://cobbler/cobbler_api'
env:
- name: COBBLER_SERVER
user:
description: Cobbler authentication user.
required: no
env:
- name: COBBLER_USER
password:
description: C<PASSWORD> authentication password
required: no
env:
- name: COBBLER_PASSWORD
cache_fallback:
description: Fallback to cached results if connection to cobbler fails
type: boolean
default: no
exclude_profiles:
description: Profiles to exclude from inventory
type: list
default: []
elements: str
group_by:
description: Keys to group hosts by
type: list
default: [ 'mgmt_classes', 'owners', 'status' ]
group:
description: Group to place all hosts into
default: cobbler
group_prefix:
description: Prefix to apply to cobbler groups
default: cobbler_
want_facts:
description: Toggle, if C(true) the plugin will retrieve host facts from the server
type: boolean
default: yes
'''
EXAMPLES = '''
# my.cobbler.yml
plugin: community.general.cobbler
url: http://cobbler/cobbler_api
user: ansible-tester
password: <PASSWORD>
'''
from distutils.version import LooseVersion
import socket
from ansible.errors import AnsibleError
from ansible.module_utils.common.text.converters import to_bytes, to_native, to_text
from ansible.module_utils.common._collections_compat import MutableMapping
from ansible.module_utils.six import iteritems
from ansible.plugins.inventory import BaseInventoryPlugin, Cacheable, to_safe_group_name
# xmlrpc
try:
import xmlrpclib as xmlrpc_client
HAS_XMLRPC_CLIENT = True
except ImportError:
try:
import xmlrpc.client as xmlrpc_client
HAS_XMLRPC_CLIENT = True
except ImportError:
HAS_XMLRPC_CLIENT = False
class InventoryModule(BaseInventoryPlugin, Cacheable):
''' Host inventory parser for ansible using cobbler as source. '''
NAME = 'community.general.cobbler'
def __init__(self):
super(InventoryModule, self).__init__()
# from config
self.cobbler_url = None
self.exclude_profiles = [] # A list of profiles to exclude
self.connection = None
self.token = None
self.cache_key = None
self.use_cache = None
def verify_file(self, path):
valid = False
if super(InventoryModule, self).verify_file(path):
if path.endswith(('cobbler.yaml', 'cobbler.yml')):
valid = True
else:
self.display.vvv('Skipping due to inventory source not ending in "cobbler.yaml" nor "cobbler.yml"')
return valid
def _get_connection(self):
if not HAS_XMLRPC_CLIENT:
raise AnsibleError('Could not import xmlrpc client library')
if self.connection is None:
self.display.vvvv('Connecting to %s\n' % self.cobbler_url)
self.connection = xmlrpc_client.Server(self.cobbler_url, allow_none=True)
self.token = None
if self.get_option('user') is not None:
self.token = self.connection.login(self.get_option('user'), self.get_option('password'))
return self.connection
def _init_cache(self):
if self.cache_key not in self._cache:
self._cache[self.cache_key] = {}
def _reload_cache(self):
if self.get_option('cache_fallback'):
self.display.vvv('Cannot connect to server, loading cache\n')
self._options['cache_timeout'] = 0
self.load_cache_plugin()
self._cache.get(self.cache_key, {})
def _get_profiles(self):
if not self.use_cache or 'profiles' not in self._cache.get(self.cache_key, {}):
c = self._get_connection()
try:
if self.token is not None:
data = c.get_profiles(self.token)
else:
data = c.get_profiles()
except (socket.gaierror, socket.error, xmlrpc_client.ProtocolError):
self._reload_cache()
else:
self._init_cache()
self._cache[self.cache_key]['profiles'] = data
return self._cache[self.cache_key]['profiles']
def _get_systems(self):
if not self.use_cache or 'systems' not in self._cache.get(self.cache_key, {}):
c = self._get_connection()
try:
if self.token is not None:
data = c.get_systems(self.token)
else:
data = c.get_systems()
except (socket.gaierror, socket.error, xmlrpc_client.ProtocolError):
self._reload_cache()
else:
self._init_cache()
self._cache[self.cache_key]['systems'] = data
return self._cache[self.cache_key]['systems']
def _add_safe_group_name(self, group, child=None):
group_name = self.inventory.add_group(to_safe_group_name('%s%s' % (self.get_option('group_prefix'), group.lower().replace(" ", ""))))
if child is not None:
self.inventory.add_child(group_name, child)
return group_name
def parse(self, inventory, loader, path, cache=True):
super(InventoryModule, self).parse(inventory, loader, path)
# read config from file, this sets 'options'
self._read_config_data(path)
# get connection host
self.cobbler_url = self.get_option('url')
self.cache_key = self.get_cache_key(path)
self.use_cache = cache and self.get_option('cache')
self.exclude_profiles = self.get_option('exclude_profiles')
self.group_by = self.get_option('group_by')
for profile in self._get_profiles():
if profile['parent']:
self.display.vvvv('Processing profile %s with parent %s\n' % (profile['name'], profile['parent']))
if profile['parent'] not in self.exclude_profiles:
parent_group_name = self._add_safe_group_name(profile['parent'])
self.display.vvvv('Added profile parent group %s\n' % parent_group_name)
if profile['name'] not in self.exclude_profiles:
group_name = self._add_safe_group_name(profile['name'])
self.display.vvvv('Added profile group %s\n' % group_name)
self.inventory.add_child(parent_group_name, group_name)
else:
self.display.vvvv('Processing profile %s without parent\n' % profile['name'])
# Create a heirarchy of profile names
profile_elements = profile['name'].split('-')
i = 0
while i < len(profile_elements) - 1:
profile_group = '-'.join(profile_elements[0:i + 1])
profile_group_child = '-'.join(profile_elements[0:i + 2])
if profile_group in self.exclude_profiles:
self.display.vvvv('Excluding profile %s\n' % profile_group)
break
group_name = self._add_safe_group_name(profile_group)
self.display.vvvv('Added profile group %s\n' % group_name)
child_group_name = self._add_safe_group_name(profile_group_child)
self.display.vvvv('Added profile child group %s to %s\n' % (child_group_name, group_name))
self.inventory.add_child(group_name, child_group_name)
i = i + 1
# Add default group for this inventory if specified
self.group = to_safe_group_name(self.get_option('group'))
if self.group is not None and self.group != '':
self.inventory.add_group(self.group)
self.display.vvvv('Added site group %s\n' % self.group)
for host in self._get_systems():
# Get the FQDN for the host and add it to the right groups
hostname = host['hostname'] # None
interfaces = host['interfaces']
if host['profile'] in self.exclude_profiles:
self.display.vvvv('Excluding host %s in profile %s\n' % (host['name'], host['profile']))
continue
# hostname is often empty for non-static IP hosts
if hostname == '':
for (iname, ivalue) in iteritems(interfaces):
if ivalue['management'] or not ivalue['static']:
this_dns_name = ivalue.get('dns_name', None)
if this_dns_name is not None and this_dns_name != "":
hostname = this_dns_name
self.display.vvvv('Set hostname to %s from %s\n' % (hostname, iname))
if hostname == '':
self.display.vvvv('Cannot determine hostname for host %s, skipping\n' % host['name'])
continue
self.inventory.add_host(hostname)
self.display.vvvv('Added host %s hostname %s\n' % (host['name'], hostname))
# Add host to profile group
group_name = self._add_safe_group_name(host['profile'], child=hostname)
self.display.vvvv('Added host %s to profile group %s\n' % (hostname, group_name))
# Add host to groups specified by group_by fields
for group_by in self.group_by:
if host[group_by] == '<<inherit>>':
groups = []
else:
groups = [host[group_by]] if isinstance(host[group_by], str) else host[group_by]
for group in groups:
group_name = self._add_safe_group_name(group, child=hostname)
self.display.vvvv('Added host %s to group_by %s group %s\n' % (hostname, group_by, group_name))
# Add to group for this inventory
if self.group is not None:
self.inventory.add_child(self.group, hostname)
# Add host variables
if self.get_option('want_facts'):
try:
self.inventory.set_variable(hostname, 'cobbler', host)
except ValueError as e:
self.display.warning("Could not set host info for %s: %s" % (hostname, to_text(e)))
|
StarcoderdataPython
|
40383
|
<reponame>ulricheck/enaml_data<gh_stars>0
# -*- coding: utf-8 -*-
"""
Copyright (c) 2015, <NAME>.
Distributed under the terms of the MIT License.
The full license is in the file COPYING.txt, distributed with this software.
Created on Aug 24, 2015
"""
from atom.api import Instance, ForwardInstance, Bool
from enaml.core.pattern import Pattern
from enaml.qt.qt_control import QtControl
from enaml.qt.qt_menu import QtMenu
from enaml.qt.qt_widget import QtWidget
from enaml.qt.QtWidgets import QHeaderView
from enaml.qt.QtCore import Qt, QModelIndex
from enaml_data.widgets.abstract_item import (
ProxyAbstractWidgetItem,
ProxyAbstractWidgetItemGroup
)
TEXT_H_ALIGNMENTS = {
'left': Qt.AlignLeft,
'right': Qt.AlignRight,
'center': Qt.AlignHCenter,
'justify': Qt.AlignJustify,
}
TEXT_V_ALIGNMENTS = {
'top': Qt.AlignTop,
'bottom': Qt.AlignBottom,
'center': Qt.AlignVCenter,
}
RESIZE_MODES = {
'interactive': QHeaderView.Interactive,
'fixed': QHeaderView.Fixed,
'stretch': QHeaderView.Stretch,
'resize_to_contents': QHeaderView.ResizeToContents,
'custom': QHeaderView.Custom
}
class AbstractQtWidgetItemGroup(QtControl, ProxyAbstractWidgetItemGroup):
""" Base class for Table and Tree Views
"""
#: Context menu for this group
menu = Instance(QtMenu)
def init_layout(self):
for child in self.children():
if isinstance(child, QtMenu):
self.menu = child
def refresh_style_sheet(self):
pass # Takes a lot of time
def _abstract_item_view():
from .qt_abstract_item_view import QtAbstractItemView
return QtAbstractItemView
class AbstractQtWidgetItem(AbstractQtWidgetItemGroup, ProxyAbstractWidgetItem):
#:
is_destroyed = Bool()
#: Index within the view
index = Instance(QModelIndex)
#: Delegate widget to display when editing the cell
#: if the widget is editable
delegate = Instance(QtWidget)
#: Reference to view
view = ForwardInstance(_abstract_item_view)
def create_widget(self):
# View items have no widget!
for child in self.children():
if isinstance(child, (Pattern, QtWidget)):
self.delegate = child
def init_widget(self):
pass
def init_layout(self):
super(AbstractQtWidgetItem, self).init_layout()
self._update_index()
def _update_index(self):
""" Update where this item is within the model"""
raise NotImplementedError
def destroy(self):
""" Set the flag so we know when this item is destroyed """
self.is_destroyed = True
super(AbstractQtWidgetItem, self).destroy()
|
StarcoderdataPython
|
3248133
|
# -*- coding: utf-8 -*-
# @Author: <NAME>
# @Date: 2017-09-21 11:33:48
# @Last Modified by: <NAME>
# @Last Modified time: 2018-09-17 17:17:38
import os
_colors = {
"running_color": 'magenta',
"conf_key_color": 'cyan',
"conf_val_color": 'yellow',
"error_color": 'red',
"warning_color": 'yellow',
"help_color": 'white',
}
# this is the default configuration
# replace YOUR_SSH_KEY and YOUR_SSH_USER with real life values
# e.g. {"key":"mykeyfile.pem" , "user":"ubuntu"}
_default_config = {
"ssh_path": "~/.ssh",
"default_key": {
"key": "YOUR_SSH_KEY", # replace this
"user": "YOUR_SSH_USER" # replace this
},
}
#
# Sample Configuration
#
sample_config1 = {
# *mandatory*
#
# define a path for your ssh keys
"ssh_path": "~/.ssh",
# define the default key to user if to set for an instance,
# *mandatory* if no keys are defined in instances
"default_key": {
"key": "YOUR_SSH_KEY", # replace this
"user": "YOUR_SSH_USER" # replace this
},
# this defines instances of interest, these will show when doing 'list', or 'list running' ( as opposed to 'list all', 'list all-running' that will show all instances, and not just those of interest)
"instances" : {
"YOUR_INSTANCE_ID1" : {
# this key will be used when connecting this instance
"key" : "YOUR_INSTANCE_SPECIFIC_SSH_KEY1",
"user": "YOUR_INSTANCE_SPECIFIC_SSH_USER1",
},
"YOUR_INSTANCE_ID2": {
# this key will be used when connecting this instance
"key": "YOUR_INSTANCE_SPECIFIC_SSH_KEY2",
"user": "YOUR_INSTANCE_SPECIFIC_SSH_USER2",
},
"YOUR_INSTANCE_ID3": {
# the default key will be used when connecting to this instance
}
}
}
#
# OPTIONAL :
#
# this dictionary is used for automatically loading different configurations according to AWS_DEFAULT_PROFILE env var
# if not set or not found, _default_config is loaded
# _aws_profile_auto_load = {
# "YOUR_AWS_PROFILE_1": sample_config1,
# "YOUR_AWS_PROFILE_1": sample_config2,
# }
_aws_profile_auto_load = {}
_active_configuration = {}
def auto_load():
global _active_configuration
profile = os.getenv("AWS_DEFAULT_PROFILE")
if profile in _aws_profile_auto_load:
print("auto-loading configuration for aws profile " + os.getenv("AWS_DEFAULT_PROFILE"))
_active_configuration = _aws_profile_auto_load[profile]
else:
print("no auto load info found or AWS_DEFAULT_PROFILE not set, loading default configuration")
_active_configuration = _default_config
|
StarcoderdataPython
|
126974
|
<gh_stars>0
# -*- coding: utf-8 -*-
# @Author: disheng
import os
PROJECT_PATH = os.path.abspath(
os.path.join(
os.path.abspath(os.path.dirname(__file__)),
os.pardir))
class DefaultConfig(object):
"""
default config, 由git托管，一般情况下不用修改
可以在config目录下新建configs.py, 更新自己的本地配置，会覆盖此处的配置
未被覆盖的配置将使用此处的配置值
"""
# 项目路径
project_path = PROJECT_PATH
# 切词词典
user_dict_path = project_path + "/data/dict/user_dict.dict"
# 词性标注词典
user_tag_path = project_path + "/data/dict/user_tag.dict"
# 停用词词典
stopwords_path = project_path + "/data/dict/user_stopwords.dict"
# ltp模型路径（可以根据自己下载的数据地址来覆盖改写）
ltp_model_path = project_path + '/data/ltp_data'
seg_model_path = project_path + '/data/ltp_data/cws.model'
pos_model_path = project_path + '/data/ltp_data/pos.model'
par_model_path = project_path + '/data/ltp_data/parser.model'
# word2vec
wordvector_model_path = project_path + "/data/model/word2vec.model"
word2vec_format_model_path = project_path + "/data/model/word2vec.bin"
# doc2vec
docvector_model_path = project_path + "/data/model/doc2vec.model"
# 情感分析模型
sentiment_model_path = project_path + "/data/model/sentiment.model"
# 健康风险评论分析模型
risk_model_path = project_path + "/data/model/risk.model"
# 标签聚类模型
cluster_tag_model_path = project_path + "/data/model/cluster_tag.model"
# 数据路径
input_data_path = project_path + "/data/review.csv"
segged_path = project_path + "/data/review.segged"
dsr_review_path = project_path + "/data/review_dsr.csv"
new_dsr_review_path = project_path + "/data/new_review_dsr.csv"
tag_path = project_path + "/data/output/tags.csv"
structured_tag_path = project_path + "/data/output/structured_tags.csv"
tag_counts_path = project_path + "/data/output/tag_counts.csv"
structured_tag_counts_path = project_path + "/data/output/structured_tag_counts.csv"
tag_counts_segged_path = project_path + "/data/tag_counts.segged"
tag_data_path = project_path + "/data/tag_data.npy"
sentiment_input_path = project_path + "/data/output/tag_counts_oneday.csv"
sentiment_test_output_path = project_path + "/data/output/sentiment_test.csv"
sentiment_output_path = project_path + "/data/output/sentiment.csv"
risk_test_output_path = project_path + "/data/output/risk_test.csv"
tag_sentiment_model_path = project_path + "/data/model.tag_sentiment_lr.model"
# spark测试路径
spark_test_out = project_path + "/data/output/spark_out"
spark_test_segged = project_path + "/data/spark_review.segged"
# 聚类数据路径
cluster_path = project_path + "/data/output/clusters.csv"
cluster_tag_filter_path = project_path + "/data/output/clusters_tag_filter.csv"
cluster_tag_path = project_path + "/data/output/cluster_tags.csv"
cluster_filter_path = project_path + "/data/output/clusters_filter.csv"
cluster_filter_result_path = project_path + "/data/output/clusters_filter_result.csv"
# eval路径
eval_out_root = project_path + "/data/output/eval"
risky_comments_path = project_path + "/data/risky_comments.csv"
# 调试相关
DEBUG_LOG_SWITCH = False # 是否通过print_debug_log打印调试信息
TAG_DELIM = "" # tag组件之间分隔符
INPUT_DELIM = "\t" # 输入文件的分隔符
# 标签提取策略
NEGATIVE_ADVS = ['不'] # 负面副词
ADV_BLACKLIST = ['但是', '而且']
TEST_SMALL_DATA = False
# 标签聚类策略
MIN_TAG_OCCURANCE = 3
CLUSTER_MODE = "all"
# spark流程相关配置
use_local_input = False
|
StarcoderdataPython
|
3284273
|
# Copyright 2018 The Cirq Developers
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import numpy as np
import cirq
def test_equal_up_to_global_phase_primitives():
assert cirq.equal_up_to_global_phase(1.0 + 1j, 1.0 + 1j, atol=1e-9)
assert not cirq.equal_up_to_global_phase(2.0, 1.0 + 1j, atol=1e-9)
assert cirq.equal_up_to_global_phase(1.0 + 1j, 1.0 - 1j, atol=1e-9)
assert cirq.equal_up_to_global_phase(np.exp(1j * 3.3), 1.0 + 0.0j, atol=1e-9)
assert cirq.equal_up_to_global_phase(np.exp(1j * 3.3), 1.0j, atol=1e-9)
assert cirq.equal_up_to_global_phase(np.exp(1j * 3.3), 1, atol=1e-9)
assert not cirq.equal_up_to_global_phase(np.exp(1j * 3.3), 0, atol=1e-9)
assert cirq.equal_up_to_global_phase(1j, 1 + 1e-10, atol=1e-9)
assert not cirq.equal_up_to_global_phase(1j, 1 + 1e-10, atol=1e-11)
# atol is applied to magnitude of complex vector, not components.
assert cirq.equal_up_to_global_phase(1.0 + 0.1j, 1.0, atol=0.01)
assert not cirq.equal_up_to_global_phase(1.0 + 0.1j, 1.0, atol=0.001)
assert cirq.equal_up_to_global_phase(1.0 + 1j, np.sqrt(2) + 1e-8, atol=1e-7)
assert not cirq.equal_up_to_global_phase(1.0 + 1j, np.sqrt(2) + 1e-7, atol=1e-8)
assert cirq.equal_up_to_global_phase(1.0 + 1e-10j, 1.0, atol=1e-15)
def test_equal_up_to_global_numeric_iterables():
assert cirq.equal_up_to_global_phase([], [], atol=1e-9)
assert cirq.equal_up_to_global_phase([[]], [[]], atol=1e-9)
assert cirq.equal_up_to_global_phase([1j, 1], [1j, 1], atol=1e-9)
assert cirq.equal_up_to_global_phase([1j, 1j], [1 + 0.1j, 1 + 0.1j], atol=0.01)
assert not cirq.equal_up_to_global_phase([1j, 1j], [1 + 0.1j, 1 - 0.1j], atol=0.01)
assert not cirq.equal_up_to_global_phase([1j, 1j], [1 + 0.1j, 1 + 0.1j], atol=1e-3)
assert not cirq.equal_up_to_global_phase([1j, -1j], [1, 1], atol=0.0)
assert not cirq.equal_up_to_global_phase([1j, 1], [1, 1j], atol=0.0)
assert not cirq.equal_up_to_global_phase([1j, 1], [1j, 1, 0], atol=0.0)
assert cirq.equal_up_to_global_phase((1j, 1j), (1, 1 + 1e-4), atol=1e-3)
assert not cirq.equal_up_to_global_phase((1j, 1j), (1, 1 + 1e-4), atol=1e-5)
assert not cirq.equal_up_to_global_phase((1j, 1), (1, 1j), atol=1e-09)
def test_equal_up_to_global_numpy_array():
assert cirq.equal_up_to_global_phase(
np.asarray([1j, 1j]), np.asarray([1, 1], dtype=np.complex64)
)
assert not cirq.equal_up_to_global_phase(
np.asarray([1j, -1j]), np.asarray([1, 1], dtype=np.complex64)
)
assert cirq.equal_up_to_global_phase(np.asarray([]), np.asarray([]))
assert cirq.equal_up_to_global_phase(np.asarray([[]]), np.asarray([[]]))
def test_equal_up_to_global_mixed_array_types():
a = [1j, 1, -1j, -1]
b = [-1, 1j, 1, -1j]
c = [-1, 1, -1, 1]
assert cirq.equal_up_to_global_phase(a, tuple(b))
assert not cirq.equal_up_to_global_phase(a, tuple(c))
c_types = [np.complex64, np.complex128]
if hasattr(np, 'complex256'):
c_types.append(np.complex256)
for c_type in c_types:
assert cirq.equal_up_to_global_phase(np.asarray(a, dtype=c_type), tuple(b))
assert not cirq.equal_up_to_global_phase(np.asarray(a, dtype=c_type), tuple(c))
assert cirq.equal_up_to_global_phase(np.asarray(a, dtype=c_type), b)
assert not cirq.equal_up_to_global_phase(np.asarray(a, dtype=c_type), c)
# Object arrays and mixed array/scalar comparisons.
assert not cirq.equal_up_to_global_phase([1j], 1j)
assert not cirq.equal_up_to_global_phase(np.asarray([1], dtype=np.complex128), np.exp(1j))
assert not cirq.equal_up_to_global_phase([1j, 1j], [1j, "1j"])
assert not cirq.equal_up_to_global_phase([1j], "Non-numeric iterable")
assert not cirq.equal_up_to_global_phase([], [[]], atol=0.0)
# Dummy container class implementing _equal_up_to_global_phase_
# for homogeneous comparison, with nontrivial getter.
class A:
def __init__(self, val):
self.val = [val]
def _equal_up_to_global_phase_(self, other, atol):
if not isinstance(other, A):
return NotImplemented
return cirq.equal_up_to_global_phase(self.val[0], other.val[0], atol=atol)
# Dummy container class implementing _equal_up_to_global_phase_
# for heterogeneous comparison.
class B:
def __init__(self, val):
self.val = [val]
def _equal_up_to_global_phase_(self, other, atol):
if not isinstance(self.val[0], type(other)):
return NotImplemented
return cirq.equal_up_to_global_phase(self.val[0], other, atol=atol)
def test_equal_up_to_global_phase_eq_supported():
assert cirq.equal_up_to_global_phase(A(0.1 + 0j), A(0.1j), atol=1e-2)
assert not cirq.equal_up_to_global_phase(A(0.0 + 0j), A(0.1j), atol=0.0)
assert not cirq.equal_up_to_global_phase(A(0.0 + 0j), 0.1j, atol=0.0)
assert cirq.equal_up_to_global_phase(B(0.0j), 1e-8j, atol=1e-8)
assert cirq.equal_up_to_global_phase(1e-8j, B(0.0j), atol=1e-8)
assert not cirq.equal_up_to_global_phase(1e-8j, B(0.0 + 0j), atol=1e-10)
# cast types
assert cirq.equal_up_to_global_phase(A(0.1), A(0.1j), atol=1e-2)
assert not cirq.equal_up_to_global_phase(1e-8j, B(0.0), atol=1e-10)
|
StarcoderdataPython
|
68862
|
#!/home/francisco/Projects/Pycharm/py-binary-trees-draw/venv/bin/python
# -*- coding: utf-8 -*-
from node import Node
class AVLTree:
def __init__(self):
self.root = None
self.leaf = Node(None)
self.leaf.height = -1
self.nodes_dict_aux = {}
self.nodes_dict = {}
def insert(self, key):
"""
Insert key values in tree
:param key: numeric.
:return: self.nodes_height_dict a dict where keys are tuple (parent, height) and values are the children.
"""
node = Node(key)
node.left = self.leaf
node.right = self.leaf
if not self.root:
self.root = node
else:
current = self.root
parent = current
while current:
if current == self.leaf:
break
node.height += 1
parent = current
if node.key < current.key:
current = current.left
elif node.key > current.key:
current = current.right
elif node.key == current.key:
return False
node.parent = parent
if node.key < parent.key:
parent.left = node
else:
parent.right = node
self._calculate_height(node)
self._fix_violation(node)
self._recovery_nodes_dict()
return self.nodes_dict
return None
def walk_in_order(self, node=None):
"""
Walking tree in pre-order.
:param node: node object.
"""
if not node:
node = self.root
if node != self.leaf:
self.walk_in_order(node.left)
fb = node.left.height - node.right.height
if node.parent:
print('{0}\t{1}\t{2}\t{3}\t{4}\t{5}'.format(node.key, node.parent.key, node.left.key, node.right.key,
node.height, fb))
else:
print('{0}\t{1}\t{2}\t{3}\t{4}\t{5}'.format(node.key, None, node.left.key, node.right.key,
node.height, fb))
self.walk_in_order(node.right)
def walk_pos_order(self, node=None):
"""
Walking tree in pos-order.
:param node: node object.
"""
if not node:
node = self.root
if node != self.leaf:
self.walk_pos_order(node.right)
if node.parent:
print('{0}\t{1}\t{2}\t{3}\t{4}'.format(node.key, node.parent.key, node.left.key, node.right.key,
node.height, ))
else:
print('{0}\t{1}\t{2}\t{3}\t{4}'.format(node.key, None, node.left.key, node.right.key, node.height))
self.walk_pos_order(node.left)
def search(self, value):
"""
Search the node object that key is equal for given value.
:param value: numeric.
:return: node object.
"""
current = self.root
while current and value != current.key:
if not current.key:
return False
if current.key > value:
current = current.left
else:
current = current.right
return current
def minimum(self, node=None):
"""
Search the minimum key in subtree that start from given node.
:param node: node object.
:return: node object.
"""
if not node:
node = self.root
while node.left != self.leaf:
node = node.left
return node
def maximum(self, node=None):
"""
Search the maximum key in subtree that start from given node.
:param node: node object.
:return: node object.
"""
if not node:
node = self.root
while node.right != self.leaf:
node = node.right
return node
def successor(self, value):
"""
Find the largest value in the tree directly above the given value.
:param value: numeric.
:return: object node.
"""
current = self.search(value)
if not current:
return False
elif current.right != self.leaf:
node = self.minimum(current.right)
return node
node = current.parent
while node and current == node.right:
current = node
node = current.parent
if not node:
return self.maximum()
return node
def predecessor(self, value):
"""
It finds in the tree the lowest value directly below the given number.
:param value: numeric.
:return: node object.
"""
current = self.search(value)
if not current:
return False
elif current.left != self.leaf:
node = self.maximum(current.left)
return node
node = current.parent
while node and current == node.left:
current = node
node = current.parent
if not node:
return self.minimum()
return node
def remove(self, value):
"""
Remove node where key is equal of given value.
:param value: numeric
"""
node = self.search(value)
if node == self.root:
return self._remove_root()
elif node.left == self.leaf and node.right == self.leaf:
return self._remove_if_leaf(node)
elif (node.left == self.leaf) ^ (node.right == self.leaf):
return self._remove_if_one_child(node)
else:
return self._remove_if_two_children(node)
def _remove_if_leaf(self, node):
remove_key = node.key
parent = node.parent
if parent.left == node:
parent.left = self.leaf
else:
parent.right = self.leaf
self._calculate_height(parent)
self._fix_violation(parent)
self._recovery_nodes_dict()
del node
return remove_key, None
def _remove_if_one_child(self, node):
remove_key = node.key
if node.parent.left == node:
if node.right == self.leaf:
node.parent.left = node.left
else:
node.parent.left = node.right
else:
if node.right == self.leaf:
node.parent.right = node.left
else:
node.parent.right = node.right
node.left.parent = node.parent
node.right.parent = node.parent
self._calculate_height(node.parent)
self._fix_violation(node.parent)
self._recovery_nodes_dict()
del node
return remove_key, None
def _remove_if_two_children(self, node):
remove_key = node.key
successor = self.successor(node.key)
if successor == node.right:
if node == node.parent.left:
node.parent.left = successor
else:
node.parent.right = successor
successor.parent = node.parent
successor.left = node.left
successor.left.parent = successor
else:
if node == node.parent.left:
node.parent.left = successor
else:
node.parent.right = successor
successor.parent.left = successor.right
successor.left = node.left
successor.right = node.right
node.right.parent = successor
node.left.parent = successor
successor.parent = node.parent
self._calculate_height(node.parent)
self._fix_violation(node.parent)
self._recovery_nodes_dict()
del node
return remove_key, successor.key
def _remove_root(self):
remove_key = self.root.key
successor = None
if self.root.left == self.leaf and self.root.right == self.leaf:
self.root = None
elif (self.root.left == self.leaf) ^ (self.root.right == self.leaf):
if self.root.left != self.leaf:
self.root = self.root.left
else:
self.root = self.root.right
self.root.parent = None
else:
successor = self.successor(self.root.key)
if successor == self.root.right:
successor.parent = None
successor.left = self.root.left
self.root.left.parent = successor
self.root = successor
else:
if successor.right:
successor.right.parent = successor.parent
successor.parent.left = successor.right
successor.left = self.root.left
successor.right = self.root.right
self.root.left.parent = successor
self.root.right.parent = successor
successor.parent = None
self.root = successor
self._calculate_height(self.root)
self._fix_violation(self.root)
self._recovery_nodes_dict()
if successor:
return remove_key, successor.key
else:
return remove_key, None
def _recovery_nodes_dict(self):
# Because fixing the violations mess up the heights of each node we have to first create a dict where the
# keys are the parents and the values are a list of tuples with the childs and their heights.
self.nodes_dict_aux = {} # a dict where keys are parent and values is tuples with child and ir height.
self._make_nodes_dict_aux()
self.nodes_dict = {} # a dict where keys are tuple with parent and chid height and values is tuples
# with child.
self._make_nodes_dict()
def _make_nodes_dict_aux(self, node=None, flag=0):
"""
Recursion function to create dict where the keys are the parents and the values are a list of tuples with the
childs and their heights.
:param node: node object.
:param flag: integer who indicate if node is left or right child.
"""
if not node:
node = self.root
if node != self.root and node != self.leaf:
height = self._calculate_real_height(node)
if not (node.parent.key in self.nodes_dict_aux):
self.nodes_dict_aux[node.parent.key] = [None, None]
self.nodes_dict_aux[node.parent.key][flag] = (node.key, height)
if node != self.leaf:
self._make_nodes_dict_aux(node.left, 0)
self._make_nodes_dict_aux(node.right, 1)
def _make_nodes_dict(self):
for key in self.nodes_dict_aux:
nodes = self.nodes_dict_aux[key]
if nodes[0] and nodes[1]:
_, height = min(nodes, key=lambda x: x[:][1])
# print(nodes[0][0], nodes[1][0], height)
self.nodes_dict[key, height] = [nodes[0][0], nodes[1][0]]
else:
if nodes[0]:
height = nodes[0][1]
self.nodes_dict[key, height] = [nodes[0][0], None]
else:
height = nodes[1][1]
self.nodes_dict[key, height] = [None, nodes[1][0]]
def _calculate_real_height(self, node):
"""
Calculate real height in tree of given node.
:param node: node object.
:return: numeric.
"""
height = 0
current = node
while current != self.root:
height += 1
current = current.parent
return height
def _calculate_height(self, node):
"""
Calculate left and right height of node.
:param node: node object.
"""
current = node
while current:
current.height = max(current.left.height, current.right.height) + 1
current = current.parent
def _fix_violation(self, node):
"""
Verify if is necessary rotate the node.
:param node: node object.
"""
flag = False
previous = node
current = node.parent
while current:
fb1 = current.left.height - current.right.height
fb2 = previous.left.height - previous.right.height
if fb1 >= 2 and fb2 >= 0:
self._rotate_right(current)
flag = True
break
if fb1 <= -2 and fb2 <= 0:
self._rotate_left(current)
flag = True
break
if fb1 >= +2 and fb2 <= 0:
self._rotate_left(previous)
self._rotate_right(current)
flag = True
break
if fb1 <= -2 and fb2 >= 0:
self._rotate_right(previous)
self._rotate_left(current)
flag = True
break
previous = current
current = current.parent
return flag
def _rotate_left(self, x):
"""
Rotate node to left.
:param x: node object.
"""
y = x.right # define y
x.right = y.left # x right now igual y left
y.left.parent = x # y left now is x left
y.parent = x.parent # y parent is x parent
if x == self.root: # if x is root now y is root
self.root = y
elif x == x.parent.left:
x.parent.left = y # if x is the left child, then y is the left child
else:
x.parent.right = y # if x is the right child, then y is the right child
y.left = x # y left now is x
x.parent = y # x parent now is y
x.height -= 2
self._calculate_height(x)
def _rotate_right(self, x):
"""
Rotate node to right.
:param x: node object.
"""
y = x.left
x.left = y.right
y.right.parent = x
y.parent = x.parent
if x == self.root: # if x is root now y is root
self.root = y
elif x == x.parent.left:
x.parent.left = y # if x is the left child, then y is the left child
else:
x.parent.right = y # if x is the right child, then y is the right child
y.right = x
x.parent = y
x.height -= 2
self._calculate_height(x)
if __name__ == '__main__':
bt = AVLTree()
print('node\tparent\tleft\tright\theight\tfb')
print('***********************************************')
# bt.insert(11)
# bt.insert(2)
# bt.insert(14)
# bt.insert(1)
# bt.insert(7)
# bt.insert(15)
# bt.insert(5)
# bt.insert(8)
# bt.insert(4)
# bt.walk_in_order()
# print('***********************************************')
# print(bt.nodes_dict)
# print('***********************************************')
bt.insert(44)
bt.insert(17)
bt.insert(78)
bt.insert(32)
bt.insert(50)
bt.insert(88)
bt.insert(48)
bt.insert(62)
bt.insert(84)
bt.insert(92)
bt.insert(80)
bt.insert(82)
bt.walk_in_order()
print('***********************************************')
print(bt.nodes_dict)
print('***********************************************')
bt.remove(32)
print('remove 32')
print('node\tparent\tleft\tright\theight\tfb')
print('***********************************************')
bt.walk_in_order()
print('***********************************************')
print(bt.nodes_dict)
print('***********************************************')
bt.remove(84)
print('remove 84')
print('node\tparent\tleft\tright\theight\tfb')
print('***********************************************')
bt.walk_in_order()
print('***********************************************')
print(bt.nodes_dict)
print('***********************************************')
bt.remove(82)
print('remove 82')
print('node\tparent\tleft\tright\theight\tfb')
print('***********************************************')
bt.walk_in_order()
print('***********************************************')
print(bt.nodes_dict)
print('***********************************************')
# bt.insert(4)
# bt.insert(2)
# bt.insert(6)
# bt.insert(1)
# bt.insert(3)
# bt.insert(5)
# bt.insert(15)
# bt.insert(7)
# bt.insert(16)
# bt.insert(14)
# bt.bt_draw()
# bt.insert(10)
# bt.insert(5)
# bt.insert(16)
# bt.insert(2)
# bt.insert(8)
# bt.insert(1)
# bt.bt_draw()
|
StarcoderdataPython
|
41422
|
# Generated by Django 2.2.12 on 2021-02-02 06:53
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('accounts', '0003_auto_20210202_0503'),
]
operations = [
migrations.AddField(
model_name='account',
name='email',
field=models.CharField(default='NEED TO FORMAT EMAIL', max_length=42),
),
migrations.AddField(
model_name='account',
name='name',
field=models.CharField(default='None', max_length=42),
),
migrations.AddField(
model_name='account',
name='profits',
field=models.CharField(default='0.00', max_length=42),
),
migrations.AlterField(
model_name='account',
name='country_code',
field=models.CharField(default='NO', max_length=2),
),
migrations.AlterField(
model_name='account',
name='current_balance',
field=models.CharField(default='0.00', max_length=10),
),
migrations.AlterField(
model_name='account',
name='interest_rate',
field=models.CharField(default='0.01', max_length=10),
),
migrations.AlterField(
model_name='transaction',
name='deposit_date',
field=models.CharField(default='NEED TO FORMAT DATE', max_length=10),
),
migrations.AlterField(
model_name='transaction',
name='wallet',
field=models.CharField(default='MISSING WALLET', max_length=42),
),
]
|
StarcoderdataPython
|
1612927
|
#! /usr/bin/env python
import sys
import unittest
def run_tests():
test_suite = unittest.TestLoader().discover('dcm_spec_tools')
result = unittest.TextTestRunner(verbosity=2).run(test_suite)
return result.wasSuccessful()
if __name__ == '__main__':
sys.exit(0 if run_tests() else 1)
|
StarcoderdataPython
|
3350395
|
from scipy.ndimage import zoom
from scipy.io import loadmat
import numpy as np
import nibabel as nib
import glob
import os
nii_list = glob.glob("../data/mat/*.nii.gz")
nii_list.sort()
for nii_path in nii_list:
print("-----------------------------------------------")
nii_file = nib.load(nii_path)
tmpl_affine = nii_file.affine
tmpl_header = nii_file.header
nii_name = os.path.basename(nii_path)[:-19]
osp_path = os.path.dirname(nii_path)+"/"+nii_name+"_recon_OSP_F4.mat"
ori_path = os.path.dirname(nii_path)+"/"+nii_name+".mat"
for package in [[osp_path, "osp"], [ori_path, "ori"]]:
mat_path = package[0]
save_tag = package[1]
mdict = loadmat(mat_path)
try:
mat_data = mdict["reconImg"]
except Exception:
pass # or you could use 'continue'
try:
mat_data = mdict["data"]
except Exception:
pass # or you could use 'continue'
save_data = mat_data
save_file = nib.Nifti1Image(save_data, affine=tmpl_affine, header=tmpl_header)
save_name = os.path.dirname(nii_path)+"/"+nii_name+"_"+save_tag+".nii.gz"
nib.save(save_file, save_name)
print(save_name)
|
StarcoderdataPython
|
1696227
|
import tensorflow as tf
import numpy as np
from tfmonopoles.theories import GeorgiGlashowRadialTheory
from tfmonopoles import FieldTools
import argparse
parser = argparse.ArgumentParser(description="Generate a monopole ring")
parser.add_argument("--vev", "-v", default=1.0, type=float)
parser.add_argument("--gaugeCoupling", "-g", default=1.0, type=float)
parser.add_argument("--selfCoupling", "-l", default=0.5, type=float)
parser.add_argument("--tol", "-t", default=1e-3, type=float)
parser.add_argument("--outputPath", "-o", default="", type=str)
parser.add_argument("--inputPath", "-i", default="", type=str)
parser.add_argument("--numCores", "-n", default=0, type=int)
parser.add_argument("--externalField", "-B", default=0, type=int)
parser.add_argument("--maxSteps", "-M", default=100000, type=int)
parser.add_argument("--momentum", "-p", default=0.95, type=float)
args = parser.parse_args()
if args.numCores != 0:
tf.config.threading.set_intra_op_parallelism_threads(args.numCores)
tf.config.threading.set_inter_op_parallelism_threads(args.numCores)
# Load data from input path
inputPath = args.inputPath
R = tf.constant(np.load(inputPath + "/R.npy", allow_pickle=True))
Y = tf.constant(np.load(inputPath + "/Y.npy", allow_pickle=True))
Z = tf.constant(np.load(inputPath + "/Z.npy", allow_pickle=True))
scalarField = np.load(inputPath + "/scalarField.npy", allow_pickle=True)
gaugeField = np.load(inputPath + "/gaugeField.npy", allow_pickle=True)
inputParams = np.load(inputPath + "/params.npy", allow_pickle=True).item()
latShape = tf.shape(R)
# Add magnetic field if required
numFluxQuanta = args.externalField
magField = FieldTools.constantMagneticField(R, Y, Z, 0, numFluxQuanta)
gaugeField = FieldTools.linearSuperpose(gaugeField, magField)
# Theory parameters
params = {
"vev" : args.vev,
"selfCoupling" : args.selfCoupling,
"gaugeCoupling" : args.gaugeCoupling,
"latShape" : latShape
}
scalarField = scalarField * tf.cast(params["vev"] / inputParams["vev"], tf.complex128)
theory = GeorgiGlashowRadialTheory(params)
scalarFieldVar = tf.Variable(scalarField)
gaugeFieldVar = tf.Variable(gaugeField)
@tf.function
def lossFn():
return theory.energy(scalarFieldVar, gaugeFieldVar)
energy = lossFn()
tf.print(energy)
# Stopping criterion on RSS gradient
tol = args.tol
# Just need to satisfy rssGrad < rssGradOld to start the loop
rssGrad = 1e6
rssGradOld = 1e7
numSteps = 0
maxSteps = args.maxSteps
printIncrement = 10
minSteps = 100
# First perform standard gradient descent to get close to the saddle point
opt = tf.keras.optimizers.SGD(learning_rate=0.01*args.gaugeCoupling*args.vev)
while numSteps < minSteps or (rssGrad < rssGradOld and numSteps < maxSteps and rssGrad > tol):
# Compute the field energy, with tf watching the variables
with tf.GradientTape() as tape:
energy = lossFn()
vars = [scalarFieldVar, gaugeFieldVar]
# Compute the gradients using automatic differentiation
grads = tape.gradient(energy, vars)
# Postprocess the gauge field gradients
grads = theory.processGradients(grads, vars)
# Compute RSS gradient for stopping criterion
gradSq = FieldTools.innerProduct(grads[0], grads[0], tr=True)
gradSq += FieldTools.innerProduct(grads[1], grads[1], tr=True, adj=True)
rssGradOld = rssGrad
rssGrad = tf.math.sqrt(gradSq)
# rssGrad = tf.reduce_max(tf.abs(grads[1]))
if (numSteps % printIncrement == 0):
print("Energy after " + str(numSteps) + " iterations: " +\
str(energy.numpy()))
print("RSS gradient after " + str(numSteps) + " iterations: " +\
str(rssGrad.numpy()))
# Perform the gradient descent step
opt.apply_gradients(zip(grads, vars))
numSteps += 1
# Postprocess the fields
scalarFieldVar.assign(0.5*(scalarFieldVar + tf.math.conj(scalarFieldVar)))
gaugeFieldVar.assign(FieldTools.projectToSu2(gaugeFieldVar))
print("First gradient descent completed in " + str(numSteps) + " iterations")
print("Energy reached: " + str(energy.numpy()))
# Intermediate save
outputPath = args.outputPath
if outputPath != "":
np.save(outputPath + "/R", R.numpy())
np.save(outputPath + "/Y", Y.numpy())
np.save(outputPath + "/Z", Z.numpy())
np.save(outputPath + "/scalarField", scalarFieldVar.numpy())
np.save(outputPath + "/gaugeField", gaugeFieldVar.numpy())
np.save(outputPath + "/params", params)
# Now minimise the RSS gradient summed over all sites
opt = tf.keras.optimizers.SGD(learning_rate=1e-5, momentum=args.momentum)
numSteps = 0
while rssGrad > tol and numSteps < maxSteps:
vars = [scalarFieldVar, gaugeFieldVar]
# Compute the field energy, with tf watching the variables
with tf.GradientTape() as outterTape:
with tf.GradientTape() as innerTape:
energy = lossFn()
# Compute the gradients using automatic differentiation
grads = innerTape.gradient(energy, vars)
# Postprocess the gauge field gradients
grads = theory.processGradients(grads, vars)
# Compute squared gradients (note that as this is being tracked we can't
# use the innerProduct function due to passing by value)
gradSq = tf.math.real(
tf.reduce_sum(tf.linalg.adjoint(grads[0]) @ grads[0])
)
gradSq += tf.math.real(
tf.reduce_sum(
tf.linalg.trace(tf.linalg.adjoint(grads[1]) @ grads[1])
)
)
rssGrad = tf.sqrt(gradSq)
# Compute the second-level gradients (gradient of gradient squared)
ggrads = outterTape.gradient(gradSq, vars)
ggrads = theory.processGradients(ggrads, vars)
# Normalise second-level gradients on a field-by-field basis
scalarGGradSq = FieldTools.innerProduct(ggrads[0], ggrads[0], adj=True)
gaugeGGradSq = FieldTools.innerProduct(
ggrads[1], ggrads[1], tr=True, adj=True
)
ggrads[0] /= tf.cast(tf.math.sqrt(scalarGGradSq) + 1e-6, tf.complex128)
ggrads[1] /= tf.cast(tf.math.sqrt(gaugeGGradSq) + 1e-6, tf.complex128)
if (numSteps % printIncrement == 0):
print("Energy after " + str(numSteps) + " iterations: " +\
str(energy.numpy()))
print("RSS gradient after " + str(numSteps) + " iterations: " +\
str(rssGrad.numpy()))
# Perform the gradient descent step
opt.apply_gradients(zip(ggrads, vars))
numSteps += 1
# Postprocess the fields to avoid drift away from SU(2)/its Lie algebra
scalarFieldVar.assign(0.5*(scalarFieldVar + tf.math.conj(scalarFieldVar)))
gaugeFieldVar.assign(FieldTools.projectToSu2(gaugeFieldVar))
print("Gradient descent finished in " + str(numSteps) + " iterations")
print("Final energy: " + str(energy.numpy()))
# Save fields as .npy files for plotting and further analysis
if outputPath != "":
np.save(outputPath + "/R", R.numpy())
np.save(outputPath + "/Y", Y.numpy())
np.save(outputPath + "/Z", Z.numpy())
np.save(outputPath + "/scalarField", scalarFieldVar.numpy())
np.save(outputPath + "/gaugeField", gaugeFieldVar.numpy())
np.save(outputPath + "/params", params)
|
StarcoderdataPython
|
3210368
|
# -*- coding: utf-8 -*-
"""Package contains following modules assisting in construction of HTTP probes.
* :mod:`selenium_probes.helpers.browser` allows to interact with Selenium WebDriver
* :mod:`selenium_probes.helpers.vault` allows to interact with Azure Key Vault
"""
|
StarcoderdataPython
|
1612458
|
<filename>Hackkerank/Python Challenges/rangoli.py
alph = 'abcdefghijklmnopqrstuvwxyz'
def rangoli_V3(N):
width = 4*(N - 1) + 1
A = list(alph[:N])
rA = list(reversed(A))
all_rows = []
for i in range(N):
thisrow = rA[:i+1] + A[N-i:]
all_rows.append("-".join(thisrow).center(width,"-"))
all_rows = all_rows + list(reversed(all_rows[:-1]))
complete_string = "\n".join(all_rows)
print(complete_string)
rangoli_V3(26)
|
StarcoderdataPython
|
1724131
|
from copy import deepcopy
class TwoTeamsGame:
def __init__(self, team1, team2, player_selector):
"""
:param team1: array of easyAI-supported objects. See Player module
:param team2: array of easyAI-supported objects.
:param player_selector constructor for objects of type AbstractOrderedPlayerSelector (see below)
"""
self.player_selector = player_selector(team1, team2)
self.setup_game()
def setup_game(self):
"""
put here your own initialization and so on
:return:
"""
raise NotImplementedError('Abstract method')
def make_move(self, move):
raise NotImplementedError('Abstract method')
def show(self):
raise NotImplementedError('Abstract method')
def is_over(self):
raise NotImplementedError('Abstract method')
def play(self, nmoves=1000, verbose=True):
history = []
if verbose:
self.show()
for self.nmove in range(1, nmoves + 1):
if self.is_over():
break
move = self.player.ask_move(self)
history.append((deepcopy(self), move))
self.make_move(move)
if verbose:
self.show()
self.switch_player()
history.append(deepcopy(self))
return history
@property
def opponent_team(self):
return self.current_opponent_team()
@property
def player(self):
return self.current_player()
@property
def nplayer(self):
return self.current_player().name
def current_player(self):
return self.player_selector.current_player()
def current_opponent_team(self):
return self.player_selector.opponent_team()
def current_team(self):
return self.player_selector.current_team()
def switch_player(self):
self.player_selector.next_player()
def copy(self):
return deepcopy(self)
def get_move(self):
"""
Method for getting a move from the current player. If the player is an
AI_Player, then this method will invoke the AI algorithm to choose the
move. If the player is a Human_Player, then the interaction with the
human is via the text terminal.
"""
return self.player.ask_move(self)
def play_move(self, move):
"""
Method for playing one move with the current player. After making the move,
the current player will change to the next player.
Parameters
-----------
move:
The move to be played. ``move`` should match an entry in the ``.possibles_moves()`` list.
"""
result = self.make_move(move)
self.switch_player()
return result
class AbstractOrderedPlayerSelector:
"""
Base class for player selectors. Selects next player in order, the behaviour is:
team1 - player1
team2 - player 1
team 1 - player 2
team 2 - player 2
etc
according to rules defined in filter_team
"""
def __init__(self, team1, team2):
self.teams = [team1, team2]
self.move_no = 0
self.counters = [0, 0]
def filter_team(self, team):
"""
Filters an array of players. Used for return active players. For example in a RPG game may be the still alive ones
:param team:
:return:
"""
raise NotImplementedError('Abstract method')
def current_player(self):
team_id = self._current_team_id()
team = self.current_team()
character_id = self.counters[team_id] % len(team)
return team[character_id]
def _current_team_id(self):
return self.move_no % 2
def _next_team_id(self):
return (self.move_no + 1) % 2
def next_player(self):
"""
Moves pointer to next player
:return:
"""
team_id = self._current_team_id()
self.counters[team_id] += 1
self.move_no += 1
def current_team(self):
return self.filter_team(self.teams[self._current_team_id()])
def opponent_team(self):
return self.filter_team(self.teams[self._next_team_id()])
|
StarcoderdataPython
|
1696125
|
<gh_stars>100-1000
from . import calculus
# XXX: hack to set methods
from . import approximation
from . import differentiation
from . import extrapolation
from . import polynomials
|
StarcoderdataPython
|
3326619
|
import datetime
import logging
import os
import pandas as pd
import statsmodels.api as stats
from pandas.tseries.offsets import BDay
from stock_analyzer.data_fetcher import get_ranged_data, get_spx_prices
logging.basicConfig(format='%(level_name)s: %(message)s', level=logging.DEBUG)
class AnalyzerBase(object):
DATA_FOLDER = 'asset_data'
SP500_FILE = 'sp500'
def __init__(self, ticker, hist_start_date=None):
self.ticker = ticker
self.stock_data = pd.DataFrame()
self.sp500_data = pd.DataFrame()
self.hist_start_date = hist_start_date or datetime.datetime.today() - BDay(252)
@property
def mean(self):
raise NotImplementedError("Need to be implemented by sub-classes")
@property
def asset_returns(self):
raise NotImplementedError("Need to be implemented by sub-classes")
@property
def asset_returns(self):
raise NotImplementedError("Need to be implemented by sub-classes")
@property
def index_returns(self):
raise NotImplementedError("Need to be implemented by sub-classes")
def plot_returns(self):
raise NotImplementedError("Need to be implemented by sub-classes")
def plot_returns_against_snp500(self):
raise NotImplementedError("Need to be implemented by sub-classes")
@property
def beta(self):
raise NotImplementedError("Need to be implemented by sub-classes")
@property
def ols_model(self):
raise NotImplementedError("Need to be implemented by sub-classes")
def setup_underlying_data(self, refresh=False):
if not os.path.exists(self.DATA_FOLDER):
os.makedirs(self.DATA_FOLDER)
self.get_sp500_data(refresh=refresh)
self.get_stock_data(refresh=refresh)
def get_stock_data(self, refresh=False):
df = pd.DataFrame()
if refresh or not os.path.exists('{}/{}.csv'.format(self.DATA_FOLDER, self.ticker)):
try:
df = get_ranged_data(self.ticker, self.hist_start_date, useQuandl=False)
self.save_data(df, self.ticker)
except Exception as exception:
logging.error("#### Error for Ticker %s" % self.ticker)
logging.error(str(exception))
else:
logging.debug('Already have {}'.format(self.ticker))
df = pd.read_csv('{}/{}.csv'.format(self.DATA_FOLDER, self.ticker), parse_dates=True, index_col=1)
if df.empty:
logging.error("Unable to get Stock-Data from the Web. Please check connection")
raise IOError("Unable to get Stock-Data from the Web")
df.reset_index(inplace=True)
# df = df.drop("Symbol", axis=1)
df.set_index("Date", inplace=True)
self.stock_data = df
def save_data(self, data_frame, file_name):
data_frame.to_csv('{}/{}.csv'.format(self.DATA_FOLDER, file_name))
logging.info("Save completed for {}".format(file_name))
def get_sp500_data(self, refresh=False):
df = pd.DataFrame()
if refresh or not os.path.exists('{}/{}.csv'.format(self.DATA_FOLDER, self.SP500_FILE)):
try:
df = get_spx_prices(self.hist_start_date)
self.save_data(df, self.SP500_FILE)
except Exception as exception:
logging.error("#### Error in getting SNP-500 data")
logging.error(str(exception))
else:
logging.debug('Already have {}'.format(self.SP500_FILE))
df = pd.read_csv('{}/{}.csv'.format(self.DATA_FOLDER, self.SP500_FILE), parse_dates=True, index_col=1)
if df.empty:
logging.error("Unable to get Stock-Data from the Web. Please check connection")
raise IOError("Unable to get SNP 500 from the Web")
df.reset_index(inplace=True)
df.set_index("Date", inplace=True)
self.sp500_data = df
@staticmethod
def ordinary_least_square_model(asset_returns, index_returns):
def lin_reg(x, y):
x = stats.add_constant(x)
model = stats.OLS(y, x).fit()
x = x[:, 1]
return model
return lin_reg(index_returns.values, asset_returns.values)
|
StarcoderdataPython
|
172735
|
<gh_stars>1-10
# test_procedure_10002.py
# Connect P15..P8 to P7..P0, D/A0,1 to A/D0,1 A/D2 to 2.5 V
# Load micro:bit
from microbit import *
while True:
try:i2c.read(93,1)
except OSError:pass
else:
pin8.set_pull(pin8.PULL_UP);sleep(10)
i2c.write(93,b'\0c');sleep(10)
while True:
try:i2c.read(93,1)
except OSError:pass
else:break
break
class bot():
def __init__(self,p=0):
self.pin=p
def botdisable(self):
pin8.set_pull(pin8.NO_PULL)
sleep(200)
reset()
def send_c(self,c,p=33,s=0,d=None,f=None):
a=bytes([1,self.pin,p,s])
if d is not None:a+=(round(d)).to_bytes(4,'little')
if f is not None:a+=(round(f)).to_bytes(4,'little')
try:
i2c.write(93,a)
i2c.write(93,bytes([0,c]))
c=b'\x01'
while c!=b'\0':
i2c.write(93,b'\0')
c=i2c.read(93,1)
except:
self.botdisable()
def read_r(self):
try:
i2c.write(93,b'\x18')
r=i2c.read(93,4)
return int.from_bytes(r,'little')
except:
self.botdisable()
def write_digital(self,s):
if s>1 or s<0:s=4
elif s==0:s=2
self.send_c(s)
def write_analog(self,f):self.send_c(32,0,0,f)
def read_digital(self):
self.send_c(3)
return self.read_r()
def pitch(self,d,f):
self.send_c(13,0,0,d,f)
def version_info(self):
self.send_c(98)
return self.read_r()
class io():
def __init__(self,p=0):
self.pin=p
def states(self,p,s):
if p>self.pin:raise ValueError('start > end!')
elif self.pin-p>8:raise ValueError('> 8 pins!')
elif p==self.pin and s is None:return self.digitalRead()
elif p==self.pin:self.write_digital(s&1)
elif s is None:
bot(self.pin).send_c(8,p)
return bot().read_r()
else:bot(self.pin).send_c(7,p,s)
def directions(self,p,d):
if p>self.pin:raise ValueError('start > end!')
elif self.pin-p>8:raise ValueError('> 8 pins!')
elif d is None:
bot(self.pin).send_c(6,p)
return bot().read_r()
else:bot(self.pin).send_c(5,p,d)
def fail(code):
bot(25).write_digital(1)
display.show(code)
x = 0
while True:
x = x + 1
n = bot().version_info()
if n != 10002:fail(1)
display.off()
ad4 = pin4.read_analog()
display.on()
v = ad4 * (3.3 - 0.090) / 1024
v = v * (64.9 / 10.0)
# print("v = %f" % v)
if v < 6.0 or v > 15.0:fail(2)
bot(20).write_analog(102);
sleep(10)
ad = pin0.read_analog()
if ad < 30 or ad > 162:fail(3)
bot(20).write_analog(900);
sleep(10)
ad = pin0.read_analog()
if ad < 830 or ad > 960:fail(4)
bot(21).write_analog(102);
sleep(10)
ad = pin1.read_analog()
if ad < 30 or ad > 162:fail(5)
bot(21).write_analog(900);
sleep(10)
ad = pin1.read_analog()
if ad < 830 or ad > 960:fail(6)
ad = pin2.read_analog()
if ad < 700 or ad > 850:fail(7)
io(7).directions(0, 0)
io(15).states(8, 170)
io(15).directions(8, 255)
x = io(7).states(0, None)
if x != 170:fail(8)
io(15).directions(8, 0)
io(7).states(0, 85)
io(7).directions(0, 255)
x = io(15).states(8, None)
if x != 85:fail(9)
io(19).directions(18, 0)
io(17).states(16, 2)
io(17).directions(16, 3)
x = io(19).states(18, None)
if x != 2:fail(10)
io(17).directions(16, 0)
io(19).states(18, 1)
io(19).directions(18, 3)
x = io(17).states(16, None)
if x != 1:fail(11)
f = 500
while True:
bot(20).write_digital(1)
bot(22)f, 100)
sleep(200)
bot(20).write_digital(0)
bot(21).write_digital(1)
sleep(300)
bot(21).write_digital(0)
f = f + 500
if f > 3000: f = 500
|
StarcoderdataPython
|
4820407
|
import threading
import time
from datetime import datetime
import math
import random
class Car:
def __init__(self, hz, id, name, request):
self.id = id
self.diff_seconds = 1.0 / hz
self.hz = hz
self.last_tick = datetime.now()
self.request = request
self.x = 0
self.name = name
self.amplitude = 1
self.diff_seconds_speed = 1.0 / 1.0
self.last_speed_tick = datetime.now()
# 1 - 50
self.diff_seconds_accel = 1.0 / 2.0
self.last_accel_tick = datetime.now()
self.diff_seconds_temperature = 1.0 / 0.5
self.last_temperature_tick = datetime.now()
# 41 - 250
self.diff_seconds_engine_speed = 1.0 / 2.0
self.last_engine_speed_tick = datetime.now()
# 0 - 6
# speed -> 1hz
# accel -> 2hz
# engine temperature -> 0.5hz
# engine speed -> 2hz
def tick(self):
now = datetime.now()
if (now - self.last_speed_tick).total_seconds() > self.diff_seconds_speed:
self.last_speed_tick = now
self.request.request(self.id, self.name, "speed", str({"value": random.randrange(1, 50)}))
if (now - self.last_accel_tick).total_seconds() > self.diff_seconds_accel:
self.x += 0.1
self.last_accel_tick = now
value = self.amplitude * math.sin(self.x)
self.request.request(self.id, self.name, "accel", str({"x": value, "y": value, "z": value}))
if (now - self.last_temperature_tick).total_seconds() > self.diff_seconds_temperature:
self.last_temperature_tick = now
self.request.request(self.id, self.name, "temperature", str({"value": random.randrange(41, 250)}))
if (now - self.last_engine_speed_tick).total_seconds() > self.diff_seconds_engine_speed:
self.last_engine_speed_tick = now
self.request.request(self.id, self.name, "engine", str({"rpm": random.randrange(1, 3)}))
class CarGenerator(threading.Thread):
def __init__(self, cars, request):
threading.Thread.__init__(self)
self.cars = [Car(car["hz"], car["id"], car["name"], request) for car in cars]
self._stop_event = threading.Event()
self.thread = None
def run(self):
while True:
if self._stopped():
return
for car in self.cars:
car.tick()
time.sleep(0.001)
def stop(self):
self._stop_event.set()
def _stopped(self):
return self._stop_event.is_set()
|
StarcoderdataPython
|
4816814
|
import logging
_LINE_FORMATS = {
'classic': '%(asctime)s %(levelname)-8s [%(name)s] %(message)s',
'short': '%(asctime)s %(levelname) [%(name)s] %(message)s',
'no_time': '%(levelname)-8s [%(name)s] %(message)s',
}
_DT_FORMATS = {
'classic': '%Y-%m-%d %H:%M:%S',
'time_first': '%H:%M:%S %Y-%m-%d',
'short': '%y-%m-%d %H:%M:%S',
'time_only': '%H:%M:%S',
'no_date': '%H:%M:%S',
}
_LOG_LEVELS = {
'critical': logging.CRITICAL,
'fatal': logging.FATAL,
'error': logging.ERROR,
'warning': logging.WARNING,
'info': logging.INFO,
'debug': logging.DEBUG,
}
def _get_file_handler(log_file_path, log_level='info', line_format='classic', dt_format='classic'):
"""Tworzy uchwyt loggera do pliku.
Args:
log_file_path (str): ścieżka do pliku
log_level (str): poziom logowania, domyślnie "info"
line_formatter (str): format logowanej linii, domyślnie "classic"
dt_formatter (str): format logowanej daty, domyślnie "classic"
Returns:
logging.FileHandler: uchwyt loggera do pliku
"""
try:
log_level = _LOG_LEVELS[log_level]
except KeyError:
raise ValueError('nie ma poziomu logowania "{}"'.format(log_level))
try:
line_format = _LINE_FORMATS[line_format]
except KeyError:
raise ValueError('nie ma formatu "{}"'.format(line_format))
try:
dt_format = _DT_FORMATS[dt_format]
except KeyError:
raise ValueError('nie ma formatu daty "{}"'.format(dt_format))
file_handler = logging.FileHandler(log_file_path)
file_handler.setLevel(log_level)
fmt = logging.Formatter(line_format)
fmt.datefmt = dt_format
file_handler.setFormatter(fmt)
return file_handler
def _get_console_handler(log_level='debug', line_format='classic', dt_format='classic'):
"""Tworzy uchwyt loggera do konsoli.
Args:
log_level (str, optional): poziom logowania, domyślnie "debug"
line_formatter (str, optional): format logowanej linii, domyślnie "classic"
dt_formatter (str, optional): format logowanej daty, domyślnie "classic"
Returns:
logging.StreamHandler: uchwyt loggera do konsoli
Raises:
ValueError: jeśli log_level, formatter lub dt_formatter nie istnieje
"""
try:
log_level = _LOG_LEVELS[log_level]
except KeyError:
raise ValueError('nie ma poziomu logowania "{}"'.format(log_level))
try:
line_format = _LINE_FORMATS[line_format]
except KeyError:
raise ValueError('nie ma formatu "{}"'.format(line_format))
try:
dt_format = _DT_FORMATS[dt_format]
except KeyError:
raise ValueError('nie ma formatu daty "{}"'.format(dt_format))
console_handler = logging.StreamHandler()
console_handler.setLevel(log_level)
fmt = logging.Formatter(line_format)
fmt.datefmt = dt_format
console_handler.setFormatter(fmt)
return console_handler
def add_file_handler(logger_name, file_path, log_level='info', line_format='classic', dt_format='classic'):
"""Dodaje do loggera o podanej nazwie uchwyt do pliku o podanych parametrach.
Args:
logger_name (str): nazwa loggera
file_path (str): ścieżka do pliku logów
log_level (str, optional): poziom logowania, domyślnie "info"
line_formatter (str, optional): format logowanej linii, domyślnie "classic"
dt_formatter (str, optional): format logowanej daty, domyślnie "classic"
Raises:
ValueError: jeśli nie ma loggera o podanej nazwie lub parametr słownikowy jest niepoprawny
"""
try:
logger = logging.Logger.manager.loggerDict[logger_name]
except KeyError:
raise ValueError('logger o nazwie {} nie istnieje'.format(logger_name))
try:
log_level = _LOG_LEVELS[log_level]
except KeyError:
raise ValueError('nie ma poziomu logowania "{}"'.format(log_level))
try:
line_format = _LINE_FORMATS[line_format]
except KeyError:
raise ValueError('nie ma formatu "{}"'.format(line_format))
try:
dt_format = _DT_FORMATS[dt_format]
except KeyError:
raise ValueError('nie ma formatu daty "{}"'.format(dt_format))
file_handler = logging.FileHandler(file_path)
file_handler.setLevel(log_level)
fmt = logging.Formatter(line_format)
fmt.datefmt = dt_format
file_handler.setFormatter(fmt)
logger.addHandler(file_handler)
def add_console_handler(logger_name, log_level='debug', line_format='classic', dt_format='classic'):
"""Dodaje do loggera o podanej nazwie uchwyt do konsoli o podanych parametrach.
Args:
logger_name (str): nazwa loggera
log_level (str, optional): poziom logowania, domyślnie "debug"
line_formatter (str, optional): format logowanej linii, domyślnie "classic"
dt_formatter (str, optional): format logowanej daty, domyślnie "classic"
Raises:
ValueError: jeśli nie ma loggera o podanej nazwie lub parametr słownikowy jest niepoprawny
"""
try:
logger = logging.Logger.manager.loggerDict[logger_name]
except KeyError:
raise KeyError('logger o nazwie {} nie istnieje'.format(logger_name))
try:
log_level = _LOG_LEVELS[log_level]
except KeyError:
raise ValueError('nie ma poziomu logowania "{}"'.format(log_level))
try:
line_format = _LINE_FORMATS[line_format]
except KeyError:
raise ValueError('nie ma formatu "{}"'.format(line_format))
try:
dt_format = _DT_FORMATS[dt_format]
except KeyError:
raise ValueError('nie ma formatu daty "{}"'.format(dt_format))
console_handler = logging.StreamHandler()
console_handler.setLevel(log_level)
fmt = logging.Formatter(line_format)
fmt.datefmt = dt_format
console_handler.setFormatter(fmt)
logger.addHandler(console_handler)
def clear_handlers(logger_name):
"""Czyści uchwyty (handlery) w loggerze o podanej nazwie.
Args:
logger_name (str): nazwa loggera, w którym mają być wyczyszczone uchwyty (handlery)
Raises:
ValueError: jeśli logger o podanej nazwie nie istnieje
"""
try:
for h in logging.Logger.manager.loggerDict[logger_name].handlers:
if isinstance(h, logging.FileHandler):
h.flush()
h.close()
logging.Logger.manager.loggerDict[logger_name].handlers = []
except KeyError:
raise ValueError('logger "{}" nie istnieje'.format(logger_name))
def create_logger(logger_name):
"""Tworzy logger o podanej nazwie (jeśli nie istnieje).
Args:
logger_name (str): nazwa loggera
Returns:
logging.Logger: utworzony logger
"""
logger = logging.getLogger(logger_name)
logger.setLevel(logging.DEBUG)
return logger
def get_logger(logger_name, ch_params=None, fh_params=None):
"""Pobiera logger. Jeśli logger o podanej nazwie już istnieje, to zwraca istniejący.
Args:
logger_name (str): nazwa loggera
ch_params (dict): słownik z parametrami console handlera
fh_params (dict): słownik z parametrami file handlera
Returns:
logging.Logger: obiekt loggera
Raises:
KeyError: jeśli nie podano ścieżki do pliku logów
"""
if logger_name in logging.Logger.manager.loggerDict:
return logging.Logger.manager.loggerDict[logger_name]
logger = create_logger(logger_name)
if ch_params is not None:
add_console_handler(logger_name,
log_level=ch_params.get('log_level', 'debug'),
line_format=ch_params.get('line_format', 'classic'),
dt_format=ch_params.get('dt_format', 'classic'))
if fh_params is not None:
try:
add_file_handler(logger_name, fh_params['file_path'],
log_level=fh_params.get('log_level', 'info'),
line_format=fh_params.get('line_format', 'classic'),
dt_format=fh_params.get('dt_format', 'classic'))
except KeyError:
raise KeyError('nie podano ścieżki do pliku logów')
return logger
|
StarcoderdataPython
|
193062
|
<filename>tests/runtest.py<gh_stars>10-100
# eventpy library
# Copyright (C) 2020 <NAME> (wqking)
# Github: https://github.com/wqking/eventpy
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import sys
sys.path.append('../')
from internal import test_linkedlist
import tutorial_callbacklist
import tutorial_eventdispatcher
import tutorial_eventqueue
import test_callbacklist_basic
import test_callbacklist_multithread
import test_eventdispatcher_basic
import test_eventdispatcher_multithread
import test_eventqueue_basic
import test_eventqueue_multithread
def doTest() :
tutorial_callbacklist.test_tutorial_1_basic()
tutorial_callbacklist.test_tutorial_2_callbackWithParameters()
tutorial_callbacklist.test_tutorial_3_remove()
tutorial_callbacklist.test_tutorial_4_forEach()
tutorial_eventdispatcher.test_tutorial_1_basic()
tutorial_eventdispatcher.test_tutorial_2_listenerWithParameters()
tutorial_eventdispatcher.test_tutorial_3_customizedEventClass()
tutorial_eventdispatcher.test_tutorial_4_eventCanceling()
tutorial_eventqueue.test_tutorial_1_basic()
tutorial_eventqueue.test_tutorial_2_multipleThreading()
test_linkedlist.test_empty()
test_linkedlist.test_append()
test_linkedlist.test_prepend()
test_linkedlist.test_insert()
test_callbacklist_basic.test_noParams()
test_callbacklist_basic.test_hasParams()
test_callbacklist_basic.test_forEach()
test_callbacklist_basic.test_forEachIf()
test_callbacklist_basic.test_nestedCallbacks_newCallbacksShouldNotBeTriggered()
test_callbacklist_basic.test_removeInsideCallback()
test_callbacklist_multithread.test_append()
test_callbacklist_multithread.test_remove()
test_callbacklist_multithread.test_doubleRemove()
test_callbacklist_multithread.test_appendDoubleRemove()
test_callbacklist_multithread.test_insert()
test_eventdispatcher_basic.test_noParams1()
test_eventdispatcher_basic.test_noParams2()
test_eventdispatcher_basic.test_noParams3()
test_eventdispatcher_basic.test_hasParams()
test_eventdispatcher_basic.test_hasParams_includeEvent()
test_eventdispatcher_basic.test_forEach()
test_eventdispatcher_basic.test_forEachIf()
test_eventdispatcher_multithread.test_multiThreading()
test_eventqueue_basic.test_noParams1()
test_eventqueue_basic.test_hasParams()
test_eventqueue_basic.test_processOne()
test_eventqueue_basic.test_customizedEvent()
test_eventqueue_basic.test_clearEvents()
test_eventqueue_basic.test_processIf()
test_eventqueue_multithread.test_multiThreading()
test_eventqueue_multithread.test_oneThreadWaits()
test_eventqueue_multithread.test_manyThreadsWait()
if __name__ == "__main__":
doTest()
|
StarcoderdataPython
|
1653709
|
"""Added line item table
Revision ID: 20e5ee0480f6
Revises: 2<PASSWORD>
Create Date: 2015-05-12 13:48:39.460366
"""
# revision identifiers, used by Alembic.
revision = '20e5ee0480f6'
down_revision = '2<PASSWORD>'
from alembic import op
import sqlalchemy as sa
def upgrade():
### commands auto generated by Alembic - please adjust! ###
op.create_table('line_item',
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('contract_id', sa.Integer(), nullable=False),
sa.Column('description', sa.Text(), nullable=False),
sa.Column('manufacturer', sa.Text(), nullable=True),
sa.Column('model_number', sa.Text(), nullable=True),
sa.Column('quantity', sa.Integer(), nullable=True),
sa.Column('unit_of_measure', sa.String(length=255), nullable=True),
sa.Column('unit_cost', sa.Float(), nullable=True),
sa.Column('total_cost', sa.Float(), nullable=True),
sa.ForeignKeyConstraint(['contract_id'], ['contract.id'], ondelete='CASCADE'),
sa.PrimaryKeyConstraint('id')
)
### end Alembic commands ###
def downgrade():
### commands auto generated by Alembic - please adjust! ###
op.drop_table('line_item')
### end Alembic commands ###
|
StarcoderdataPython
|
24305
|
<gh_stars>0
{'application':{'type':'Application',
'name':'codeEditor',
'backgrounds': [
{'type':'Background',
'name':'bgCodeEditor',
'title':'Code Editor R PythonCard Application',
'size':(400, 300),
'statusBar':1,
'visible':0,
'style':['resizeable'],
'visible':0,
'menubar': {'type':'MenuBar',
'menus': [
{'type':'Menu',
'name':'menuFile',
'label':'&File',
'items': [
{'type':'MenuItem',
'name':'menuFileNewWindow',
'label':'New Window',
},
{'type':'MenuItem',
'name':'menuFileNew',
'label':'&New\tCtrl+N',
},
{'type':'MenuItem',
'name':'menuFileOpen',
'label':'&Open\tCtrl+O',
},
{'type':'MenuItem',
'name':'menuFileSave',
'label':'&Save\tCtrl+S',
},
{'type':'MenuItem',
'name':'menuFileSaveAs',
'label':'Save &As...',
},
{'type':'MenuItem',
'name':'fileSep1',
'label':'-',
},
{'type':'MenuItem',
'name':'menuFileCheckSyntax',
'label':'&Check Syntax (Module)\tAlt+F5',
'command':'checkSyntax',
},
{'type':'MenuItem',
'name':'menuFileRun',
'label':'&Run\tCtrl+R',
'command':'fileRun',
},
{'type':'MenuItem',
'name':'menuFileRunWithInterpreter',
'label':'Run with &interpreter\tCtrl+Shift+R',
'command':'fileRunWithInterpreter',
},
{'type':'MenuItem',
'name':'menuFileRunOptions',
'label':'Run Options...',
'command':'fileRunOptions',
},
{'type':'MenuItem',
'name':'fileSep2',
'label':'-',
},
{'type':'MenuItem',
'name':'menuFilePageSetup',
'label':'Page Set&up...',
},
{'type':'MenuItem',
'name':'menuFilePrint',
'label':'&Print...\tCtrl+P',
},
{'type':'MenuItem',
'name':'menuFilePrintPreview',
'label':'Print Pre&view',
},
{'type':'MenuItem',
'name':'fileSep2',
'label':'-',
},
{'type':'MenuItem',
'name':'menuFileExit',
'label':'E&xit\tAlt+X',
'command':'exit',
},
]
},
{'type':'Menu',
'name':'Edit',
'label':'&Edit',
'items': [
{'type':'MenuItem',
'name':'menuEditUndo',
'label':'&Undo\tCtrl+Z',
},
{'type':'MenuItem',
'name':'menuEditRedo',
'label':'&Redo\tCtrl+Y',
},
{'type':'MenuItem',
'name':'editSep1',
'label':'-',
},
{'type':'MenuItem',
'name':'menuEditCut',
'label':'Cu&t\tCtrl+X',
},
{'type':'MenuItem',
'name':'menuEditCopy',
'label':'&Copy\tCtrl+C',
},
{'type':'MenuItem',
'name':'menuEditPaste',
'label':'&Paste\tCtrl+V',
},
{'type':'MenuItem',
'name':'editSep2',
'label':'-',
},
{'type':'MenuItem',
'name':'menuEditFind',
'label':'&Find...\tCtrl+F',
'command':'doEditFind',
},
{'type':'MenuItem',
'name':'menuEditFindNext',
'label':'&Find Next\tF3',
'command':'doEditFindNext',
},
{'type':'MenuItem',
'name':'menuEditFindFiles',
'label':'Find in Files...\tAlt+F3',
'command':'findFiles',
},
{'type':'MenuItem',
'name':'menuEditReplace',
'label':'&Replace...\tCtrl+H',
'command':'doEditFindReplace',
},
{'type':'MenuItem',
'name':'menuEditGoTo',
'label':'&Go To...\tCtrl+G',
'command':'doEditGoTo',
},
{'type':'MenuItem',
'name':'editSep3',
'label':'-',
},
{'type':'MenuItem',
'name':'menuEditReplaceTabs',
'label':'&Replace tabs with spaces',
'command':'doEditReplaceTabs',
},
{'type':'MenuItem',
'name':'editSep3',
'label':'-',
},
{'type':'MenuItem',
'name':'menuEditClear',
'label':'Cle&ar\tDel',
},
{'type':'MenuItem',
'name':'menuEditSelectAll',
'label':'Select A&ll\tCtrl+A',
},
{'type':'MenuItem',
'name':'editSep4',
'label':'-',
},
{'type':'MenuItem',
'name':'menuEditIndentRegion',
'label':'&Indent Region',
'command':'indentRegion',
},
{'type':'MenuItem',
'name':'menuEditDedentRegion',
'label':'&Dedent Region',
'command':'dedentRegion',
},
{'type':'MenuItem',
'name':'menuEditCommentRegion',
'label':'Comment &out region\tAlt+3',
'command':'commentRegion',
},
{'type':'MenuItem',
'name':'menuEditUncommentRegion',
'label':'U&ncomment region\tShift+Alt+3',
'command':'uncommentRegion',
},
]
},
{'type':'Menu',
'name':'menuView',
'label':'&View',
'items': [
{'type':'MenuItem',
'name':'menuViewWhitespace',
'label':'&Whitespace',
'checkable':1,
},
{'type':'MenuItem',
'name':'menuViewIndentationGuides',
'label':'Indentation &guides',
'checkable':1,
},
{'type':'MenuItem',
'name':'menuViewRightEdgeIndicator',
'label':'&Right edge indicator',
'checkable':1,
},
{'type':'MenuItem',
'name':'menuViewEndOfLineMarkers',
'label':'&End-of-line markers',
'checkable':1,
},
{'type':'MenuItem',
'name':'menuViewFixedFont',
'label':'&Fixed Font',
'enabled':0,
'checkable':1,
},
{'type':'MenuItem',
'name':'viewSep1',
'label':'-',
},
{'type':'MenuItem',
'name':'menuViewLineNumbers',
'label':'&Line Numbers',
'checkable':1,
'checked':1,
},
{'type':'MenuItem',
'name':'menuViewCodeFolding',
'label':'&Code Folding',
'checkable':1,
'checked':0,
},
]
},
{'type':'Menu',
'name':'menuFormat',
'label':'F&ormat',
'items': [
{'type':'MenuItem',
'name':'menuFormatStyles',
'label':'&Styles...',
'command':'doSetStyles',
},
{'type':'MenuItem',
'name':'menuFormatWrap',
'label':'&Wrap Lines',
'checkable':1,
},
]
},
{'type':'Menu',
'name':'menuScriptlet',
'label':'&Shell',
'items': [
{'type':'MenuItem',
'name':'menuScriptletShell',
'label':'&Shell Window\tF5',
},
{'type':'MenuItem',
'name':'menuScriptletNamespace',
'label':'&Namespace Window\tF6',
},
{'type':'MenuItem',
'name':'scriptletSep1',
'label':'-',
},
{'type':'MenuItem',
'name':'menuScriptletSaveShellSelection',
'label':'Save Shell Selection...',
},
{'type':'MenuItem',
'name':'menuScriptletRunScriptlet',
'label':'Run Scriptlet...',
},
]
},
{'type':'Menu',
'name':'menuHelp',
'label':'&Help',
'items': [
{'type':'MenuItem',
'name':'menuShellDocumentation',
'label':'&Shell Documentation...',
'command':'showShellDocumentation',
},
{'type':'MenuItem',
'name':'menuPythonCardDocumentation',
'label':'&PythonCard Documentation...\tF1',
'command':'showPythonCardDocumentation',
},
{'type':'MenuItem',
'name':'menuPythonDocumentation',
'label':'Python &Documentation...',
'command':'showPythonDocumentation',
},
{'type':'MenuItem',
'name':'helpSep1',
'label':'-',
},
{'type':'MenuItem',
'name':'menuHelpAbout',
'label':'&About codeEditor...',
'command':'doHelpAbout',
},
]
},
]
},
'strings': {
'saveAs':'Save As',
'about':'About codeEditor...',
'saveAsWildcard':'All files (*.*)|*.*|Python scripts (*.py;*.pyw)|*.pyw;*.PY;*.PYW;*.py|Text files (*.txt;*.text)|*.text;*.TXT;*.TEXT;*.txt|HTML and XML files (*.htm;*.html;*.xml)|*.htm;*.xml;*.HTM;*.HTML;*.XML;*.html',
'chars':'chars',
'gotoLine':'Goto line',
'lines':'lines',
'gotoLineNumber':'Goto line number:',
'documentChangedPrompt':'The text in the %s file has changed.\n\nDo you want to save the changes?',
'untitled':'Untitled',
'sample':'codeEditor sample',
'codeEditor':'codeEditor',
'replaced':'Replaced %d occurances',
'words':'words',
'openFile':'Open file',
'scriptletWildcard':'Python files (*.py)|*.py|All Files (*.*)|*.*',
'document':'Document',
},
'components': [
{'type':'Choice',
'name':'popComponentNames',
},
{'type':'Choice',
'name':'popComponentEvents',
},
{'type':'CodeEditor',
'name':'document',
'position':(0, 0),
'size':(250, 100),
},
] # end components
} # end background
] # end backgrounds
} }
|
StarcoderdataPython
|
3233682
|
import discord
from discord.ext import commands
from util import config
class Help(commands.Cog):
prefix = config['PREFIX']
ops = config['BOT_OPS']
# help commands
@commands.group(invoke_without_command=True)
async def help(self, ctx):
em = discord.Embed(title='Hugmaker Help', description=f'Use {self.prefix}help `command` for more information about specific commands, replacing `command` with the name of a command below.', color=ctx.author.color)
em.add_field(name='Emote commands', value='gaysper, hug, make')
em.add_field(name='Bot info', value='about, flag, flags')
em.add_field(name='Operator commands', value='echo, stat')
await ctx.send(embed=em)
# BOT INFO COMMANDS
@help.command()
async def about(self, ctx):
em = discord.Embed(title='Command: About', description='Sends information about the bot')
em.add_field(name='Syntax', value=f'{self.prefix}about')
await ctx.send(embed=em)
@help.command()
async def flag(self, ctx):
em = discord.Embed(title='Command: Flag', description='Sends more information about a specific pride flag')
em.add_field(name='Syntax', value=f'{self.prefix}flag `name`')
em.add_field(name='Parameters', value=f'`name` should be replaced by the name of a pride flag.')
await ctx.send(embed=em)
@help.command()
async def flags(self, ctx):
em = discord.Embed(title='Command: Flags', description='Sends a list of pride flags supported by the bot')
em.add_field(name='Syntax', value=f'{self.prefix}flags')
await ctx.send(embed=em)
# EMOTE COMMANDS
@help.command()
async def gaysper(self, ctx):
em = discord.Embed(title='Command: Flag', description='Sends a pride flag Gaysper (ghost) emote')
em.add_field(name='Syntax', value=f'{self.prefix}gaysper `body` `[outline]`')
em.add_field(name='Parameters', value=f'`body` should be replaced by the name of a pride flag. Optionally, `[outline]` can also be replaced with the name of a pride flag. *(Run `{self.prefix}flags` for a full list.)*')
await ctx.send(embed=em)
@help.command()
async def hug(self, ctx):
em = discord.Embed(title='Command: Hug', description='Sends a hug emote where the people are pride flags')
em.add_field(name='Syntax', value=f'{self.prefix}hug `left` `right`')
em.add_field(name='Parameters', value=f'`left` and `right` should be replaced by the names of pride flags. *(Run `{self.prefix}flags` for a full list.)*')
await ctx.send(embed=em)
@help.command()
async def make(self, ctx):
em = discord.Embed(title='Command: Make', description='Creates a pride flag emote from a specified emoji')
em.add_field(name='Syntax', value=f'{self.prefix}make `emoji` `flag` `[options]`')
em.add_field(name='Parameters', value=f'`emoji` should be replaced by an emoji character.\n`flag` should be replaced by the name of a pride flag. *(Run `{self.prefix}flags` for a full list.)*', inline=False)
em.add_field(
name='Options',
value='Replace `[options]` with any number of the following to modify the behavior of hugmaker\'s emoji generation:\n- `blur` to blur the flag\n- `inv` to generate an inverse version of the emoji',
inline=False
)
await ctx.send(embed=em)
# OPERATOR COMMANDS
# TODO: Add load, reload, unload
@help.command()
async def echo(self, ctx):
em = discord.Embed(title='Command: Echo', description='**[Operator only]** Echoes the string you pass in.')
em.add_field(name='Syntax', value=f'{self.prefix}echo `message`')
em.add_field(name='Parameters', value=f'`message` should be replaced by the message to echo. If it lasts multiple lines, use double quotes at the beginning and end of the message.', inline=False)
await ctx.send(embed=em)
@help.command()
async def stat(self, ctx):
em = discord.Embed(title='Command: Stat', description='**[Operator only]** Sets the bot\'s status')
em.add_field(name='Syntax', value=f'{self.prefix}stat `status`')
em.add_field(name='Parameters', value='`status` should be replaced by the new status. It will be set in the form "Listening to **`status`**".', inline=False)
await ctx.send(embed=em)
def setup(bot):
bot.add_cog(Help(bot))
|
StarcoderdataPython
|
4821921
|
<reponame>gonzalocasas/compas<gh_stars>0
from __future__ import print_function
from __future__ import absolute_import
from __future__ import division
import os
import ctypes
import compas
from compas.utilities import flatten
dll = os.path.join(compas.LIBS, "ShapeOp/bindings/python/_ShapeOp.0.1.0.dll")
shapeopPython = ctypes.cdll.LoadLibrary(dll)
__author__ = ['<NAME>', ]
__copyright__ = 'Copyright 2016 - Block Research Group, ETH Zurich'
__license__ = 'MIT License'
__email__ = '<EMAIL>'
__all__ = [
'int_array',
'float_array',
'ShapeOpSolver',
]
# replace this by interop.core functionality
def int_array(data):
try:
len(data[0])
except TypeError:
pass
else:
raise
array = (ctypes.c_int * len(data))()
for index, value in enumerate(data):
array[index] = int(value)
return array
# replace this by interop.core functionality
def float_array(data):
try:
len(data[0])
except TypeError:
pass
else:
data = list(flatten(data))
array = (ctypes.c_double * len(data))()
for index, value in enumerate(data):
array[index] = float(value)
return array
class ShapeOpSolver(object):
""""""
def __init__(self, kmax=100):
self.solver = shapeopPython.shapeop_create()
self.number_of_points = 0
self.points = 0
self.kmax = kmax
def init(self):
shapeopPython.shapeop_init(self.solver)
def delete(self):
shapeopPython.shapeop_delete(self.solver)
def solve(self):
self.init()
shapeopPython.shapeop_solve(self.solver, self.kmax)
def set_points(self, xyz):
self.number_of_points = len(xyz)
self.points = float_array(xyz)
shapeopPython.shapeop_setPoints(self.solver, ctypes.byref(self.points), self.number_of_points)
def get_points(self):
shapeopPython.shapeop_getPoints(self.solver, ctypes.byref(self.points), self.number_of_points)
return self.points
def add_plane_constraint(self, vertices, weight):
n = len(vertices)
vertices_array = int_array(vertices)
constraint_id = shapeopPython.shapeop_addConstraint(self.solver,
ctypes.c_char_p('Plane'),
ctypes.byref(vertices_array),
ctypes.c_int(n),
ctypes.c_double(weight))
return constraint_id
def add_closeness_constraint(self, vertex, weight):
n = 1
vertices_array = int_array([vertex])
constraint_id = shapeopPython.shapeop_addConstraint(self.solver,
ctypes.c_char_p('Closeness'),
ctypes.byref(vertices_array),
ctypes.c_int(n),
ctypes.c_double(weight))
return constraint_id
# ==============================================================================
# Main
# ==============================================================================
if __name__ == "__main__":
pass
|
StarcoderdataPython
|
4805940
|
<filename>official/docker_to_bash/docker_to_bash.py<gh_stars>0
import os,traceback,sys
class _Mode :
def __init__(self,tag_open,tag_close):
self._tag_open = tag_open
self._tag_close = tag_close
self._mode_on = False
def update(self,line,line_nb,end=False):
tag_open = (self._tag_open in line)
tag_close = (self._tag_close in line)
if tag_open and tag_close :
raise Exception("opening and closing tag on the same line is not supported, line "+str(line_nb))
if self._mode_on and tag_close:
self._mode_on = False
return
if (not self._mode_on) and tag_open:
self._mode_on = True
return
if self._mode_on and tag_open:
raise Exception("invalid tag opening: the tag was already open ( "+str(self._tag_open)+", line "+str(line_nb)+")")
if (not self._mode_on) and tag_close:
raise Exception("invalid tag closing: the tag was not open ( "+str(self._tag_close)+", line "+str(line_nb)+")")
if end and self._mode_on:
raise Exception("invalid tag: an opening tag ("+str(self._tag_open)+") has never been closed")
def get(self):
return self._mode_on
def convert_dockerfile_to_bash(dockerfile_path,destination_path,update_only):
with open(dockerfile_path,"r") as f: content = f.readlines()
script = ["#! /bin/bash\n\n"]
bash_ignore_mode = _Mode("[BASH IGNORE]","[/BASH IGNORE]")
if update_only:
update_mode = _Mode("[BASH UPDATE]","[/BASH UPDATE]")
for line_number,line in enumerate(content):
if line_number == (len(content)-1):
end = True
else:
end = False
line = line.strip()
bash_ignore_mode.update(line,line_number,end=end)
is_bash_ignore = bash_ignore_mode.get()
if update_only:
update_mode.update(line,line_number,end=end)
is_update = update_mode.get()
if not line.startswith("#"):
if not is_bash_ignore:
if line.startswith("RUN"):
line = line[4:]
if update_only:
if is_update:
script.append(line)
else :
script.append(line)
script_str = "\n".join(script)
with open(destination_path,"w+") as f :
f.write(script_str)
return
|
StarcoderdataPython
|
3369213
|
<filename>current/deps/v8/tools/testrunner/testproc/util.py<gh_stars>1000+
#!/usr/bin/env python
# Copyright 2020 the V8 project authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import heapq
import random
class FixedSizeTopList():
"""Utility collection for gathering a fixed number of elements with the
biggest value for the given key. It employs a heap from which we pop the
smallest element when the collection is 'full'.
If you need a reversed behaviour (collect min values) just provide an
inverse key."""
def __init__(self, size, key=None):
self.size = size
self.key = key or (lambda x: x)
self.data = []
self.discriminator = 0
def add(self, elem):
elem_k = self.key(elem)
heapq.heappush(self.data, (elem_k, self.extra_key(), elem))
if len(self.data) > self.size:
heapq.heappop(self.data)
def extra_key(self):
# Avoid key clash in tuples sent to the heap.
# We want to avoid comparisons on the last element of the tuple
# since those elements might not be comparable.
self.discriminator += 1
return self.discriminator
def as_list(self):
original_data = [rec for (_, _, rec) in self.data]
return sorted(original_data, key=self.key, reverse=True)
|
StarcoderdataPython
|
3358501
|
<gh_stars>0
# Copyright 1997 - 2018 by IXIA Keysight
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
from ixnetwork_restpy.base import Base
from ixnetwork_restpy.files import Files
class NetworkRangeInfo(Base):
"""The NetworkRangeInfo class encapsulates a user managed networkRangeInfo node in the ixnetwork hierarchy.
An instance of the class can be obtained by accessing the NetworkRangeInfo property from a parent instance.
The internal properties list will be empty when the property is accessed and is populated from the server using the find method.
The internal properties list can be managed by the user by using the add and remove methods.
"""
_SDM_NAME = 'networkRangeInfo'
def __init__(self, parent):
super(NetworkRangeInfo, self).__init__(parent)
@property
def CMacProperties(self):
"""An instance of the CMacProperties class.
Returns:
obj(ixnetwork_restpy.testplatform.sessions.ixnetwork.topology.cmacproperties.CMacProperties)
Raises:
NotFoundError: The requested resource does not exist on the server
ServerError: The server has encountered an uncategorized error condition
"""
from ixnetwork_restpy.testplatform.sessions.ixnetwork.topology.cmacproperties import CMacProperties
return CMacProperties(self)
@property
def EvpnIPv4PrefixRange(self):
"""An instance of the EvpnIPv4PrefixRange class.
Returns:
obj(ixnetwork_restpy.testplatform.sessions.ixnetwork.topology.evpnipv4prefixrange.EvpnIPv4PrefixRange)
Raises:
NotFoundError: The requested resource does not exist on the server
ServerError: The server has encountered an uncategorized error condition
"""
from ixnetwork_restpy.testplatform.sessions.ixnetwork.topology.evpnipv4prefixrange import EvpnIPv4PrefixRange
return EvpnIPv4PrefixRange(self)
@property
def EvpnIPv6PrefixRange(self):
"""An instance of the EvpnIPv6PrefixRange class.
Returns:
obj(ixnetwork_restpy.testplatform.sessions.ixnetwork.topology.evpnipv6prefixrange.EvpnIPv6PrefixRange)
Raises:
NotFoundError: The requested resource does not exist on the server
ServerError: The server has encountered an uncategorized error condition
"""
from ixnetwork_restpy.testplatform.sessions.ixnetwork.topology.evpnipv6prefixrange import EvpnIPv6PrefixRange
return EvpnIPv6PrefixRange(self)
@property
def Count(self):
"""Number of elements inside associated multiplier-scaled container object, e.g. number of devices inside a Device Group
Returns:
number
"""
return self._get_attribute('count')
@property
def DescriptiveName(self):
"""Longer, more descriptive name for element. It's not guaranteed to be unique like -name-, but maybe offers more context
Returns:
str
"""
return self._get_attribute('descriptiveName')
@property
def Name(self):
"""Name of NGPF element, guaranteed to be unique in Scenario
Returns:
str
"""
return self._get_attribute('name')
@Name.setter
def Name(self, value):
self._set_attribute('name', value)
@property
def NetworkRangeIPByMask(self):
"""Use mask to generate range of addresses
Returns:
obj(ixnetwork_restpy.multivalue.Multivalue)
"""
return self._get_attribute('networkRangeIPByMask')
@property
def NetworkRangeInterfaceIp(self):
"""Interface IP address for a non-connected interface
Returns:
obj(ixnetwork_restpy.multivalue.Multivalue)
"""
return self._get_attribute('networkRangeInterfaceIp')
@property
def NetworkRangeInterfaceIpMask(self):
"""Interface IP mask for a non-connected interface
Returns:
obj(ixnetwork_restpy.multivalue.Multivalue)
"""
return self._get_attribute('networkRangeInterfaceIpMask')
@property
def NetworkRangeIp(self):
"""Network Range IP
Returns:
obj(ixnetwork_restpy.multivalue.Multivalue)
"""
return self._get_attribute('networkRangeIp')
@property
def NetworkRangeIpIncrementBy(self):
"""Network Range IP Increment By
Returns:
obj(ixnetwork_restpy.multivalue.Multivalue)
"""
return self._get_attribute('networkRangeIpIncrementBy')
@property
def NetworkRangeIpMask(self):
"""Network Range IP Mask
Returns:
obj(ixnetwork_restpy.multivalue.Multivalue)
"""
return self._get_attribute('networkRangeIpMask')
@property
def NetworkRangeLinkType(self):
"""Link Type
Returns:
obj(ixnetwork_restpy.multivalue.Multivalue)
"""
return self._get_attribute('networkRangeLinkType')
@property
def NetworkRangeRID(self):
"""Network Range RID
Returns:
obj(ixnetwork_restpy.multivalue.Multivalue)
"""
return self._get_attribute('networkRangeRID')
@property
def NetworkRangeRIDIncrement(self):
"""Network Range RID Increment
Returns:
obj(ixnetwork_restpy.multivalue.Multivalue)
"""
return self._get_attribute('networkRangeRIDIncrement')
@property
def NumColumns(self):
"""4 Byte Integer.
Returns:
obj(ixnetwork_restpy.multivalue.Multivalue)
"""
return self._get_attribute('numColumns')
@property
def NumRows(self):
"""4 Byte Integer.
Returns:
obj(ixnetwork_restpy.multivalue.Multivalue)
"""
return self._get_attribute('numRows')
def add(self, Name=None):
"""Adds a new networkRangeInfo node on the server and retrieves it in this instance.
Args:
Name (str): Name of NGPF element, guaranteed to be unique in Scenario
Returns:
self: This instance with all currently retrieved networkRangeInfo data using find and the newly added networkRangeInfo data available through an iterator or index
Raises:
ServerError: The server has encountered an uncategorized error condition
"""
return self._create(locals())
def remove(self):
"""Deletes all the networkRangeInfo data in this instance from server.
Raises:
NotFoundError: The requested resource does not exist on the server
ServerError: The server has encountered an uncategorized error condition
"""
self._delete()
def find(self, Count=None, DescriptiveName=None, Name=None):
"""Finds and retrieves networkRangeInfo data from the server.
All named parameters support regex and can be used to selectively retrieve networkRangeInfo data from the server.
By default the find method takes no parameters and will retrieve all networkRangeInfo data from the server.
Args:
Count (number): Number of elements inside associated multiplier-scaled container object, e.g. number of devices inside a Device Group
DescriptiveName (str): Longer, more descriptive name for element. It's not guaranteed to be unique like -name-, but maybe offers more context
Name (str): Name of NGPF element, guaranteed to be unique in Scenario
Returns:
self: This instance with matching networkRangeInfo data retrieved from the server available through an iterator or index
Raises:
ServerError: The server has encountered an uncategorized error condition
"""
return self._select(locals())
def read(self, href):
"""Retrieves a single instance of networkRangeInfo data from the server.
Args:
href (str): An href to the instance to be retrieved
Returns:
self: This instance with the networkRangeInfo data from the server available through an iterator or index
Raises:
NotFoundError: The requested resource does not exist on the server
ServerError: The server has encountered an uncategorized error condition
"""
return self._read(href)
def get_device_ids(self, PortNames=None, NetworkRangeIPByMask=None, NetworkRangeInterfaceIp=None, NetworkRangeInterfaceIpMask=None, NetworkRangeIp=None, NetworkRangeIpIncrementBy=None, NetworkRangeIpMask=None, NetworkRangeLinkType=None, NetworkRangeRID=None, NetworkRangeRIDIncrement=None, NumColumns=None, NumRows=None):
"""Base class infrastructure that gets a list of networkRangeInfo device ids encapsulated by this object.
Use the optional regex parameters in the method to refine the list of device ids encapsulated by this object.
Args:
PortNames (str): optional regex of port names
NetworkRangeIPByMask (str): optional regex of networkRangeIPByMask
NetworkRangeInterfaceIp (str): optional regex of networkRangeInterfaceIp
NetworkRangeInterfaceIpMask (str): optional regex of networkRangeInterfaceIpMask
NetworkRangeIp (str): optional regex of networkRangeIp
NetworkRangeIpIncrementBy (str): optional regex of networkRangeIpIncrementBy
NetworkRangeIpMask (str): optional regex of networkRangeIpMask
NetworkRangeLinkType (str): optional regex of networkRangeLinkType
NetworkRangeRID (str): optional regex of networkRangeRID
NetworkRangeRIDIncrement (str): optional regex of networkRangeRIDIncrement
NumColumns (str): optional regex of numColumns
NumRows (str): optional regex of numRows
Returns:
list(int): A list of device ids that meets the regex criteria provided in the method parameters
Raises:
ServerError: The server has encountered an uncategorized error condition
"""
return self._get_ngpf_device_ids(locals())
def FetchAndUpdateConfigFromCloud(self, Mode):
"""Executes the fetchAndUpdateConfigFromCloud operation on the server.
Args:
Arg1 (str(None|/api/v1/sessions/1/ixnetwork/globals?deepchild=*|/api/v1/sessions/1/ixnetwork/topology?deepchild=*)): The method internally sets Arg1 to the current href for this instance
Mode (str):
Raises:
NotFoundError: The requested resource does not exist on the server
ServerError: The server has encountered an uncategorized error condition
"""
Arg1 = self.href
return self._execute('FetchAndUpdateConfigFromCloud', payload=locals(), response_object=None)
def Start(self):
"""Executes the start operation on the server.
Start CPF control plane (equals to promote to negotiated state).
Args:
Arg1 (list(str[None|/api/v1/sessions/1/ixnetwork/topology])): The method internally sets Arg1 to the encapsulated list of hrefs for this instance
Raises:
NotFoundError: The requested resource does not exist on the server
ServerError: The server has encountered an uncategorized error condition
"""
Arg1 = self
return self._execute('Start', payload=locals(), response_object=None)
def Stop(self):
"""Executes the stop operation on the server.
Stop CPF control plane (equals to demote to PreValidated-DoDDone state).
Args:
Arg1 (list(str[None|/api/v1/sessions/1/ixnetwork/topology])): The method internally sets Arg1 to the encapsulated list of hrefs for this instance
Raises:
NotFoundError: The requested resource does not exist on the server
ServerError: The server has encountered an uncategorized error condition
"""
Arg1 = self
return self._execute('Stop', payload=locals(), response_object=None)
|
StarcoderdataPython
|
144924
|
<filename>projects/src/main/python/CodeJam/Y13R5P1/JongMan/generated_py_623d5a5ed9124daf833506d5b6c57318.py
import sys
sys.path.append('/home/george2/Raise/ProgramRepair/CodeSeer/projects/src/main/python')
from CodeJam.Y13R5P1.JongMan.roulette2 import *
def func_b3607c87abf94237a6dc3992ce5b3f09(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
return partial
def func_af4aecab5b3b43698a7d87c2fc9612eb(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
return p
def func_1ef2d23a5b9742beb274b24a8661c68f(lowest_cnt):
if lowest_cnt == 0:
return 0
ret = 0.0
return ret
def func_1f456037a7f44e88abe43a7664d8dc38(lowest_cnt, lowest, only_mine):
ret = 0.0
ret += lowest * 36.0 * only_mine / float(lowest_cnt)
return ret
def func_f92bd295d2984f4d80cbf903837be8a2(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
return only_mine
def func_b4571d5f4f5e4f2291203ec3b53b1b57(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
return partial
def func_89207f0081b24f9c882a0fe8ff87e567(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
return p
def func_aa6ff703a869404ab5ccba8fb314dcdc(lowest_cnt, lowest, only_mine):
if lowest_cnt == 0:
return 0
ret = 0.0
ret += lowest * 36.0 * only_mine / float(lowest_cnt)
return ret
def func_05b034cd4596424aa9f727b25ae9799a(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
lowest_cnt = only_mine + len(partial)
return lowest_cnt
def func_ee77ce06116d4dbf8dcdf4271624d151(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
lowest_cnt = only_mine + len(partial)
return partial
def func_425d397183b445779a8913011fabce9d(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
lowest_cnt = only_mine + len(partial)
return only_mine
def func_d1b63fd727154d62a0e51091702505a1(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
lowest_cnt = only_mine + len(partial)
return p
def func_56650768666e4576b35c08ae0a8f3869(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
lowest_cnt = only_mine + len(partial)
if lowest_cnt == 0:
return 0
return p
def func_5ad99e5dabca410e8c85829604e3b7c3(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
lowest_cnt = only_mine + len(partial)
if lowest_cnt == 0:
return 0
return only_mine
def func_cd60b6989fa34950b4f881aa607c9ec1(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
lowest_cnt = only_mine + len(partial)
if lowest_cnt == 0:
return 0
return partial
def func_cc50f64d990a4d2c9d17839f0df99e5c(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
lowest_cnt = only_mine + len(partial)
if lowest_cnt == 0:
return 0
return lowest_cnt
def func_cace8cb98f8a477ca8abb3e96100f1ed(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
lowest_cnt = only_mine + len(partial)
if lowest_cnt == 0:
return 0
ret = 0.0
return only_mine
def func_9d1a53f5eae243e3a8a282b0e61e67b1(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
lowest_cnt = only_mine + len(partial)
if lowest_cnt == 0:
return 0
ret = 0.0
return ret
def func_a67fb82fe9964d89bbcfd06cc1ffd4fc(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
lowest_cnt = only_mine + len(partial)
if lowest_cnt == 0:
return 0
ret = 0.0
return p
def func_8d71ceedbe7e4d099e7ac25c72a969cf(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
lowest_cnt = only_mine + len(partial)
if lowest_cnt == 0:
return 0
ret = 0.0
return lowest_cnt
def func_debb2352e83b4aa3ba817d1a93fed623(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
lowest_cnt = only_mine + len(partial)
if lowest_cnt == 0:
return 0
ret = 0.0
return partial
def func_f3c397f88f4647b5bdd387cf7f939f7f(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
lowest_cnt = only_mine + len(partial)
if lowest_cnt == 0:
return 0
ret = 0.0
ret += lowest * 36.0 * only_mine / float(lowest_cnt)
return lowest_cnt
def func_4e416694a021440aae7bd0243ccc6343(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
lowest_cnt = only_mine + len(partial)
if lowest_cnt == 0:
return 0
ret = 0.0
ret += lowest * 36.0 * only_mine / float(lowest_cnt)
return only_mine
def func_9bea198fe2ef47838825c59464b01660(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
lowest_cnt = only_mine + len(partial)
if lowest_cnt == 0:
return 0
ret = 0.0
ret += lowest * 36.0 * only_mine / float(lowest_cnt)
return partial
def func_8ca5932e47da4ec395984bc0243ac390(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
lowest_cnt = only_mine + len(partial)
if lowest_cnt == 0:
return 0
ret = 0.0
ret += lowest * 36.0 * only_mine / float(lowest_cnt)
return ret
def func_0a833f94d5dc457ab03800aecff043da(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
lowest_cnt = only_mine + len(partial)
if lowest_cnt == 0:
return 0
ret = 0.0
ret += lowest * 36.0 * only_mine / float(lowest_cnt)
return p
def func_b5023ac8c4654db2b4c81f5440079cf4(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
lowest_cnt = only_mine + len(partial)
if lowest_cnt == 0:
return 0
ret = 0.0
ret += lowest * 36.0 * only_mine / float(lowest_cnt)
for p in partial:
ret += 36.0 * (lowest - p) * 1.0 / lowest_cnt
return only_mine
def func_93fb4b4a66cf4947801fa25a5f3905ad(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
lowest_cnt = only_mine + len(partial)
if lowest_cnt == 0:
return 0
ret = 0.0
ret += lowest * 36.0 * only_mine / float(lowest_cnt)
for p in partial:
ret += 36.0 * (lowest - p) * 1.0 / lowest_cnt
return partial
def func_2054f2fcfa7e41dbb4a8573d899868ef(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
lowest_cnt = only_mine + len(partial)
if lowest_cnt == 0:
return 0
ret = 0.0
ret += lowest * 36.0 * only_mine / float(lowest_cnt)
for p in partial:
ret += 36.0 * (lowest - p) * 1.0 / lowest_cnt
return ret
def func_16fc15362ae44de382a7cf8b6300aaf0(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
lowest_cnt = only_mine + len(partial)
if lowest_cnt == 0:
return 0
ret = 0.0
ret += lowest * 36.0 * only_mine / float(lowest_cnt)
for p in partial:
ret += 36.0 * (lowest - p) * 1.0 / lowest_cnt
return p
def func_313ca3bbd50b4776b8e1cdd5a4237c60(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
lowest_cnt = only_mine + len(partial)
if lowest_cnt == 0:
return 0
ret = 0.0
ret += lowest * 36.0 * only_mine / float(lowest_cnt)
for p in partial:
ret += 36.0 * (lowest - p) * 1.0 / lowest_cnt
return lowest_cnt
def func_8ccb6be215f946c096f353ecc7e1f8ad(lowest, placed, override):
partial = [p for p in placed if p <= lowest]
if override > 0:
partial = partial[:-override]
only_mine = 37 - len(placed)
lowest_cnt = only_mine + len(partial)
if lowest_cnt == 0:
return 0
ret = 0.0
ret += lowest * 36.0 * only_mine / float(lowest_cnt)
for p in partial:
ret += 36.0 * (lowest - p) * 1.0 / lowest_cnt
return ret
def func_e1a520bf58c74b5f95fd5e1fb9835983(lowest_cnt, lowest,
remaining_budget, can_replicate, larger):
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget / lowest_cnt
)
return next_larger
def func_717b5659538b41bd88c3ece95f35a098(lowest, placed, exclude,
needed_budget):
cand = get_expected(placed, lowest, exclude) - exclude - needed_budget
ret = max(ret, cand)
return ret
def func_53abe815e79f40a1b75b6da20024e6e1(lowest, placed, exclude,
needed_budget):
cand = get_expected(placed, lowest, exclude) - exclude - needed_budget
ret = max(ret, cand)
return cand
def func_0a79f5bb24484ca39aec13faa8111d46(lowest, placed):
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
return needed_budget
def func_ab9640aa475841d6891a8dee2b2ca9c4(lowest, placed):
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
return p
def func_586c631fab234f4abee0ae2b83a97524(lowest, budget, placed, needed_budget
):
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
return p
def func_4c057f6f577c4d45b063e72434a1a8b9(lowest, budget, placed, needed_budget
):
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
return remaining_budget
def func_f786d824fa0743ab91f810f4b5b2ecc6(lowest, budget, placed, needed_budget
):
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
return partial
def func_239cff9d8f2a4c149f4bee34d2a26c66(lowest, placed):
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
return partial
def func_1faf349b06954d568194f1b2fdc2a331(lowest, placed):
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
return p
def func_9e543731501f45b7a9f7111e08dc6fee(lowest, placed):
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
return lowest_cnt
def func_a10e776df323436c80bf480b9fc7a7ca(lowest_cnt, lowest,
remaining_budget, can_replicate, placed):
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
return larger
def func_6d48a285cace454baa0cbf40e34a8ace(lowest_cnt, lowest,
remaining_budget, can_replicate, placed):
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
return next_larger
def func_faa8e882935c4474ab27832a082ddeb4(lowest_cnt, lowest,
remaining_budget, can_replicate, placed):
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
return p
def func_0ccd2127f2214a5caa91cd8829a4d56d(lowest, budget, placed, needed_budget
):
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
return p
def func_823ff6d2a5a745c2b4d5c99dca6bf1f8(lowest, budget, placed, needed_budget
):
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
return lowest_cnt
def func_d61fa8489acc46ac8c5a3d2490865ffb(lowest, budget, placed, needed_budget
):
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
return remaining_budget
def func_365835b6f7484ef28c09afbc58638e15(lowest, budget, placed, needed_budget
):
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
return partial
def func_6875a669551a4eba80d27edaf9ab29da(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
return budget
def func_083d5dfe2aed4a6f8e8cc78f4922fe2a(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
return bets
def func_e4af148c84f94b669df248bb3bfc5a36(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
return placed
def func_37511302e85e4608a016bf88c5d04943(infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
return placed
def func_a629d90826ed496883b5466c5eb53a3f(infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
return ret
def func_83b242b2d1fa4e4fa7bca9942c560ab2(placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
return queue
def func_4b8e3f3803e8494aa0b4c9d0dcdae0a8(placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
return ret
def func_7d4ef7b2dd064ef093c471ba71ceeb2f(placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
return p
def func_b163268f8ff64d3f84e3aaa6d8010b7b(placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
return queue
def func_6ef8e71e217a4110bac33d08a52272ad(placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
return p
def func_88c0d8eea3ce4744a926669c6082994e():
queue = sorted(set(queue))
seen = set(queue)
return queue
def func_49238305546a42b88fab1e662bc3886f():
queue = sorted(set(queue))
seen = set(queue)
return seen
def func_ce981d0535964624bf3ee9531c331713(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
return ret
def func_c1fd60988f424224aad069548db86cb3(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
return bets
def func_a5ecdfa35a234ecab08849a0d96e3eb5(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
return placed
def func_6a2ab7d45b58407abcc316b7add8fc78(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
return budget
def func_26126a771ebf4efba104529689bafd56(infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
return placed
def func_f59c5bdd3baf4e7ba6fa44bcdc21f8ad(infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
return p
def func_31618675966746e8a3b27760bcb0835c(infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
return queue
def func_99f09453144841aba7d754444625a900(infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
return ret
def func_7712e59f1d0f481fbe89bcc5f0aac879(placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
return ret
def func_a8c596f467194fb1b2d14694fa657671(placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
return queue
def func_46d8aef8af3a4db38f56975d1aefd163(placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
return p
def func_adbd3f3140124e6190f58d7026e60ce3(placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
return seen
def func_024786bb17704b50afeed4c0be4abf3d(placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
return p
def func_85f0ac2c5e5c456f8d538f8e34213058(placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
return queue
def func_a9f293f95d944e7d866f0d196e3e2d57(budget, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return ret
def func_4be1d115232a411493011c98316bf5c7(budget, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return partial
def func_60f3a5452e9747acb6450bf5dca833d1(budget, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return larger
def func_173eab38ea1a4067bff3779d02068566(budget, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return lowest
def func_1cb3add9f5a244d4bf75fcdf4c1e97d0(budget, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return exclude
def func_35a92a405dda4aa9bdd5424b16d64394(budget, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return remaining_budget
def func_f965f33635b54fdab6bef89dfcc89751(budget, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return queue
def func_54ebca06e8c94c8fbe08cbcacdc1a7c5(budget, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return lowest_cnt
def func_2dc61e8836d049228aa560f269cf6212(budget, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return needed_budget
def func_848e3dd00b6f4a5587339e269a2ac980(budget, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return next_larger
def func_9201b586d2bb48b1b67b9c2ac979bc7d(budget, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return p
def func_f258f5e37b604b3da0ac0c85a02982f0(budget, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return seen
def func_3e01a7e9d3e2479287aa5ceed777784a(budget, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return can_replicate
def func_7c6f95a6417c4872883e34c1b0b51dd9(budget, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return cand
def func_7543941daf1f4f038456594e7b6e7269(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
return bets
def func_e0497990b4ef4b0d83a4c7d4be2c85d6(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
return p
def func_dec1e042c1ce4a9ea4eab8d6605b2690(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
return budget
def func_b73b99b05a6f4a4b87086ec200248db7(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
return placed
def func_bb98bb02b80941f8982743aaba5991eb(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
return ret
def func_435d5f517c2742029461a81bb808dceb(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
return queue
def func_f99950bcfbc3464abfbef40a5ea4cdf0(infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
return queue
def func_9235167e61604887b366097ed2b99239(infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
return p
def func_ffc8073941f740ed9fb51309802b4fdb(infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
return ret
def func_0041b49d8afa4ef18301fdeacea88257(infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
return placed
def func_265673fa1dd840d7aa17bb82706d27b9(placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
return p
def func_a0056a7262b441039860d046ca992b88(placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
return ret
def func_9c11471050fc48fe9e5f7facb70e4c26(placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
return queue
def func_4f865c4a702244d1be54f33203b0b368(placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
return seen
def func_9243d7ed6d9b48cba0d746db46cd269f(budget, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return remaining_budget
def func_4e393aa5f5584bf8bd8a2742b11c1776(budget, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return seen
def func_ae9c66516d354391864931f32ed23dcd(budget, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return ret
def func_418acfab21b341c7863b413014cddc82(budget, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return cand
def func_016c2c5ca7e4470c969584bfc6cd72f1(budget, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return next_larger
def func_d0d3c841431f47e4b717a1b7c577396c(budget, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return queue
def func_72b2d94a87b147aabe50336749e37879(budget, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return exclude
def func_67eee9de990443e085ab6d1167d499a4(budget, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return partial
def func_462da3106c414a9c91acd8f9f47cbdfd(budget, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return needed_budget
def func_8d11fb75c9f64f649744f56293634ca3(budget, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return can_replicate
def func_2c657999f97648419f4bb97200dffaaf(budget, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return lowest
def func_7e43943e75a34c27a22b76c99d5f1a9d(budget, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return lowest_cnt
def func_d62de335f450463198e1ef3d73e36a60(budget, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return p
def func_5cd38c58d4cf427db53336b6d407c668(budget, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return larger
def func_7b0a748f0d1748a7826768d5660e8fea(budget, cc, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return can_replicate
def func_10daafd3c0f648b48d0c629b51d9a68d(budget, cc, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return needed_budget
def func_c7d838ac8c7a4a8d9d8e58f411210adb(budget, cc, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return p
def func_d17f06f02f8a459ab2621e9229925209(budget, cc, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return partial
def func_193c4bae9b8c4b288a64ffceaa1357da(budget, cc, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return remaining_budget
def func_f2cea0e383194413943eeeb713f132a0(budget, cc, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return larger
def func_79e6f9e552d54076b8120b78f1b74c16(budget, cc, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return queue
def func_acb5e7a6c4d542c796f44042db9c89b8(budget, cc, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return cand
def func_d4514fa8f2204062acede068a879b881(budget, cc, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return ret
def func_b771b5acc080494ba562adf4b3409267(budget, cc, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return next_larger
def func_d24eaae067a54042849fed825d87a2a5(budget, cc, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return lowest
def func_ea3a8ec07d5c4b75aa68097c3cfc2056(budget, cc, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return lowest_cnt
def func_d2edd5919d3b4bc09e86f1823ee8b3f8(budget, cc, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return seen
def func_e9244afb5e0b4516abbabd813bacfda3(budget, cc, placed):
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return exclude
def func_8a3eedaae84a4ac0a4ababa1da21a8fd(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
return p
def func_025cba4c7ac748a599cb834cf3359f00(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
return queue
def func_7b7feac682d94ac7ba4d052bda8ee83d(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
return ret
def func_5ac0bcb86df047dbb63f820394789752(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
return budget
def func_7545214d91974685b68063f41ddd4dc8(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
return bets
def func_32342c9481784983ae6f68d22a4508a7(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
return placed
def func_4333d964f5cf4636bb9ee15c636daa77(infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
return ret
def func_2b817e14313045ebab7dbfcb94ea801c(infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
return queue
def func_211e5dca28ea42e483294e4cd1a9b770(infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
return p
def func_ecb447c251bc40a98ebfe5c4a441968f(infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
return seen
def func_fd243e02442d4db8951cfbae96c60fde(infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
return placed
def func_ef66c0f32e634e5196fd6c5806fbeb73(budget, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return next_larger
def func_66ab7686dc274650a64d0b0bd841ecd9(budget, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return cand
def func_6ea4ecb0027249d48d09c0e44f86592f(budget, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return queue
def func_5aaaeb947cf24badb29d2bfade201bf8(budget, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return partial
def func_145ea1523499472c8e10a32d1d4fcc0b(budget, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return larger
def func_f3643d51ae9b4dcfa05275ff84e994a0(budget, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return exclude
def func_fa5826c503454255b6e198c489d3338d(budget, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return remaining_budget
def func_346669cf7fdb42f08a0d0e1ae00d3231(budget, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return needed_budget
def func_9b879c5d032e4dc8a93bd1e06ad3c777(budget, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return lowest_cnt
def func_9fce7021afb7428f97af9c8f9bfc453e(budget, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return can_replicate
def func_74ddda17a48d4ad8a71f939e6f1d2a07(budget, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return lowest
def func_934d186d2493471f97a636549a9d331d(budget, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return ret
def func_0c00f14afddb48daa8444e73770dc1d5(budget, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return seen
def func_5252f512145a427aa25a240b2477d5bf(budget, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return p
def func_96c52d559dfc4958900f75d7a7bbf83d(budget, cc, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return needed_budget
def func_543644ca3582410e8a52a5495730db23(budget, cc, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return queue
def func_dee43b4a4abe4ddab0704e3cec0c8ddb(budget, cc, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return p
def func_b3f12384b40e4e678c884d41caf319d2(budget, cc, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return ret
def func_f29e053c2e1e4b2ea0fb8efd05c00b42(budget, cc, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return cand
def func_72494d8167ad41afb91c9461e5d7af22(budget, cc, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return larger
def func_0ff370eaca534bafab02aa14500b9415(budget, cc, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return seen
def func_181e3ae275e54f6cae304228d5016090(budget, cc, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return lowest_cnt
def func_2cf9d754159a457eb28b55daeb235fd9(budget, cc, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return exclude
def func_d40062eb1a3948898baf065f86f0ede1(budget, cc, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return partial
def func_b95d26c918f344458c6ebe66b7051767(budget, cc, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return can_replicate
def func_d8567a2bad1d46c6a23c6ce20a31d8c8(budget, cc, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return remaining_budget
def func_13aba82267cd4457a8a1e4b63b44aa3d(budget, cc, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return lowest
def func_fc176ac0bfb34c2691613ec2a5fdc75c(budget, cc, placed):
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return next_larger
def func_2d49266271214aaa95d35f24b76ec595(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
return seen
def func_f2b717277015480aa81aead5107e1714(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
return queue
def func_55991d4d81b847b5ab9c935dd4740b43(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
return ret
def func_ea807d1ab8ce4b54bebc0e342495390d(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
return bets
def func_afec952bb37f4eb28ab4c1177da659b1(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
return p
def func_542440f6c97e475186a629cf67c30bd9(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
return budget
def func_a58808f936184171adf4ca127385aa47(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
return placed
def func_69269cfcb1df46e5bce82c1642a1d1c6(budget, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return ret
def func_217e5e81e67d4bc592872b6e60df7c0f(budget, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return cand
def func_e9246604588c46948de89237bdd32275(budget, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return needed_budget
def func_dae21bdf565e4f90aae2973ca9e7486f(budget, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return lowest
def func_db17c5e8503b46ad8bbf8931e5b32e52(budget, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return exclude
def func_196b7d60df08426fb70b727c94599617(budget, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return can_replicate
def func_302cc621a81d4cc7b7db19e2f2ae6438(budget, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return next_larger
def func_7de616bc0ae6460098bdcacd7dae81a1(budget, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return p
def func_44c7df8fe0154deaa19b7f1e6ff1352e(budget, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return lowest_cnt
def func_bae7f480a58c4213a216a5cf8ad20077(budget, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return queue
def func_f72aa9ed781d45b4876e17a7560a90d8(budget, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return larger
def func_c09e92806bcc4f7885272b1e4feb6974(budget, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return partial
def func_686c2cf465754d5aba6dd4d21ad63bd0(budget, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return seen
def func_64439de98f614163993b60f484a64160(budget, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return remaining_budget
def func_f259fde834fb4b13a3a17a7d7e838c5c(budget, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return placed
def func_eecffcd8912a4bd4abe277464c745fec(budget, cc, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return ret
def func_494af83cd97d487ebace16517c0fe661(budget, cc, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return remaining_budget
def func_5493036f88954b8a8e422c6a5156013e(budget, cc, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return needed_budget
def func_a6d6a0fb803f4d3fa2520dfdbbc3af04(budget, cc, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return p
def func_9bb601b8b58e42348644e4580a92c780(budget, cc, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return seen
def func_af6a65ea88db4fd5bc991157cc4480ca(budget, cc, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return partial
def func_122e1b9e6e1d4003b44c7593002a9839(budget, cc, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return cand
def func_436932b197694d079ecde2bb83b30aad(budget, cc, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return can_replicate
def func_1b501c76fca14d9b8fd5308bf6d224be(budget, cc, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return lowest
def func_bfd213671d3b4e869689bb315b6307cc(budget, cc, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return next_larger
def func_22489454c8b844999cd79b33963e66f1(budget, cc, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return larger
def func_a331c758c9784ab78cf6f871d182799a(budget, cc, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return queue
def func_d5090927965c4a7196025a54a7022fd1(budget, cc, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return lowest_cnt
def func_019880ec4b2440dbb24cba7e1e28797f(budget, cc, placed):
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return exclude
def func_dcb82034344c4468b735b388c2e217b4(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return ret
def func_b26814b64f404549b5593a931a3bfb60(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return cand
def func_bba94e77e5154f6790eb5c168e946eb3(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return queue
def func_d0cc8317738649fc9b5a6a6d29c3241e(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return budget
def func_ab3a93c6d790498487c1d83861a28b2b(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return larger
def func_9cf9d0b97cb44ddea84599dd104835ec(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return needed_budget
def func_b025205560c5431fa82482f088fee293(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return remaining_budget
def func_d0269692fb8443d7a4830cf0bc5ea88a(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return exclude
def func_97b3780de72f4878a4cee9aad047b18c(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return partial
def func_14ae0304cbf14f6193ba0839e004a08b(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return next_larger
def func_aae5ec4f39b54ed79122ca8c2b8eb0e3(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return can_replicate
def func_7b3c1e48b5584fedb36eb631b1bc38cd(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return placed
def func_0395d0f2ab3f49169b9db8c575279755(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return seen
def func_7b0a587ab78c489e8acd2c2c26a2aa62(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return p
def func_7b9f7d77a1484530846b95e281556200(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return bets
def func_83111d5c74864ed7af33e9075416a2f2(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return lowest
def func_a98378c8d2a647279a6b852a3751dbde(infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
return lowest_cnt
def func_8a981716b1514f26bb98bf08c33d765a(budget, cc, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return p
def func_7c83dd71464844619bc874126c772fdb(budget, cc, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return next_larger
def func_ab416eb9ae064724abbd16b410e4296b(budget, cc, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return lowest
def func_ad6a65eb22044352be7652f108b5cc6d(budget, cc, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return needed_budget
def func_654db418d7c34fa1a93ae5fab58b01ee(budget, cc, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return exclude
def func_15fc4e8a0c284cec909c468addd83437(budget, cc, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return remaining_budget
def func_29a5b238cecb4ad694a77b7534b2ce4f(budget, cc, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return lowest_cnt
def func_eda06dcfdce646bbbf629d834be4b797(budget, cc, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return ret
def func_20448dc8039c41d9b857401a4f19a9b2(budget, cc, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return placed
def func_42aee3ed8aca42caaa61131c07e085ed(budget, cc, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return seen
def func_a6dc24c1f29e42478b59ec268fdd0519(budget, cc, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return cand
def func_066d3292e85d4dbe8bba252d4003607a(budget, cc, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return larger
def func_d28b52f8bfc345cbb2063d893733a357(budget, cc, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return queue
def func_b8fab3f744e044a690749e287712ffc8(budget, cc, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return partial
def func_eeb4fd5bb1fd4ff0a6a776000bbcd5ea(budget, cc, infile):
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return can_replicate
def func_a5ddfb768e78412f84c978280dfa3ec1(cc, infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return partial
def func_df1c8da2913d42c79ddb78d85db00554(cc, infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return budget
def func_c346738204204fa8a2f0517d43c47348(cc, infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return queue
def func_a34dd5f4cc9b462a8d0223205d510661(cc, infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return lowest
def func_7b70629151234ebca72fa7892955b28a(cc, infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return seen
def func_338c5e27bb2245b388e911698c394bba(cc, infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return p
def func_5ee6cc2a272146c98713b6ba1c5c84d8(cc, infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return cand
def func_cee1b1c95a5f436b84a0e3f37ccb7230(cc, infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return placed
def func_f0aab3ac554e49be97ba5a453ac6f951(cc, infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return exclude
def func_91f3d95ca9f340bb9db453d3810d9ebe(cc, infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return lowest_cnt
def func_4a4750cd2da24fdeac9c72080f5c17b0(cc, infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return remaining_budget
def func_801889946caf4cbeb665ca1f748d726f(cc, infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return bets
def func_d8f6336299e140d395480b3bed0b153e(cc, infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return larger
def func_450702b6a7ba404f88a774360e0a93cb(cc, infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return ret
def func_80c4fe2f905941d78b72d8e89416307c(cc, infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return can_replicate
def func_f9a53acdeee34078bc8a8f9e1f2fba02(cc, infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return needed_budget
def func_dd766c6acd4c487dbcc7d20ffb8a5f26(cc, infile):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in placed
]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1, remaining_budget /
lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)('Case #%d: %.10lf' % (cc + 1, ret))
return next_larger
def func_b8b7a77b1a6f4bf99ef8804621361945():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
return cases
def func_6a1bcd85a27e4465812016c718a0c590():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
return infile
def func_7dffabe4fddc434bb9e219906d2f093f(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return bets
def func_200a1fefdafa4ff58edca7d517cc0d2b(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return seen
def func_9d6034e01b0044799134df8197892147(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return lowest
def func_0b465a59946b43728e3275f1d08843eb(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return exclude
def func_7d0669129fb84f4ea8d73c092b70937a(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return budget
def func_ee78176ad994479d8f81063d7bc240fa(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return cand
def func_e55093cbd2724cdeb209473119f15cc6(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return p
def func_ec821cd60abb4227989f79f08aa7a81a(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return cases
def func_29b7b6e45d8048db8d9374e3d188b405(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return remaining_budget
def func_df5e424df57148b68dc3f8fbb20a362d(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return queue
def func_3aff0462414747928ef53a68dbf704db(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return placed
def func_b1f139e39f3b4b589cfb62080dc826d6(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return ret
def func_d802a1059c234b27956794f17dd467eb(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return needed_budget
def func_4e12d1c861614438b6dd563771c0323e(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return partial
def func_048af8f95e7d4a76a81bc04ffdc05ca1(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return larger
def func_9293e278d5684d57bf52ed64970f2dad(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return next_larger
def func_206b34c6d52d4deba65b83ffb1a9c614(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return can_replicate
def func_42262518132f4173821794c18ac16110(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return cc
def func_62ea4ea2090743e882d6a2256e9bb9a3(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return lowest_cnt
def func_bd00b82284714345a992f7ebbf54dcf2(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return p
def func_b5886dd541304beb96195341067cec15(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return bets
def func_9b3bb15f016e458ebcff5b85cbd6c519(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return ret
def func_ba427fcf857d457a84d56ce1ffa42b2f(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return lowest_cnt
def func_fd17d215a16d4e259eb123839dc44e6b(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return can_replicate
def func_cbc5e6bbfcc04067bc2cf1d790c57dd9(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return queue
def func_ca7919ee26e34ff6b016017b100a2550(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return remaining_budget
def func_06f2c0d5aae145cd9546fd78096f59e2(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return placed
def func_c90380a87a734f6896c56408b9dfca22(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return partial
def func_ebc1d4a254e847618367bcb50443ec7f(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return needed_budget
def func_5fbc0222a2f9485195fe43db8ab4fedc(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return next_larger
def func_d34104a35c4e4a3cbcb685a5b28ee35e(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return seen
def func_5f463628341441a0875f931d0b036ecf(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return lowest
def func_3e8097e37c8744698990cacf4781f64b(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return cc
def func_1a84b22f99534e0fa25d4b0b8a3119f0(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return budget
def func_6a02bf0f31b34598b9baf654d97e153b(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return larger
def func_010f380ed04949fcb2820d0413ebb35f():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return bets
def func_87780d1e8313481fb1762c5e101c8320():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return p
def func_f6161087a94f4ed6b547f3a471f9aecd():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return placed
def func_7ea384dbe3684b44a4a6ea6e650e4b2b():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return can_replicate
def func_f503133e24a04bb2a00b0cc9977b8295():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return lowest
def func_2868949534bb4b1e9a04051fdde991e8():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return larger
def func_800e0609b09b4b6b8bc983e503465154():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return needed_budget
def func_83762b7b93da4316a3aab32ef573f470():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return exclude
def func_54db9053ea104d67a67de804bb2df77c():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return next_larger
def func_a9d5a2789dd44d878d1db75963f878e1():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return ret
def func_e593bc4a0b794e2aa7edf31ef735a7c9():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return queue
def func_fa55a6d85cdd41e382bc88c71e4c4368():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return seen
def func_4f2c9168549b4312a451578401a40a77():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return budget
def func_adf1029c65c346708b610c4f59d5616e():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return infile
def func_b35fdd6b22ec46ac9d9a98d9cacbb335():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return remaining_budget
def func_44107efc209d4635abc6b9cc0b82a92c():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return partial
def func_3160c53328c64bc98d09d651bebd6a54():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return cc
def func_202a0ee8d63c4c88a8d433d6bb105421():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return lowest_cnt
def func_46c737324a234d238088f250b532f95f():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return cand
def func_aa03b861b3684627a0a584efb7bb44a8():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
return cases
def func_99317ad013bc4b1b9619e97a6bc4a684(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return next_larger
def func_02779287568b4632975e29caafbae94c(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return partial
def func_0c92bcbe2c9545d48af22cdf51e74101(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return can_replicate
def func_5f8169f98a3f495c86bd00d560d1ee30(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return seen
def func_f967a0dc33f94a58ba090f28d49f9a29(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return budget
def func_932f2ff1430243578714a897281e3339(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return lowest_cnt
def func_cf7fb27f2f064918b6e261fe9db81711(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return bets
def func_23bafb692d1942b1969af26dab2a4a86(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return needed_budget
def func_c336e16124104b239ec490a74a87bcbf(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return larger
def func_9a1b24f0f3fe4a268262576b49e80daa(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return ret
def func_907e76df01d8448f9433fbc6ebed54fb(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return cc
def func_4d3568ebbc554230a4929ee332587761(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return lowest
def func_1bbc126e948b4fb4a20af4d968d53a53(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return cases
def func_f44b2784caf846b4b6260ff284ee90e5(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return remaining_budget
def func_3c0477e49680400098462ae209c7b09f(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return p
def func_dc7bcd5d80cc4af98632f43ef09dcd18(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return queue
def func_ab93cf4a44ed406ea499c1ba4c14cd16(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return placed
def func_1d1c96d70cf24a139b15eb47c24fc305(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return ret
def func_aba2540eefae4bc0839f907579e112a2(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return cc
def func_8a361a215a1b4fa9902633f4f455fb96(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return lowest_cnt
def func_e6abc6b658c54688ae959bc29a50342e(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return p
def func_7203895fdde744e4b562d3c889ea0d22(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return larger
def func_7b206146484340ab9b756f447bb421dd(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return bets
def func_703a14796566413fabd4c1819b61f0ea(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return needed_budget
def func_e7cdfe0e43694d54b1cb0195a9e48a3e(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return queue
def func_34c925b20a52438ebff8bb14681388f9(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return placed
def func_91c7814a2120447cbe81ee0bfff7450d(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return next_larger
def func_39f32d839bf54c4cbb6e4f0a749276d2(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return budget
def func_2645be30df18446080ceeac71fa2aeb9(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return can_replicate
def func_8d65f3565cfc49dd8d98ca630b2e0c4d(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return partial
def func_169c2ee346a74ad2800eed357642d5de(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return seen
def func_23ab5cdf216f4d75ade922cbde9234f9(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return remaining_budget
def func_19a09d040c5e40fdb88405ced32712f0(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return lowest
def func_7e2fe86e40eb4dbfa7c6b9a72c81ffd4():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return larger
def func_349b55074a984003ac38d6088e86c313():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return p
def func_8ae20d4777344d7ebaa323d90639e74b():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return cases
def func_563e00dc9aaf4905b9b48e71e40b610c():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return infile
def func_a7c817f0031c4726bb934daa0c63371c():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return lowest_cnt
def func_45a7f875fb154f0486649a2864041a0a():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return bets
def func_3587172fa6fc4595af1bbf069b2037d4():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return partial
def func_a77474959e1c4d5fbfc6429bb04b609a():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return remaining_budget
def func_56f630a0254e41d0ad255d33bca7a79a():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return budget
def func_d28d4aed70f74d4a93560209baae9e6e():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return ret
def func_c1fcb3daee704d658e9f2708a996f655():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return next_larger
def func_9e78026d43854e7088313bdd4791cb7c():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return lowest
def func_e107fcac013c4d24830988abd98ebc75():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return queue
def func_fb6e412ba2c8492b8c07007d244be96b():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return placed
def func_d6749a28bf14449a92861548d7a6c9b4():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return cc
def func_0061eb8e566045d6beed64764579cae5():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return can_replicate
def func_d3434989388847d3b51e0f7e5f8b5857():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return needed_budget
def func_3fc15b436aa24581b91d3cc76774260b():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
return seen
def func_e5cdc78c584a41b1b00cefe6c7e1a64d(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return remaining_budget
def func_c0f4802c353540a8a3e57907d20f5f14(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return p
def func_32f92da5b8064374bbff3ae1a95a9ccc(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return queue
def func_9b1e6967e6ab42848f1d3ed27cd1d047(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return cc
def func_5ced77ee2f2a43a78a7907b12c0d5ae7(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return partial
def func_6a3b7b272d6c4056b67e8a9055559007(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return next_larger
def func_76573fbebf97469498b38fb7d8c4f128(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return budget
def func_35821b1e41b24d3ebfa0142a6ddf5e9f(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return seen
def func_a282d4b798df4cd1beae3b6f4b64e9be(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return needed_budget
def func_f6af7e28761841e5a52ffd5257546182(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return lowest
def func_eb3ced0cb1a447f6b293a40e86b079d6(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return lowest_cnt
def func_5e7d25143c234be8a84ef55d82ed6109(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return bets
def func_17ba2d357d09415d8b7cf07dd3b9620c(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return larger
def func_2f61e386182c48aa820b73c89e22bf1a(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return placed
def func_5fa3643aded849299e12f5fa73a94102(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return cases
def func_c2a72a5ccff94d4abb6d589e22e670d4(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return ret
def func_9231b924fbe6421eaf4f6b784f77ac80(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return can_replicate
def func_c65aaa481cf048aa8ff1de6a2cc70141(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return seen
def func_1f633d0c3f81475c89eae40d71ee6d74(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return next_larger
def func_29d35e5fc2d2418cb6b2e8d18f752eb6(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return exclude
def func_c26ddaf7400741f3a903f8dcf4a1c423(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return queue
def func_67efc5e3797f4aef847d54d8ae4ed3be(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return lowest
def func_a9f63b1e792f47aa80f45a3d84e53e59(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return larger
def func_93c53d2b7b094eccbefd7d4ff4f001cf(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return partial
def func_57b64a55ad8743efab80bb79e47fc2e3(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return cc
def func_2961e60591c64001be74c212fe6fff7e(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return cand
def func_d764fdec180840cca2a279527a3d1f58(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return lowest_cnt
def func_ca4a02e9d847442d8f9d89006685b656(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return budget
def func_8a317ee6bac94018aa1f5f1617ab0ba4(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return can_replicate
def func_8dfbf449510249d9b6e8b6acb02fc37e(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return remaining_budget
def func_dd1974ea63924a3f9b556f24c93e7249(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return placed
def func_9e6fcae1c2e046a7b894a4f7ae4e2313(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return needed_budget
def func_5ae6017c113846148a56de3aea244f3e(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return bets
def func_aa067da96a1b4c6ab8c71dae7d10a80e(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return p
def func_93d52fae7e1b41c0ba0687bb5c4fb2bd(cases, infile):
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return ret
def func_939352cf1a7e479c973cf751a50898f5():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return larger
def func_22690e937c504b26b936afbe90d21851():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return lowest
def func_1b6e75c23f864853a2a969499b8a93e6():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return cases
def func_716e1e6bb6674ebc87c8fc65f3b7a6b2():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return budget
def func_0b36cfd5289c4861b0ef033ea1209cca():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return placed
def func_7dec3991a058450db98622b9a40ba36d():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return queue
def func_3310a99e7d0a4564ab7c0b5bceb8ce35():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return remaining_budget
def func_c6f2d008197d4716a1e9bc42e4015283():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return cc
def func_d825ac9f24754dc3a716fac98a9879f6():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return partial
def func_0155d85a5bc14b8594cfc84e80a6396a():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return ret
def func_099fb04ff32a4c22b9e4ba016e6b1928():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return p
def func_c3e58b7602624a569a62473ac0aa884a():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return needed_budget
def func_678c488550104a3e82711915acbcc360():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return bets
def func_f73174629b7d4755a61766d9dd7a7959():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return seen
def func_e2e83ab6a1ef46e99d5e314a2d0ed2da():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return lowest_cnt
def func_824a2e8727af4934b24398db4faf5cd4():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return can_replicate
def func_709f9aeb6b6d4202be6de93e06c5352a():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return next_larger
def func_2d778199ad9f436897f9034f9b945a6a():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
return infile
def func_014b59feb2644fc381264822002e4aa8(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return budget
def func_b47fcd0a7c684c9cb123a2ffecab37ea(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return remaining_budget
def func_d3176cc3602d4718929cfe23c5722530(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return needed_budget
def func_5ba526e3304049c78241e6331024092d(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return p
def func_1d569696edde4de29c3c4948ff78f225(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return cc
def func_b8652e05434d470b8d537c99cce588ae(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return seen
def func_977269682686473d90d3b98aca75b209(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return bets
def func_fdbaf5c1af27404294c00e3dbd5bd629(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return next_larger
def func_ef94d039092b43b484ed7ed5587f1028(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return cand
def func_f4bb888398634cd5a82ff88c00c2ec2f(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return lowest_cnt
def func_f582d5f1de4c44eb8a65ff756ae92d06(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return placed
def func_b1451abdba3b4a45861aaf51c96de390(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return partial
def func_6573a452620e48e281722d4f8df5efe3(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return queue
def func_83a32361913b4c5c8441c8d5d4eb3bf6(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return exclude
def func_127f3d26d463413381dd0090c9d9d447(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return lowest
def func_4ec44004d185463ab9848a9619ca2dee(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return larger
def func_c6abf5cb39b7496f9f14ad18d7497dbf(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return cases
def func_e3af80c5f3944d29b0d12167e03f596b(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return ret
def func_cb830edc80524b599c35f414e9d9982c(infile):
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return can_replicate
def func_64c4778be53c42918793d40dbb23da44():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return cases
def func_bd84959af057473b96f9a75fab5485bf():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return next_larger
def func_0df505aef94e4004a95d9ea8c9396a7c():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return infile
def func_4101d7d7b5284fc398b7616684eef88a():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return exclude
def func_13edc9399c674843b3288ef8a16b6f5f():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return queue
def func_e5be29df76684581a6eacaf873b4c83e():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return cand
def func_1d617c41117e451bac357e3609978e02():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return lowest
def func_cec44e1bbad94c9e9db5368ec782dfd7():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return remaining_budget
def func_af8cd4cb21684b7c9ab95d9fad76b15a():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return p
def func_fd2e9e3e224d4608bdd87ea4954a1b92():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return bets
def func_0cd51dc6e0fb40db809beb7adf5199c7():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return cc
def func_1c4867a25f1941bcb1dd9a4f74f291c3():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return placed
def func_46339166d908453395964138572ec4cc():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return seen
def func_e842db7e952e42e3b17d188db816457f():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return can_replicate
def func_f6e9c2713ce048afbfc79d1be10a8955():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return ret
def func_c08638ee53ef4cd19b851862e189a98b():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return larger
def func_6ed3c4f11f8b4c78814c263238a45e44():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return needed_budget
def func_2004547e96e34cc3b5e14d520045b4ee():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return lowest_cnt
def func_e2d5a5e6872741d2bf1d178b06ff34af():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return budget
def func_6f5d6d06c5f94046b588aa518459b9ba():
infile = open('codejam/test_files/Y13R5P1/A.in')
cases = int(infile.readline())
for cc in xrange(cases):
budget, bets = map(int, infile.readline().split())
placed = sorted(map(int, infile.readline().split()))
ret = 0.0
queue = [1] + placed + [(p - 1) for p in placed] + [(p + 1) for p in
placed]
queue = sorted(set(queue))
seen = set(queue)
while queue:
lowest = queue.pop()
if lowest == 0:
continue
needed_budget = (37 - len(placed)) * lowest
for p in placed:
needed_budget += max(0, lowest - p)
if budget < needed_budget:
continue
remaining_budget = budget - needed_budget
partial = len([p for p in placed if p <= lowest])
lowest_cnt = 37 - len(placed) + partial
if lowest_cnt == 0:
continue
larger = [p for p in placed if p > lowest]
if larger:
next_larger = min(larger)
can_replicate = min(next_larger - lowest - 1,
remaining_budget / lowest_cnt)
else:
can_replicate = remaining_budget / lowest_cnt
if can_replicate > 0:
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
for exclude in xrange(0, min(remaining_budget, partial) + 1):
cand = get_expected(placed, lowest, exclude
) - exclude - needed_budget
ret = max(ret, cand)
print 'Case #%d: %.10lf' % (cc + 1, ret)
if lowest + can_replicate not in seen:
seen.add(lowest + can_replicate)
queue.append(lowest + can_replicate)
if lowest + can_replicate - 1 not in seen:
seen.add(lowest + can_replicate - 1)
queue.append(lowest + can_replicate - 1)
infile.close()
return partial
|
StarcoderdataPython
|
1784181
|
<reponame>hahagan/study
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import argparse
import socket
import _thread
import sys
import threading
import multiprocessing
import os
class Tcp(threading.Thread):
def __init__(self, path, ip, port):
threading.Thread.__init__(self)
self._path = path
self.ip = ip
self.port = int(port)
def run(self):
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect((self.ip, self.port))
for log in open(self._path, "r"):
client.send(log.encode('utf-8'))
client.close()
def tcp(ip, port, path):
try:
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect((ip, port))
print("send file: ", path)
for log in open(path, "r"):
client.send(log.encode('utf-8'))
client.close()
except Exception as e:
print(e)
print("send file: ", path)
return
print("send file eof: ", path)
def test_io(path):
old_path = os.path.split(path)
new_path = os.path.join("tmp", old_path[-1])
print(new_path)
try:
with open(new_path, "w") as fout:
for log in open(path, "r"):
fout.write(log+"\n")
print("end: ", new_path)
except Exception as e:
print(e)
return
if __name__ == "__main__":
muti = list()
pool = multiprocessing.Pool(8)
for i in sys.argv[1:]:
muti.append(pool.apply_async(
tcp, args=("127.0.0.1", 5140, i,)))
# muti.append(pool.apply_async(
# test_io, args=(i,)))
pool.close()
pool.join()
|
StarcoderdataPython
|
44649
|
<filename>jupiter/use_cases/metrics/entry/create.py
"""The command for creating a metric entry."""
from dataclasses import dataclass
from typing import Optional, Final
from jupiter.domain.adate import ADate
from jupiter.domain.metrics.infra.metric_notion_manager import MetricNotionManager
from jupiter.domain.metrics.metric_entry import MetricEntry
from jupiter.domain.metrics.metric_key import MetricKey
from jupiter.domain.metrics.notion_metric_entry import NotionMetricEntry
from jupiter.domain.storage_engine import StorageEngine
from jupiter.framework.use_case import UseCase
from jupiter.utils.time_provider import TimeProvider
class MetricEntryCreateUseCase(UseCase['MetricEntryCreateUseCase.Args', None]):
"""The command for creating a metric entry."""
@dataclass()
class Args:
"""Args."""
metric_key: MetricKey
collection_time: Optional[ADate]
value: float
notes: Optional[str]
_time_provider: Final[TimeProvider]
_storage_engine: Final[StorageEngine]
_notion_manager: Final[MetricNotionManager]
def __init__(
self, time_provider: TimeProvider, storage_engine: StorageEngine,
notion_manager: MetricNotionManager) -> None:
"""Constructor."""
self._time_provider = time_provider
self._storage_engine = storage_engine
self._notion_manager = notion_manager
def execute(self, args: Args) -> None:
"""Execute the command's action."""
with self._storage_engine.get_unit_of_work() as uow:
metric = uow.metric_repository.load_by_key(args.metric_key)
collection_time = args.collection_time \
if args.collection_time else ADate.from_timestamp(self._time_provider.get_current_time())
metric_entry = MetricEntry.new_metric_entry(
False, metric.ref_id, collection_time, args.value, args.notes,
self._time_provider.get_current_time())
metric_entry = uow.metric_entry_repository.create(metric_entry)
notion_metric_entry = NotionMetricEntry.new_notion_row(metric_entry, None)
self._notion_manager.upsert_metric_entry(metric.ref_id, notion_metric_entry)
|
StarcoderdataPython
|
4801193
|
<filename>data/external/repositories_2to3/168569/kaggle-Otto-master/utility.py
import numpy as np
import scipy as sp
import pandas as pd
def count_feature(X, tbl_lst = None, min_cnt = 1):
X_lst = [pd.Series(X[:, i]) for i in range(X.shape[1])]
if tbl_lst is None:
tbl_lst = [x.value_counts() for x in X_lst]
if min_cnt > 1:
tbl_lst = [s[s >= min_cnt] for s in tbl_lst]
X = sp.column_stack([x.map(tbl).values for x, tbl in zip(X_lst, tbl_lst)])
# NA(unseen values) to 0
return np.nan_to_num(X), tbl_lst
# mat: A sparse matrix
def remove_duplicate_cols(mat):
if not isinstance(mat, sp.sparse.coo_matrix):
mat = mat.tocoo()
row = mat.row
col = mat.col
data = mat.data
crd = pd.DataFrame({'row':row, 'col':col, 'data':data}, columns = ['col', 'row', 'data'])
col_rd = crd.groupby('col').apply(lambda x: str(np.array(x)[:,1:]))
dup = col_rd.duplicated()
return mat.tocsc()[:, col_rd.index.values[dup.values == False]]
def RImatrix(p, m, k, rm_dup_cols = False, seed = None):
""" USAGE:
Argument
p: # of original varables
m: The length of index vector
k: # of 1s == # of -1s
Rerurn value
sparce.coo_matrix, shape:(p, s)
If rm_dup_cols == False s == m
else s <= m
"""
if seed is not None: np.random.seed(seed)
popu = list(range(m))
row = np.repeat(list(range(p)), 2 * k)
col = np.array([np.random.choice(popu, 2 * k, replace = False) for i in range(p)]).reshape((p * k * 2,))
data = np.tile(np.repeat([1, -1], k), p)
mat = sp.sparse.coo_matrix((data, (row, col)), shape = (p, m), dtype = sp.int8)
if rm_dup_cols:
mat = remove_duplicate_cols(mat)
return mat
# Random Indexing
def RI(X, m, k = 1, normalize = True, seed = None, returnR = False):
R = RImatrix(X.shape[1], m, k, rm_dup_cols = True, seed = seed)
Mat = X * R
if normalize:
Mat = pp.normalize(Mat, norm = 'l2')
if returnR:
return Mat, R
else:
return Mat
# Return a sparse matrix whose column has k_min to k_max 1s
def col_k_ones_matrix(p, m, k = None, k_min = 1, k_max = 1, seed = None, rm_dup_cols = True):
if k is not None:
k_min = k_max = k
if seed is not None: np.random.seed(seed)
k_col = np.random.choice(list(range(k_min, k_max + 1)), m)
col = np.repeat(list(range(m)), k_col)
popu = np.arange(p)
l = [np.random.choice(popu, k_col[i], replace = False).tolist() for i in range(m)]
row = sum(l, [])
data = np.ones(k_col.sum())
mat = sp.sparse.coo_matrix((data, (row, col)), shape = (p, m), dtype = np.float32)
if rm_dup_cols:
mat = remove_duplicate_cols(mat)
return mat
|
StarcoderdataPython
|
93146
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Nov 6 09:44:54 2019
@author: thomas
"""
import numpy as np
import matplotlib.pyplot as plt
plt.close('all')
def graycode(M):
if (M==1):
g=['0','1']
elif (M>1):
gs=graycode(M-1)
gsr=gs[::-1]
gs0=['0'+x for x in gs]
gs1=['1'+x for x in gsr]
g=gs0+gs1
return(g)
M=2**4 # number of levels
gwords=graycode(np.log2(M).astype(int)) # Gray code words
u=np.arange(0,M)
Am = 2*u - M +1 # Symbol levels
for i,g in enumerate(gwords):
print('%d -> %6.2f : %s' %(i,Am[i],g))
plt.figure()
plt.stem(u,Am)
plt.xlabel('$m$')
plt.ylabel('$A_m$')
for n in range(0,M):
A = Am[n]
if A>0:
y=A+1
else:
y=A-2
plt.text(n-0.5,y,gwords[n])
minA=np.min(Am)
maxA=np.max(Am)
plt.ylim(minA-4,maxA+4)
plt.tight_layout()
plt.savefig('levelspam.png')
|
StarcoderdataPython
|
3341069
|
name = [
'sulfate ion',
'acetate ion',
]
mmtf_translator = {
'SULFATE ION' : 'sulfate ion',
'ACETATE ION' : 'acetate ion',
}
|
StarcoderdataPython
|
22738
|
<reponame>ssmbct-netops/CyberSaucier
import requests, json, argparse, os
from termcolor import colored
parser = argparse.ArgumentParser(description="Verify the recipes by running them through CyberSaucier")
parser.add_argument('--rulefolder', help='Folder containing the json recipes')
parser.add_argument("--url", help="URL to CyberSaucier", default="http://localhost:7000")
args = parser.parse_args()
for root, dirs, files in os.walk(args.rulefolder):
path = root.split(os.sep)
for fname in files:
if fname.lower().endswith("json"):
file = os.path.join(root, fname)
with open(file, 'r') as f:
data=f.read()
rule = json.loads(data)
if "verify" in rule:
u = args.url + "/" + rule["name"]
resp = requests.post(url=u, data=rule["verify"]["originalInput"], headers={'Content-Type':'text/plain'})
resp = resp.json()
if resp["result"] == rule["verify"]["expectedOutput"]:
print(colored(rule["name"] + " : PASS", "green"))
else:
print(colored(rule["name"] + " : FAIL", "red"))
|
StarcoderdataPython
|
145192
|
<gh_stars>0
# This is an input class. Do not edit.
class LinkedList:
def __init__(self, value):
self.value = value
self.next = None
# O(n) time | O(n) space - where n is the number of nodes in the Linked List
def nodeSwap(head):
if head is None or head.next is None:
return head
nextNode = head.next
head.next = nodeSwap(head.next.next)
nextNode.next = head
return nextNode
|
StarcoderdataPython
|
155276
|
<reponame>forca-inf/forca
widths = {'Alpha': 722,
'Beta': 667,
'Chi': 722,
'Delta': 612,
'Epsilon': 611,
'Eta': 722,
'Euro': 750,
'Gamma': 603,
'Ifraktur': 686,
'Iota': 333,
'Kappa': 722,
'Lambda': 686,
'Mu': 889,
'Nu': 722,
'Omega': 768,
'Omicron': 722,
'Phi': 763,
'Pi': 768,
'Psi': 795,
'Rfraktur': 795,
'Rho': 556,
'Sigma': 592,
'Tau': 611,
'Theta': 741,
'Upsilon': 690,
'Upsilon1': 620,
'Xi': 645,
'Zeta': 611,
'aleph': 823,
'alpha': 631,
'ampersand': 778,
'angle': 768,
'angleleft': 329,
'angleright': 329,
'apple': 790,
'approxequal': 549,
'arrowboth': 1042,
'arrowdblboth': 1042,
'arrowdbldown': 603,
'arrowdblleft': 987,
'arrowdblright': 987,
'arrowdblup': 603,
'arrowdown': 603,
'arrowhorizex': 1000,
'arrowleft': 987,
'arrowright': 987,
'arrowup': 603,
'arrowvertex': 603,
'asteriskmath': 500,
'bar': 200,
'beta': 549,
'braceex': 494,
'braceleft': 480,
'braceleftbt': 494,
'braceleftmid': 494,
'bracelefttp': 494,
'braceright': 480,
'bracerightbt': 494,
'bracerightmid': 494,
'bracerighttp': 494,
'bracketleft': 333,
'bracketleftbt': 384,
'bracketleftex': 384,
'bracketlefttp': 384,
'bracketright': 333,
'bracketrightbt': 384,
'bracketrightex': 384,
'bracketrighttp': 384,
'bullet': 460,
'carriagereturn': 658,
'chi': 549,
'circlemultiply': 768,
'circleplus': 768,
'club': 753,
'colon': 278,
'comma': 250,
'congruent': 549,
'copyrightsans': 790,
'copyrightserif': 790,
'degree': 400,
'delta': 494,
'diamond': 753,
'divide': 549,
'dotmath': 250,
'eight': 500,
'element': 713,
'ellipsis': 1000,
'emptyset': 823,
'epsilon': 439,
'equal': 549,
'equivalence': 549,
'eta': 603,
'exclam': 333,
'existential': 549,
'five': 500,
'florin': 500,
'four': 500,
'fraction': 167,
'gamma': 411,
'gradient': 713,
'greater': 549,
'greaterequal': 549,
'heart': 753,
'infinity': 713,
'integral': 274,
'integralbt': 686,
'integralex': 686,
'integraltp': 686,
'intersection': 768,
'iota': 329,
'kappa': 549,
'lambda': 549,
'less': 549,
'lessequal': 549,
'logicaland': 603,
'logicalnot': 713,
'logicalor': 603,
'lozenge': 494,
'minus': 549,
'minute': 247,
'mu': 576,
'multiply': 549,
'nine': 500,
'notelement': 713,
'notequal': 549,
'notsubset': 713,
'nu': 521,
'numbersign': 500,
'omega': 686,
'omega1': 713,
'omicron': 549,
'one': 500,
'parenleft': 333,
'parenleftbt': 384,
'parenleftex': 384,
'parenlefttp': 384,
'parenright': 333,
'parenrightbt': 384,
'parenrightex': 384,
'parenrighttp': 384,
'partialdiff': 494,
'percent': 833,
'period': 250,
'perpendicular': 658,
'phi': 521,
'phi1': 603,
'pi': 549,
'plus': 549,
'plusminus': 549,
'product': 823,
'propersubset': 713,
'propersuperset': 713,
'proportional': 713,
'psi': 686,
'question': 444,
'radical': 549,
'radicalex': 500,
'reflexsubset': 713,
'reflexsuperset': 713,
'registersans': 790,
'registerserif': 790,
'rho': 549,
'second': 411,
'semicolon': 278,
'seven': 500,
'sigma': 603,
'sigma1': 439,
'similar': 549,
'six': 500,
'slash': 278,
'space': 250,
'spade': 753,
'suchthat': 439,
'summation': 713,
'tau': 439,
'therefore': 863,
'theta': 521,
'theta1': 631,
'three': 500,
'trademarksans': 786,
'trademarkserif': 890,
'two': 500,
'underscore': 500,
'union': 768,
'universal': 713,
'upsilon': 576,
'weierstrass': 987,
'xi': 493,
'zero': 500,
'zeta': 494}
|
StarcoderdataPython
|
3236665
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Generated from FHIR 0.5.0.5149 (http://hl7.org/fhir/StructureDefinition/Contract) on 2015-07-06.
# 2015, SMART Health IT.
from . import attachment
from . import codeableconcept
from . import coding
from . import domainresource
from . import fhirdate
from . import fhirelement
from . import fhirreference
from . import identifier
from . import money
from . import period
from . import quantity
class Contract(domainresource.DomainResource):
""" Contract.
A formal agreement between parties regarding the conduct of business,
exchange of information or other matters.
"""
resource_name = "Contract"
def __init__(self, jsondict=None):
""" Initialize all valid properties.
"""
self.action = None
""" Contract Action.
List of `CodeableConcept` items (represented as `dict` in JSON). """
self.actionReason = None
""" Contract Action Reason.
List of `CodeableConcept` items (represented as `dict` in JSON). """
self.actor = None
""" Contract Actor.
List of `ContractActor` items (represented as `dict` in JSON). """
self.applies = None
""" Effective time.
Type `Period` (represented as `dict` in JSON). """
self.authority = None
""" Authority under which this Contract has standing.
List of `FHIRReference` items referencing `Organization` (represented as `dict` in JSON). """
self.bindingAttachment = None
""" Binding Contract.
Type `Attachment` (represented as `dict` in JSON). """
self.bindingReference = None
""" Binding Contract.
Type `FHIRReference` referencing `Composition, DocumentReference, QuestionnaireAnswers` (represented as `dict` in JSON). """
self.domain = None
""" Domain in which this Contract applies.
List of `FHIRReference` items referencing `Location` (represented as `dict` in JSON). """
self.friendly = None
""" Contract Friendly Language.
List of `ContractFriendly` items (represented as `dict` in JSON). """
self.identifier = None
""" Contract identifier.
Type `Identifier` (represented as `dict` in JSON). """
self.issued = None
""" When this Contract was issued.
Type `FHIRDate` (represented as `str` in JSON). """
self.legal = None
""" Contract Legal Language.
List of `ContractLegal` items (represented as `dict` in JSON). """
self.rule = None
""" Computable Contract Language.
List of `ContractRule` items (represented as `dict` in JSON). """
self.signer = None
""" Contract Signer.
List of `ContractSigner` items (represented as `dict` in JSON). """
self.subType = None
""" Contract Subtype.
List of `CodeableConcept` items (represented as `dict` in JSON). """
self.subject = None
""" Subject of this Contract.
List of `FHIRReference` items referencing `Resource` (represented as `dict` in JSON). """
self.term = None
""" Contract Term List.
List of `ContractTerm` items (represented as `dict` in JSON). """
self.type = None
""" Contract Tyoe.
Type `CodeableConcept` (represented as `dict` in JSON). """
self.valuedItem = None
""" Contract Valued Item.
List of `ContractValuedItem` items (represented as `dict` in JSON). """
super(Contract, self).__init__(jsondict)
def elementProperties(self):
js = super(Contract, self).elementProperties()
js.extend([
("action", "action", codeableconcept.CodeableConcept, True),
("actionReason", "actionReason", codeableconcept.CodeableConcept, True),
("actor", "actor", ContractActor, True),
("applies", "applies", period.Period, False),
("authority", "authority", fhirreference.FHIRReference, True),
("bindingAttachment", "bindingAttachment", attachment.Attachment, False),
("bindingReference", "bindingReference", fhirreference.FHIRReference, False),
("domain", "domain", fhirreference.FHIRReference, True),
("friendly", "friendly", ContractFriendly, True),
("identifier", "identifier", identifier.Identifier, False),
("issued", "issued", fhirdate.FHIRDate, False),
("legal", "legal", ContractLegal, True),
("rule", "rule", ContractRule, True),
("signer", "signer", ContractSigner, True),
("subType", "subType", codeableconcept.CodeableConcept, True),
("subject", "subject", fhirreference.FHIRReference, True),
("term", "term", ContractTerm, True),
("type", "type", codeableconcept.CodeableConcept, False),
("valuedItem", "valuedItem", ContractValuedItem, True),
])
return js
class ContractActor(fhirelement.FHIRElement):
""" Contract Actor.
List of Contract actors.
"""
resource_name = "ContractActor"
def __init__(self, jsondict=None):
""" Initialize all valid properties.
"""
self.entity = None
""" Contract Actor Type.
Type `FHIRReference` referencing `Contract, Device, Group, Location, Organization, Patient, Practitioner, RelatedPerson, Substance, Supply` (represented as `dict` in JSON). """
self.role = None
""" Contract Actor Role.
List of `CodeableConcept` items (represented as `dict` in JSON). """
super(ContractActor, self).__init__(jsondict)
def elementProperties(self):
js = super(ContractActor, self).elementProperties()
js.extend([
("entity", "entity", fhirreference.FHIRReference, False),
("role", "role", codeableconcept.CodeableConcept, True),
])
return js
class ContractFriendly(fhirelement.FHIRElement):
""" Contract Friendly Language.
The "patient friendly language" versionof the Contract in whole or in
parts. "Patient friendly language" means the representation of the Contract
and Contract Provisions in a manner that is readily accessible and
understandable by a layperson in accordance with best practices for
communication styles that ensure that those agreeing to or signing the
Contract understand the roles, actions, obligations, responsibilities, and
implication of the agreement.
"""
resource_name = "ContractFriendly"
def __init__(self, jsondict=None):
""" Initialize all valid properties.
"""
self.contentAttachment = None
""" Easily comprehended representation of this Contract.
Type `Attachment` (represented as `dict` in JSON). """
self.contentReference = None
""" Easily comprehended representation of this Contract.
Type `FHIRReference` referencing `Composition, DocumentReference, QuestionnaireAnswers` (represented as `dict` in JSON). """
super(ContractFriendly, self).__init__(jsondict)
def elementProperties(self):
js = super(ContractFriendly, self).elementProperties()
js.extend([
("contentAttachment", "contentAttachment", attachment.Attachment, False),
("contentReference", "contentReference", fhirreference.FHIRReference, False),
])
return js
class ContractLegal(fhirelement.FHIRElement):
""" Contract Legal Language.
List of Legal expressions or representations of this Contract.
"""
resource_name = "ContractLegal"
def __init__(self, jsondict=None):
""" Initialize all valid properties.
"""
self.contentAttachment = None
""" Contract Legal Text.
Type `Attachment` (represented as `dict` in JSON). """
self.contentReference = None
""" Contract Legal Text.
Type `FHIRReference` referencing `Composition, DocumentReference, QuestionnaireAnswers` (represented as `dict` in JSON). """
super(ContractLegal, self).__init__(jsondict)
def elementProperties(self):
js = super(ContractLegal, self).elementProperties()
js.extend([
("contentAttachment", "contentAttachment", attachment.Attachment, False),
("contentReference", "contentReference", fhirreference.FHIRReference, False),
])
return js
class ContractRule(fhirelement.FHIRElement):
""" Computable Contract Language.
List of Computable Policy Rule Language Representations of this Contract.
"""
resource_name = "ContractRule"
def __init__(self, jsondict=None):
""" Initialize all valid properties.
"""
self.contentAttachment = None
""" Computable Contract Rules.
Type `Attachment` (represented as `dict` in JSON). """
self.contentReference = None
""" Computable Contract Rules.
Type `FHIRReference` referencing `DocumentReference` (represented as `dict` in JSON). """
super(ContractRule, self).__init__(jsondict)
def elementProperties(self):
js = super(ContractRule, self).elementProperties()
js.extend([
("contentAttachment", "contentAttachment", attachment.Attachment, False),
("contentReference", "contentReference", fhirreference.FHIRReference, False),
])
return js
class ContractSigner(fhirelement.FHIRElement):
""" Contract Signer.
Party signing this Contract.
"""
resource_name = "ContractSigner"
def __init__(self, jsondict=None):
""" Initialize all valid properties.
"""
self.party = None
""" Contract Signatory Party.
Type `FHIRReference` referencing `Organization, Patient, Practitioner, RelatedPerson` (represented as `dict` in JSON). """
self.signature = None
""" Contract Documentation Signature.
Type `str`. """
self.type = None
""" Contract Signer Type.
Type `Coding` (represented as `dict` in JSON). """
super(ContractSigner, self).__init__(jsondict)
def elementProperties(self):
js = super(ContractSigner, self).elementProperties()
js.extend([
("party", "party", fhirreference.FHIRReference, False),
("signature", "signature", str, False),
("type", "type", coding.Coding, False),
])
return js
class ContractTerm(fhirelement.FHIRElement):
""" Contract Term List.
One or more Contract Provisions, which may be related and conveyed as a
group, and may contain nested groups.
"""
resource_name = "ContractTerm"
def __init__(self, jsondict=None):
""" Initialize all valid properties.
"""
self.action = None
""" Contract Term Action.
List of `CodeableConcept` items (represented as `dict` in JSON). """
self.actionReason = None
""" Contract Term Action Reason.
List of `CodeableConcept` items (represented as `dict` in JSON). """
self.actor = None
""" Contract Term Actor List.
List of `ContractTermActor` items (represented as `dict` in JSON). """
self.applies = None
""" Contract Term Effective Time.
Type `Period` (represented as `dict` in JSON). """
self.group = None
""" Nested Contract Term Group.
List of `ContractTerm` items (represented as `dict` in JSON). """
self.identifier = None
""" Contract Term identifier.
Type `Identifier` (represented as `dict` in JSON). """
self.issued = None
""" Contract Term Issue Date Time.
Type `FHIRDate` (represented as `str` in JSON). """
self.subType = None
""" Contract Term Subtype.
Type `CodeableConcept` (represented as `dict` in JSON). """
self.subject = None
""" Subject of this Contract Term.
Type `FHIRReference` referencing `Resource` (represented as `dict` in JSON). """
self.text = None
""" Human readable Contract term text.
Type `str`. """
self.type = None
""" Contract Term Type.
Type `CodeableConcept` (represented as `dict` in JSON). """
self.valuedItem = None
""" Contract Term Valued Item.
List of `ContractTermValuedItem` items (represented as `dict` in JSON). """
super(ContractTerm, self).__init__(jsondict)
def elementProperties(self):
js = super(ContractTerm, self).elementProperties()
js.extend([
("action", "action", codeableconcept.CodeableConcept, True),
("actionReason", "actionReason", codeableconcept.CodeableConcept, True),
("actor", "actor", ContractTermActor, True),
("applies", "applies", period.Period, False),
("group", "group", ContractTerm, True),
("identifier", "identifier", identifier.Identifier, False),
("issued", "issued", fhirdate.FHIRDate, False),
("subType", "subType", codeableconcept.CodeableConcept, False),
("subject", "subject", fhirreference.FHIRReference, False),
("text", "text", str, False),
("type", "type", codeableconcept.CodeableConcept, False),
("valuedItem", "valuedItem", ContractTermValuedItem, True),
])
return js
class ContractTermActor(fhirelement.FHIRElement):
""" Contract Term Actor List.
List of actors participating in this Contract Provision.
"""
resource_name = "ContractTermActor"
def __init__(self, jsondict=None):
""" Initialize all valid properties.
"""
self.entity = None
""" Contract Term Actor.
Type `FHIRReference` referencing `Contract, Device, Group, Location, Organization, Patient, Practitioner, RelatedPerson, Substance, Supply` (represented as `dict` in JSON). """
self.role = None
""" Contract Term Actor Role.
List of `CodeableConcept` items (represented as `dict` in JSON). """
super(ContractTermActor, self).__init__(jsondict)
def elementProperties(self):
js = super(ContractTermActor, self).elementProperties()
js.extend([
("entity", "entity", fhirreference.FHIRReference, False),
("role", "role", codeableconcept.CodeableConcept, True),
])
return js
class ContractTermValuedItem(fhirelement.FHIRElement):
""" Contract Term Valued Item.
Contract Provision Valued Item List.
"""
resource_name = "ContractTermValuedItem"
def __init__(self, jsondict=None):
""" Initialize all valid properties.
"""
self.effectiveTime = None
""" Contract Term Valued Item Effective Tiem.
Type `FHIRDate` (represented as `str` in JSON). """
self.entityCodeableConcept = None
""" Contract Term Valued Item Type.
Type `CodeableConcept` (represented as `dict` in JSON). """
self.entityReference = None
""" Contract Term Valued Item Type.
Type `FHIRReference` referencing `Resource` (represented as `dict` in JSON). """
self.factor = None
""" Contract Term Valued Item Price Scaling Factor.
Type `float`. """
self.identifier = None
""" Contract Term Valued Item Identifier.
Type `Identifier` (represented as `dict` in JSON). """
self.net = None
""" Total Contract Term Valued Item Value.
Type `Money` (represented as `dict` in JSON). """
self.points = None
""" Contract Term Valued Item Difficulty Scaling Factor.
Type `float`. """
self.quantity = None
""" Contract Term Valued Item Count.
Type `Quantity` (represented as `dict` in JSON). """
self.unitPrice = None
""" Contract Term Valued Item fee, charge, or cost.
Type `Money` (represented as `dict` in JSON). """
super(ContractTermValuedItem, self).__init__(jsondict)
def elementProperties(self):
js = super(ContractTermValuedItem, self).elementProperties()
js.extend([
("effectiveTime", "effectiveTime", fhirdate.FHIRDate, False),
("entityCodeableConcept", "entityCodeableConcept", codeableconcept.CodeableConcept, False),
("entityReference", "entityReference", fhirreference.FHIRReference, False),
("factor", "factor", float, False),
("identifier", "identifier", identifier.Identifier, False),
("net", "net", money.Money, False),
("points", "points", float, False),
("quantity", "quantity", quantity.Quantity, False),
("unitPrice", "unitPrice", money.Money, False),
])
return js
class ContractValuedItem(fhirelement.FHIRElement):
""" Contract Valued Item.
Contract Valued Item List.
"""
resource_name = "ContractValuedItem"
def __init__(self, jsondict=None):
""" Initialize all valid properties.
"""
self.effectiveTime = None
""" Contract Valued Item Effective Tiem.
Type `FHIRDate` (represented as `str` in JSON). """
self.entityCodeableConcept = None
""" Contract Valued Item Type.
Type `CodeableConcept` (represented as `dict` in JSON). """
self.entityReference = None
""" Contract Valued Item Type.
Type `FHIRReference` referencing `Resource` (represented as `dict` in JSON). """
self.factor = None
""" Contract Valued Item Price Scaling Factor.
Type `float`. """
self.identifier = None
""" Contract Valued Item Identifier.
Type `Identifier` (represented as `dict` in JSON). """
self.net = None
""" Total Contract Valued Item Value.
Type `Money` (represented as `dict` in JSON). """
self.points = None
""" Contract Valued Item Difficulty Scaling Factor.
Type `float`. """
self.quantity = None
""" Count of Contract Valued Items.
Type `Quantity` (represented as `dict` in JSON). """
self.unitPrice = None
""" Contract Valued Item fee, charge, or cost.
Type `Money` (represented as `dict` in JSON). """
super(ContractValuedItem, self).__init__(jsondict)
def elementProperties(self):
js = super(ContractValuedItem, self).elementProperties()
js.extend([
("effectiveTime", "effectiveTime", fhirdate.FHIRDate, False),
("entityCodeableConcept", "entityCodeableConcept", codeableconcept.CodeableConcept, False),
("entityReference", "entityReference", fhirreference.FHIRReference, False),
("factor", "factor", float, False),
("identifier", "identifier", identifier.Identifier, False),
("net", "net", money.Money, False),
("points", "points", float, False),
("quantity", "quantity", quantity.Quantity, False),
("unitPrice", "unitPrice", money.Money, False),
])
return js
|
StarcoderdataPython
|
1732667
|
<filename>setup.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""The setup script."""
from setuptools import setup, find_packages
def req_file(filename):
"""
We're using a requirements.txt file so that pyup.io can use this for security checks
:param filename:
:return str:
"""
with open(filename) as f:
content = f.readlines()
content = filter(lambda x: not x.startswith("#"), content)
return [x.strip() for x in content]
with open('README.rst') as readme_file:
readme = readme_file.read()
with open('HISTORY.rst') as history_file:
history = history_file.read()
requirements = ['Click==7.0', 'click-log==0.3.2']
setup_requirements = ['pytest-runner', ]
test_requirements = ['pytest>=3', ]
setup(
author="<NAME>",
author_email='<EMAIL>',
python_requires='>=3.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*',
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Intended Audience :: Developers',
'License :: OSI Approved :: Apache Software License',
'Natural Language :: English',
'Programming Language :: Python :: 3.7',
],
description="Package to merge multiple pair of pair-end fastq data",
entry_points={
'console_scripts': [
'merge_fastq=merge_fastq.cli:main',
],
},
install_requires=requirements,
license="Apache Software License 2.0",
long_description=readme + '\n\n' + history,
include_package_data=True,
keywords='merge_fastq',
name='merge_fastq',
packages=find_packages(include=['merge_fastq', 'merge_fastq.*']),
setup_requires=setup_requirements,
test_suite='tests',
tests_require=test_requirements,
url='https://github.com/rhshah/merge_fastq',
version='0.1.7',
zip_safe=False,
)
|
StarcoderdataPython
|
3271139
|
import json
import os
import sys
from fontTools.pens.recordingPen import RecordingPen
from fontTools.ttLib import TTFont
def getGlyph(glyphSet, cmap, char):
name = cmap[ord(char)]
return glyphSet[name]
def traceFont(font, char):
glyphSet = font.getGlyphSet()
cmap = font.getBestCmap()
glyph = getGlyph(glyphSet, cmap, char)
recordingPen = RecordingPen()
glyph.draw(recordingPen)
return recordingPen.value
def traceStr(font, str):
penValue = []
for c in str:
penValue.append(traceFont(font, c))
return penValue
def validate(args):
usage = 'Usage: python {} FILE characters [-o]'\
.format(__file__)
if len(args) == 1:
print(usage)
return False
return True
def getPath():
path = os.path.dirname(__file__)
if len(path) >= 1:
path += '/'
return path
def getFontPath():
return getPath() + 'font/SourceHanSans-Light.otf'
def getOutputPath(filename):
return getPath() + 'output/' + filename
args = sys.argv
if not validate(args):
exit()
str = args[1]
font = TTFont(getFontPath())
penValue = traceStr(font, str)
jv = json.dumps(penValue, ensure_ascii=False)
if len(args) >= 3 and args[2] == '-o':
with open(getOutputPath(str + '.json'), 'w') as f:
print(jv, file=f)
else:
print(jv)
|
StarcoderdataPython
|
1672955
|
<filename>src/pandas_profiling/report/presentation/flavours/widget/container.py
from ipywidgets import widgets
from pandas_profiling.report.presentation.core.container import Container
from pandas_profiling.report.presentation.core.renderable import Renderable
def get_name(item: Renderable):
if hasattr(item, "name"):
return item.name
else:
return item.anchor_id
def get_tabs(items):
children = []
titles = []
for item in items:
children.append(item.render())
titles.append(get_name(item))
tab = widgets.Tab()
tab.children = children
for id, title in enumerate(titles):
tab.set_title(id, title)
return tab
def get_list(items):
return widgets.VBox([item.render() for item in items])
def get_named_list(items):
return widgets.VBox(
[
widgets.VBox(
[widgets.HTML(f"<strong>{get_name(item)}</strong>"), item.render()]
)
for item in items
]
)
def get_row(items):
if len(items) == 1:
layout = widgets.Layout(width="100%", grid_template_columns="100%")
elif len(items) == 2:
layout = widgets.Layout(width="100%", grid_template_columns="50% 50%")
elif len(items) == 3:
layout = widgets.Layout(width="100%", grid_template_columns="25% 25% 50%")
elif len(items) == 4:
layout = widgets.Layout(width="100%", grid_template_columns="25% 25% 25% 25%")
else:
raise ValueError("Layout undefined for this number of columns")
return widgets.GridBox([item.render() for item in items], layout=layout)
def get_batch_grid(items, batch_size, titles):
layout = widgets.Layout(
width="100%",
grid_template_columns=" ".join([f"{int(100 / batch_size)}%"] * batch_size),
)
return widgets.GridBox([item.render() for item in items], layout=layout)
def get_accordion(items):
children = []
titles = []
for item in items:
children.append(item.render())
titles.append(get_name(item))
accordion = widgets.Accordion(children=children)
for id, title in enumerate(titles):
accordion.set_title(id, title)
return accordion
class WidgetContainer(Container):
def render(self):
if self.sequence_type == "list":
widget = get_list(self.content["items"])
elif self.sequence_type == "named_list":
widget = get_named_list(self.content["items"])
elif self.sequence_type in ["tabs", "sections", "select"]:
widget = get_tabs(self.content["items"])
elif self.sequence_type == "accordion":
widget = get_accordion(self.content["items"])
elif self.sequence_type == "grid":
widget = get_row(self.content["items"])
elif self.sequence_type == "batch_grid":
widget = get_batch_grid(
self.content["items"],
self.content["batch_size"],
self.content.get("titles", True),
)
else:
raise ValueError("widget type not understood", self.sequence_type)
return widget
|
StarcoderdataPython
|
1602109
|
<filename>mirnamotif/parser.py<gh_stars>1-10
"""parser parses pre-miRNA and mature miRNAs sequences from miRBase."""
from Bio import SeqIO
from parser_loop_localization import create_loc
import re
import RNA
def fold(sequence_to_fold):
"""
fold folds pre-miRNA molecules and returns terminal loop.
input: RNA sequence
output: trimmed RNA sequence
"""
p = re.compile('\(\.+\)')
m = p.search(RNA.fold(sequence_to_fold)[0])
return sequence_to_fold[m.start()-1:m.end()+1]
def parse_sh(file_name):
"""
parse_sh parses pre-miRNA sequences for mmu ath and hsa.
sequences from miRBase hairpin.fa file
input: file_name with pre-miRNA sequences
generates six files
output: 0
"""
fasta_sequences = SeqIO.parse(open(file_name), 'fasta')
with open('miR_loops_mmu', 'w') as output_l_mmu, \
open('miR_sh_mmu', 'w') as output_sh_mmu, \
open('miR_loops_ath', 'w') as output_l_ath, \
open('miR_sh_ath', 'w') as output_sh_ath, \
open('miR_loops_hsa', 'w') as output_l_hsa, \
open('miR_sh_hsa', 'w') as output_sh_hsa:
for fasta in fasta_sequences:
if fasta.id[:3] == 'mmu':
output_l_mmu.write(fasta.id + ' ' +
fold(str(fasta.seq)) + '\n')
output_sh_mmu.write(fasta.id + ' ' +
str(fasta.seq) + '\n')
if fasta.id[:3] == 'ath':
output_l_ath.write(fasta.id + ' ' +
fold(str(fasta.seq)) + '\n')
output_sh_ath.write(fasta.id + ' ' +
str(fasta.seq) + '\n')
if fasta.id[:3] == 'hsa':
output_l_hsa.write(fasta.id + ' ' +
fold(str(fasta.seq)) + '\n')
output_sh_hsa.write(fasta.id + ' ' +
str(fasta.seq) + '\n')
return 0
def parse_mature(file_name):
"""
parse_mature parses mature miRNA sequences for mmu ath and hsa.
sequences from miRBase mature.fa file
input: file_name with mature miRNA sequences
generates three files
output: 0
"""
fasta_sequences = SeqIO.parse(open(file_name), 'fasta')
with open('miR_mature_mmu', 'w') as output_mature_mmu, \
open('miR_mature_ath', 'w') as output_mature_ath, \
open('miR_mature_hsa', 'w') as output_mature_hsa:
for fasta in fasta_sequences:
if fasta.id[:3] == 'mmu':
output_mature_mmu.write(fasta.id + ' ' +
str(fasta.seq) + '\n')
if fasta.id[:3] == 'ath':
output_mature_ath.write(fasta.id + ' ' +
str(fasta.seq) + '\n')
if fasta.id[:3] == 'hsa':
output_mature_hsa.write(fasta.id + ' ' +
str(fasta.seq) + '\n')
return 0
if __name__ == "__main__":
parse_sh('hairpin.fa')
parse_mature('mature.fa')
create_loc()
|
StarcoderdataPython
|
1799304
|
import carla
LEAD_VEHICLE_SPEED = 37 #mph
LEAD_X_INIT = -379.6
LEAD_Y_INIT = -17.6
LEAD_Z_INIT = 2.0
LEAD_X_INIT_END = -379.6
LEAD_Y_INIT_END = 0
LEAD_Z_INIT_END = 2.0
INIT_ROUTE = [carla.libcarla.Location(x=LEAD_X_INIT, y=LEAD_Y_INIT, z=0),carla.libcarla.Location(x=LEAD_X_INIT_END, y=LEAD_Y_INIT_END, z=0)]
convoy = None
SPEED_REG = True
def get_convoy_config(convoy_len):
print("convoy_len:",convoy_len)
if convoy_len == 2:
convoy = {
'buffer_len': 6,
'KP': 1.0,
'KI': 1.0,
'KD': 0.1,
'distance_to_stop': 30,
'max_speed': 100
}
elif convoy_len == 3:
convoy = {
'buffer_len': 6,
'KP': 1.0,
'KI': 1.0,
'KD': 0.1,
'distance_to_stop': 30,
'max_speed': 80
}
elif convoy_len == 4:
convoy = {
'buffer_len': 6,
'KP': 1.0,
'KI': 1.0,
'KD': 0.1,
'distance_to_stop': 25,
'max_speed': 80
}
elif convoy_len == 5:
convoy = {
'buffer_len': 6,
'KP': 0.5,
'KI': 0.0,
'KD': 0.0,
'distance_to_stop': 20,
'max_speed': 70
}
elif convoy_len == 6:
convoy = {
'buffer_len': 6,
'KP': 1.0,
'KI': 1.0,
'KD': 0.1,
'distance_to_stop': 15,
'max_speed': 70
}
return convoy
|
StarcoderdataPython
|
1600068
|
<gh_stars>1-10
"""ipshaman Python API driver"""
from ipshaman.core.client import Client
__all__ = [
'Client',
]
__version__ = '0.0.4'
|
StarcoderdataPython
|
1653239
|
from django.shortcuts import render
from django.views.generic import ListView, CreateView, DetailView, UpdateView
from django.contrib.auth.decorators import permission_required, login_required
from django.utils.decorators import method_decorator
from django.contrib import messages
from django.shortcuts import redirect, reverse
# Create your views here.
from .models import Categoria
from django.contrib.auth.models import User
class CategoriaListView(ListView):
model = Categoria
template_name = "categorias/listar_categorias.html"
@method_decorator([login_required, permission_required('categorias.can_add_categoria')], name="dispatch")
class CategoriaUpdateView(UpdateView):
model = Categoria
template_name = "categorias/editar_categoria.html"
fields = '__all__'
# success_url = 'categoria_lista'
def get_context_data(self, **kwargs):
context=super(CategoriaUpdateView, self).get_context_data(**kwargs)
next_page = self.request.GET.get('next')
if next_page:
context["next"] = next_page
return context
def get_success_url(self):
redirect_to = self.request.POST.get('next')
return redirect_to or reverse('categoria_lista')
@method_decorator([login_required, permission_required('categorias.can_change_categoria')], name="dispatch")
class CategoriaCrearView(CreateView):
model = Categoria
template_name = "categorias/crear_categoria.html"
fields = ('nombre', 'descripcion', 'foto')
# success_url = 'categoria_lista'
def get_context_data(self, **kwargs):
context = super(CategoriaCrearView, self).get_context_data(**kwargs)
next_page = self.request.GET.get('next')
if next_page:
context["next"] = next_page
return context
def get_success_url(self):
redirect_to=self.request.POST.get('next')
print(redirect_to)
return redirect_to or reverse('categoria_lista')
@login_required
@permission_required('categorias.can_add_categoria')
def administrar_categorias(request):
if request.user.has_perm('categoria.can_add_categoria'):
categorias = Categoria.objects.all()
contexto = {'categorias': categorias }
return render(request, template_name='categorias/administrar_categorias.html', context=contexto)
@login_required
@permission_required('categorias.can_delete_categoria')
def borrar_categoria(request, id):
try:
categoria = Categoria.objects.get(pk=id)
categoria.delete()
messages.success(request, 'Categoría Borrada')
except Exception:
messages.error(request, 'No se pudo borrar la categoría')
return redirect('categoria_administrar')
def en_categoria(request, pk=None, nombre=None):
if nombre is None:
categoria = Categoria.objects.get(pk=pk)
else:
categoria = Categoria.objects.get(nombre=nombre.title())
# usuarios = categoria.perfiles
print(categoria)
contexto = {'categoria': categoria}#, 'usuarios': usuarios}
return render(request, 'categorias/en_categoria.html', context=contexto)
|
StarcoderdataPython
|
97483
|
class zoo:
def __init__(self,stock,cuidadores,animales):
pass
class cuidador:
def __init__(self,animales,vacaciones):
pass
class animal:
def __init__(self,dieta):
pass
class vacaciones:
def __init__(self):
pass
class comida:
def __init__(self,dieta):
pass
class stock:
def __init__(self,comida):
pass
class carnivoros:
def __init__(self):
pass
class herbivoros:
def __init__(self):
pass
class insectivoros:
def __init__(self):
pass
print("puerca")
|
StarcoderdataPython
|
3258241
|
import numpy as np
import tensorflow as tf
# this is kind of hacky, model_class is the vae_gan class but its parent abstract-class is in the same folder
from jernej_code_vae_gan import Model as model_class, utils
from jernej_code_vae_gan.mnist import mnist_data
from jernej_code_vae_gan.report import Report
import jernej_code_vae_gan.other_util_plotting as util2
from jernej_code_vae_gan.simple_classifier import Classifier as classifier_class
"""
TO RUN: You need to download the trained model weights and put them in the /models folder
Might also need to make the /results folder
"""
# Initialize TensorFlow session.
config = tf.ConfigProto(allow_soft_placement=True)
session = tf.InteractiveSession(config=config)
# Setup reporting.
run = '1'
report_filename = 'report-{}.txt'.format(run)
report = Report('results/' + report_filename)
report.add("Available GPUs", len(utils.get_available_gpus()))
# Load dataset
mnist_wrapper_object = mnist_data()
mnist_dataset = mnist_wrapper_object.get_data()
# Massage dataset
rescale = False
if rescale == True:
util2.rescale_dataset(mnist_dataset)
util2.trim_dataset(mnist_dataset, model_class)
# Load model
version = 'v0'
model_attributes = {
'dataset': mnist_wrapper_object,
'latent_dim': 50,
'version': version
}
model = model_class(session, **model_attributes)
model.build()
model_sample_reconstructions = 0
model.set_defaults(reconstruction={'sampling': model_sample_reconstructions})
checkpoint = 'models/mnist-vae-gan-v0.weights.tfmod'
model.load(checkpoint)
# Try to reconstruct same test images using model to make sure model loaded properly
test_set, test_set_labels = mnist_dataset.test.images[:128], mnist_dataset.test.labels[:128]
utils.plot_digits(mnist_wrapper_object, '{}-originals'.format(mnist_wrapper_object.name), test_set, n=10)
# Plot reconstructions.
with report.add_time_block('time_model_reconstruct_originals'):
original_reconstructions = model.reconstruct(test_set)
if np.isnan(original_reconstructions).any():
print('ERROR: Model produced NaN values for reconstructions.')
exit(1)
utils.plot_digits(mnist_wrapper_object, '{}-{}-reconstructions'.format(mnist_wrapper_object.name, model.name),
original_reconstructions, n=10)
# Plot latent space visualizations.
model_latent_visualization = True
if model_latent_visualization:
util2.latent_visualization(mnist_wrapper_object, mnist_dataset, model, report)
model_latent_distances = True
if model_latent_distances:
util2.report_latent_distances(mnist_wrapper_object, mnist_dataset, model, report)
# Load the classifier
classifier_sample = False
classifier = classifier_class(model, num_classes=mnist_wrapper_object.class_count,
sample=classifier_sample, version=version)
# classifier doesn't actually need model, we should look to remove it from its class
classifier.build()
checkpoint = 'models/mnist-simple-classifier-vae-gan-v0.weights.tfmod'
classifier.load(checkpoint)
# Check classifier accuracy across all classes
with report.add_time_block('time_classifier_evaluate'):
accuracy = classifier.evaluate(mnist_dataset.test.images, mnist_dataset.test.labels)
print('Classifier accuracy:', accuracy)
report.add('classifier_accuracy', accuracy)
# Check classifier accuracy for each class
predictions = classifier.predict(mnist_dataset.test.images)
for label, correct, count, accuracy, _ in utils.accuracy_combinations(
mnist_wrapper_object, mnist_dataset.test.labels, predictions):
print('Classifier accuracy (class={}): {}/{} ({})'.format(
label, correct, count, accuracy))
report.add('original_label{}_correct'.format(label), correct)
report.add('original_label{}_count'.format(label), count)
report.add('original_label{}_accuracy'.format(label), accuracy)
# Save the report.
report.save()
|
StarcoderdataPython
|
1746666
|
from nose.plugins import attrib
gpu = attrib.attr('gpu')
cudnn = attrib.attr('gpu', 'cudnn')
|
StarcoderdataPython
|
41466
|
import logging
import textwrap
from discord.ext import commands
from miyu_bot.bot.bot import D4DJBot
from miyu_bot.commands.common.fuzzy_matching import romanize, FuzzyMatcher
class Utility(commands.Cog):
bot: D4DJBot
def __init__(self, bot):
self.bot = bot
self.logger = logging.getLogger(__name__)
@commands.command(hidden=True)
@commands.is_owner()
async def romanize(self, ctx: commands.Context, *, arg: str):
await ctx.send(romanize(arg))
@commands.command(hidden=True, ignore_extra=False)
@commands.is_owner()
async def similarity_score(self, ctx: commands.Context, source: str, target: str):
await ctx.send(str(FuzzyMatcher().score(romanize(source), romanize(target))))
@commands.command(hidden=True)
@commands.is_owner()
async def shutdown(self, ctx: commands.Context):
await self.bot.logout()
@commands.command(name='eval', hidden=True)
@commands.is_owner()
async def eval_cmd(self, ctx: commands.Context, *, body: str):
env = {
'bot': self.bot,
'ctx': ctx,
'assets': self.bot.assets,
'asset_filters': self.bot.asset_filters,
**globals(),
}
self.bot.asset_filters.cards.default_filter
if body and body[0] == '`' and body[-1] == '`':
body = body[1:-1]
try:
value = eval(body, env)
if value:
await ctx.send(str(value))
else:
await ctx.send('Done')
except Exception as e:
await ctx.send(f'```{e.__class__.__name__}: {e}\n```')
@commands.command(name='exec', hidden=True)
@commands.is_owner()
async def exec_cmd(self, ctx: commands.Context, *, body: str):
env = {
'bot': self.bot,
'ctx': ctx,
'assets': self.bot.assets,
'asset_filters': self.bot.asset_filters,
**globals(),
}
if body and body[:9] == '```python' and body[-3:] == '```':
body = body[9:-3]
if body and body[:3] == '```' and body[-3:] == '```':
body = body[3:-3]
if body and body[:1] == '`' and body[-1:] == '`':
body = body[1:-1]
body = 'async def f():\n' + textwrap.indent(body, ' ')
l = locals()
exec(body, env, l)
f = l['f']
try:
value = await f()
if value:
await ctx.send(str(value))
else:
await ctx.send('Done')
except Exception as e:
await ctx.send(f'```{e.__class__.__name__}: {e}\n```')
@commands.command(name='invite',
aliases=[],
description='Sends the bot invite.',
help='!invite')
async def invite(self, ctx: commands.Context):
await ctx.send(
'https://discord.com/api/oauth2/authorize?client_id=789314370999287808&permissions=388160&scope=bot')
def setup(bot):
bot.add_cog(Utility(bot))
|
StarcoderdataPython
|
1795620
|
import pandas as pd
import json
from jsonschema import validate
from os import path
import sys
import PySimpleGUI as sg
raw_data = None
class_list = None
DayInfo = None
delta_max = None
UUID_to_email = None
def set_data_vars(data_path, json_path):
"""
Sets global data variables to be used in ``ElementCollection.py`` and ``Main.py``, including
* raw_data: the dataframe read from the raw data's csv
* class_list: list of unique emails from raw_data (we assume this is acceptable as a list of everyone in the class)
* DayInfo: the JSON data imported into the program, if the user uses a JSON input
:param data_path: path to the raw_data csv
:param json_path: path to the JSON file, or -1 if the user isn't using a JSON file to provide H5P IDs
"""
global raw_data
global class_list
global DayInfo
global delta_max
global UUID_to_email
raw_data = pd.read_csv(data_path)
# Uncomment below to print the number of bytes the dataframe takes in memory
# print("raw data: " + str(raw_data.memory_usage(index=True, deep=True).sum()))
UUID_to_email = find_emails(raw_data)
# Only keep around columns we care about
raw_data = raw_data[["Name", "Verb", "object id", "Question/Slide", "Timestamp", "Duration", "Response"]]
# Convert the Timestamp column to datetime objects
raw_data["Timestamp"] = pd.to_datetime(raw_data["Timestamp"], errors='coerce')
# Drop all rows where the datetime conversion failed or where email doesn't exist, b/c that means they're bad data
rows_count = len(raw_data.index)
raw_data = raw_data.dropna(subset=["Timestamp"])
rows_dropped_timestamp = rows_count - len(raw_data.index)
# Drop all columns with an NaN email, b/c that's bad data
rows_count = len(raw_data.index)
raw_data = raw_data.dropna(subset=["Name"])
rows_dropped_name_nan = rows_count - len(raw_data.index)
# Drop all columns that don't have a valid email URL, b/c that means they're bad data
# Commented out Spring 2021 when reverting to using UUIDs
# rows_count = len(raw_data.index)
# raw_data = raw_data[raw_data["Email"].str.slice(start=0, stop=7).str.fullmatch("mailto:", case=False)]
# rows_dropped_bad_email = rows_count - len(raw_data.index)
# Reformat email column to remove the "mailto:"
# raw_data["Email"] = raw_data["Email"].str.slice(start=7)
# Give notice popup about dropped rows
if rows_dropped_timestamp != 0 or rows_dropped_name_nan != 0:
sg.Popup("Some data was dropped because of improper formatting:\nBad timestamp: " + str(rows_dropped_timestamp)
+ " entries\nNo UUID associated: " + str(rows_dropped_name_nan) + " entries",
title="Info: Data Dropped")
# Drop all "consumed" verbs b/c they seem to be pretty useless
raw_data = raw_data[raw_data["Verb"] != 'consumed']
# Parse the actual object ID from the "object id" column
url_list = raw_data["object id"].to_list()
id_list = [int(s[s.index("id=") + 3: len(s) if s.find("?", s.index("id=")) == -1 else s.find("?", s.index("id="))])
for s in url_list]
raw_data["object id"] = id_list
# Sort the timestamp column to ensure times are not out of order
raw_data = raw_data.sort_values(by=['Timestamp'], ascending=False)
class_list = set(raw_data["Name"])
# import data in DayElement.json (Error handling done in Main.py)
with open(json_path) as f:
DayInfo = json.load(f)
# Find path to DayElementSchema
bundle_dir = getattr(sys, '_MEIPASS', path.abspath(path.dirname(__file__)))
validation_path = path.abspath(path.join(bundle_dir, 'DayElementSchema.json'))
with open(validation_path) as v:
schema = json.load(v)
# Perform Validation
validate(instance=DayInfo, schema=schema)
# Drop data from non-student emails (using the filter emails list)
# Commented out Spring 2021 upon switch to UUIDs
# raw_data = raw_data[~raw_data["Email"].isin(DayInfo["Filter_Emails"])]
# class_list = class_list - set(DayInfo["Filter_Emails"])
delta_max = DayInfo["Time_Delta"]
def find_emails(df):
# Define an email regex and find responses that are emails
email_regex = '([a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+)'
email_rows = df.Response.str.extract(email_regex, expand=False)
# Transform this into a new df, then into a dictionary mapping name->email
email_df = pd.DataFrame({'Name': df.Name, 'Response': email_rows}).dropna().set_index("Name")
dictionary = email_df.T.to_dict('list') # T = transposition, some wacky stuff from stack overflow
# Remove lists
for key in dictionary:
dictionary[key] = dictionary[key][0]
return dictionary
|
StarcoderdataPython
|
9147
|
from typing import List, Union
import numpy as np
import pandas_datareader as pdr
import pandas as pd
import matplotlib.pyplot as plt
def rsi(symbol :str ,name :str, date :str) -> None :
"""
Calculates and visualises the Relative Stock Index on a Stock of the company.
Parameters:
symbol(str) : Symbol of the company from https://in.finance.yahoo.com/
name(str) : Name of the company
date(str) : start date of historical data in the format (YYYY,M,D)
Returns:
Return type: void
Example:
rsi('GOOG','Google','2020,01,01')
"""
ticker : str = pdr.get_data_yahoo(symbol, date)
delta : List[float] = ticker['Close'].diff()
up : int = delta.clip(lower=0)
down : int = -1*delta.clip(upper=0)
ema_up : Union[bool,float]= up.ewm(com=13, adjust=False).mean()
ema_down : Union[bool,float] = down.ewm(com=13, adjust=False).mean()
rs : float = ema_up/ema_down
ticker['RSI'] = 100 - (100/(1 + rs))
ticker : list = ticker.iloc[14:]
print(ticker)
fig, (ax1, ax2) = plt.subplots(2)
ax1.get_xaxis().set_visible(False)
fig.suptitle(name)
ticker['Close'].plot(ax=ax1)
ax1.set_ylabel('Price ($)')
ticker['RSI'].plot(ax=ax2)
ax2.set_ylim(0,100)
ax2.axhline(30, color='r', linestyle='--')
ax2.axhline(70, color='r', linestyle='--')
ax2.set_ylabel('RSI')
plt.show()
def volatility(symbol :str, date :str) ->None:
"""
Measures and visualizes the Volatility of a Stock by calculating the Average True Range(ATR)
Parameters:
symbol(str) : Symbol of the company from https://in.finance.yahoo.com/
date(str) : start date of historical data in the format (YYYY,M,D)
Returns:
Return type: void
Example:
volatility('GOOG','2020,01,01')
"""
data : str = pdr.get_data_yahoo(symbol,date)
data.head()
high_low : Union[int,float]= data['High'] - data['Low']
high_cp : List[float] = np.abs(data['High'] - data['Close'].shift())
low_cp : List[float]= np.abs(data['Low'] - data['Close'].shift())
df : List[str] = pd.concat([high_low, high_cp, low_cp], axis=1)
true_range : float= np.max(df, axis=1)
average_true_range : float= true_range.rolling(14).mean()
average_true_range
true_range.rolling(14).sum()/14
fig, ax = plt.subplots()
average_true_range.plot(ax=ax)
ax2 : Union[bool,float]= data['Close'].plot(ax=ax, secondary_y=True, alpha=.3)
ax.set_ylabel("ATR")
ax2.set_ylabel("Price")
plt.show()
|
StarcoderdataPython
|
1667223
|
<reponame>AgeYY/prednet<filename>predusion/tools.py
import numpy as np
def tensor_sta(fir_rate, stimuli, n_tao):
'''
spikes triggered average.
input:
fir_rate (array like, float, [n_time_step, ...])
stimuli (array like, float, [n_time_step, ...]): should have the same n_time_step as fir_rate
n_tao (int): how long the sta you want
output:
qij (numpy array, float, [n_tao, *fir_rate.shape[1:], *stimuli.shape[1:]]): the tensor dot of the fir_rate and stimuli
'''
fir_rate_proc = fir_rate[n_tao:] # avoid end effect
norm = np.sum(fir_rate_proc, axis=0)
try:
norm[np.abs(norm) < 1e-10] = 1 # we don't care the norm is no firing rate, the firing rate are all 0s.
except:
pass
fir_rate_proc = fir_rate_proc / norm
fir_rate_n_time = fir_rate_proc.shape[0]
qij = [] # the correlation function
for tao in range(n_tao):
rf_tao = np.tensordot(fir_rate_proc, stimuli[n_tao - tao:n_tao - tao + fir_rate_n_time], axes=([0], [0]))
qij.append(rf_tao.copy())
qij = np.array(qij) # [number of tao time point, number of neurons, *image_shape, 3]
return qij
def confidence_interval(data, measure=np.mean, n_resamples=None, size=None, ci_bound=[2.5, 97.5]):
'''
find the confidence interval of measure(data)
data (np.array, [n_data_points])
meansure: a function whose input is an array output is a number. measure(data)
'''
if n_resamples is None:
n_resamples = data.shape[0]
if size is None:
size = data.shape[0]
measure_arr = np.zeros(n_resamples)
idx_data = np.arange(data.shape[0])
for i in range(n_resamples):
idx_resample = np.random.choice(idx_data, replace=True, size=size) # the batch size is according to https://stats.stackexchange.com/questions/246726/size-of-bootstrap-samples
measure_arr[i] = measure(data[idx_resample])
ci_l, ci_u = np.percentile(measure_arr, ci_bound)
return ci_l, ci_u
if __name__ == '__main__':
import matplotlib.pyplot as plt
radius = 2
n_point = 10
circle_curve = [[radius * np.sin(t), radius * np.cos(t)] for t in np.linspace(0, 2 * np.pi, n_point, endpoint=False)]
circle_curve = np.array(circle_curve)
ct, ct_mean = curvature(circle_curve)
print(ct, ct_mean)
|
StarcoderdataPython
|
1664118
|
from uuid import UUID, uuid4
import numpy as np
from torchdemon.models import InferenceInputData
def uuid_const() -> UUID:
return UUID("009b7240-c7e5-4df3-8722-c1be32390106")
def uuid_rand() -> UUID:
return uuid4()
def ndarray_randint(*args: int) -> np.ndarray:
return np.random.randint(0, 10, size=args)
def ndarray_rand(*args: int) -> np.ndarray:
return np.random.rand(*args)
def inference_input_data() -> InferenceInputData:
return InferenceInputData(
args=[ndarray_randint(2), ndarray_rand(4)], kwargs={"input": ndarray_rand(6)}
)
|
StarcoderdataPython
|
3303283
|
<reponame>chenrb/bk-sops
"""
Tencent is pleased to support the open source community by making 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community
Edition) available.
Copyright (C) 2017-2021 <NAME>, a Tencent company. All rights reserved.
Licensed under the MIT License (the "License"); you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://opensource.org/licenses/MIT
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
"""
from typing import List
from kombu import Exchange, Queue
class PrepareAndStartTaskQueueResolver:
TASK_NAME = "taskflow3.tasks.prepare_and_start_task"
def __init__(self, queue: str):
self.queue = queue
def resolve_task_queue_and_routing_key(self) -> (str, str):
queue_config = self.routes_config()
return queue_config[self.TASK_NAME]["queue"], queue_config[self.TASK_NAME]["routing_key"]
def routes_config(self) -> dict:
suffix = "_%s" % self.queue if self.queue else ""
return {self.TASK_NAME: {"queue": "task_prepare%s" % suffix, "routing_key": "task_prepare%s" % suffix}}
def queues(self) -> List[Queue]:
exchange = Exchange("default", type="direct")
return [
Queue(queue_config["queue"], exchange, routing_key=queue_config["routing_key"], max_priority=255)
for queue_config in self.routes_config().values()
]
|
StarcoderdataPython
|
81879
|
"""dummies.py
helper classes for testing without a connection to Pokemon Showdown
by Annika"""
import psclient
# pylint: disable=super-init-not-called
class DummyWebsocket:
"""Dummy websocket class
"""
def __init__(self, host):
self.host = host
class DummyConnection(psclient.Connection):
"""A modified version of Connection tom be used for offline testing
"""
def __init__(self, loglevel=1):
super().__init__('', '', DummyWebsocket('example.com'), {}, loglevel)
self.roomList = {
psclient.Room("testroom", self), psclient.Room("testroom2", self),
psclient.Room("testroom3", self), psclient.Room("lobby", self)
}
async def send(self, message):
"""The send() method is disabled in DummyConnection
"""
class DummyMessage(psclient.Message):
"""A modified version of Message to be used for offline testing
"""
def __init__(
self, sender=None, arguments=None, room=None, body=None, time=None,
messageType=None, challstr=None, senderName=None, connection=DummyConnection()
):
self.sender = sender
self.arguments = arguments
self.room = room
self.body = body
self.time = time
self.type = messageType
self.challstr = challstr
self.senderName = senderName
self.connection = connection
self.response = None
# (because HTML is an acronym)
self.HTMLResponse = None # pylint: disable=invalid-name
def respond(self, response):
"""Captures the response to a message
Args:
response (string): the response
"""
self.response = response
async def respondHTML(self, html):
"""Captures the HTML response to a message
Args:
html (string): the HTML
"""
self.HTMLResponse = html
class DummyUser(psclient.User):
"""A modified version of User to be used for offline testing
"""
def __init__(self, userid=None, isAdmin=False):
self.id = userid
self.isAdmin = isAdmin
|
StarcoderdataPython
|
1721233
|
from abc import ABCMeta, abstractmethod
import numpy as np
import pandas as pd
from divmachines.utility.helper import check_random_state
def _get_cv(cv):
try:
cv = CROSS_VALIDATOR[cv]
except KeyError:
raise ValueError("Consistent Cross Validator must be provided")
return cv
class CrossValidator(metaclass=ABCMeta):
"""
Base class of the Data Partitioning strategy or
Cross Validation strategy
"""
def __init__(self):
pass
@abstractmethod
def _iter_indices_mask(self, x, y, indices):
raise NotImplementedError
def split(self, x, y):
"""
Data partitioning function,
it returns the training and the test indexes
Parameters
----------
x: ndarray
training samples
y: ndarray
target value for samples
Returns
-------
train_index : ndarray
The training set indices for that split.
test_index : ndarray
The testing set indices for that split.
"""
indices = np.arange(len(x))
for test_index in self._iter_indices_mask(x, y, indices):
train_index = indices[np.logical_not(test_index)]
test_index = indices[test_index]
yield train_index, test_index
class KFold(CrossValidator):
"""
K-fold cross validation strategy
It divides the dataset into k independent fold
and at each iteration considers one fold as the
test set and the remaining folds as the training sets
Parameters
----------
folds: int, optional
Number of fold to use for the k-fold cross validation.
Minimum is 2 an default is 3.
shuffle: boolean, optional
Whether to shuffle the data before splitting into batches.
By default it shuffle the data
random_state : int, RandomState instance or None, optional, default=None
If int, random_state is the seed used by the random number generator;
If RandomState instance, random_state is the random number generator;
If None, the random number generator is the RandomState instance used
by `np.random`. Used when ``shuffle`` == True.
"""
def __init__(self, folds=3, shuffle=True, random_state=None):
super(KFold, self).__init__()
if folds < 2:
raise ValueError("Number of folds too low, minimum value is 2")
else:
self._folds = folds
self._shuffle = shuffle
self._random_state = random_state
def _iter_indices_mask(self, x, y, indices):
if self._shuffle:
check_random_state(self._random_state).shuffle(indices)
n_splits = self._folds
fold_sizes = (len(x) // n_splits) * np.ones(n_splits, dtype=np.int)
fold_sizes[:len(x) % n_splits] += 1
current = 0
mask = np.zeros(len(indices), dtype=np.bool)
for fold_size in fold_sizes:
start, stop = current, current + fold_size
copy_mask = np.copy(mask)
copy_mask[indices[start:stop]] = True
current = stop
yield copy_mask
class LeaveOneOut(CrossValidator):
"""
Leave-One-Out cross-validator
Provides train/test indices to split data in train/test sets. Each
sample is used once as a test set (singleton) while the remaining
samples form the training set.
Parameters
----------
shuffle: boolean, optional
Whether to shuffle the data before splitting into batches.
By default it shuffle the data
random_state : int, RandomState instance or None, optional, default=None
If int, random_state is the seed used by the random number generator;
If RandomState instance, random_state is the random number generator;
If None, the random number generator is the RandomState instance used
by `np.random`. Used when ``shuffle`` == True.
"""
def __init__(self, shuffle=True, random_state=None):
super(LeaveOneOut, self).__init__()
self._shuffle = shuffle
self._random_state = random_state
def _iter_indices_mask(self, x, y, indices):
if self._shuffle:
check_random_state(self._random_state).shuffle(indices)
mask = np.zeros(len(indices), dtype=np.bool)
for i in indices:
new_mask = mask.copy()
new_mask[i] = True
yield new_mask
class NaiveHoldOut(CrossValidator):
"""
Naive Hold-Out cross-validator
Provides train/test indices to split data in train/test sets.
The partitioning is performed by randomly withholding some ratings
for some of the users.
The naive hold-out cross validation removes from the test set all
the user that are not present in the train set.
The classifiers could not handle the cold start problem.
Parameters
----------
ratio: float, optional
Ratio between the train set .
For instance, 0.7 means that the train set is 70% of the
original dataset, while the test set is 30% of it.
Default is 80% for the train set and 20% for the test set.
times: int, optional
Number of times to run Hold-out cross validation.
Higher values of it result in less variance in the result score.
Default is 10.
user_idx: int, optional
Indicates the user column index in the transaction data.
Default is 0.
item_idx: int, optional
Indicates the item column index in the transaction data
Default is 1.
random_state : int, RandomState instance or None, optional, default=None
If int, random_state is the seed used by the random number generator;
If RandomState instance, random_state is the random number generator;
If None, the random number generator is the RandomState instance used
by `np.random`. Used when ``shuffle`` == True.
"""
def __init__(self,
ratio=0.8,
times=10,
user_idx=0,
item_idx=1,
random_state=None):
super(NaiveHoldOut, self).__init__()
self._times = times
self._ratio = ratio
self._user_idx = user_idx
self._item_idx = item_idx
self._random_state = random_state
def split(self, x, y):
data = pd.DataFrame(x)
n_samples = data.shape[0]
indices = np.arange(len(x))
for i in range(self._times):
check_random_state(self._random_state).shuffle(indices)
train_size = int(n_samples * self._ratio)
# split data according to the shuffled index and the holdout size
train_idx = indices[:train_size]
test_idx = indices[train_size:]
# This block of code checks whether the user and the item
# in the test set belong to the train_set otherwise
# they are dropped
# train_split = data.ix[indices[:train_size]]
# test_split = data.ix[indices[train_size:]]
# train_users = train_split[self._user_idx].unique()
# train_items = train_split[self._item_idx].unique()
# test_idx = test_split.index[(test_split[self._user_idx].isin(train_users)) &
# (test_split[self._item_idx].isin(train_items))]
yield train_idx, test_idx
def _iter_indices_mask(self, x, y, indices):
pass
class UserHoldOut(CrossValidator):
"""
User Hold-Out cross-validator
Provides train/test indices to split data in train/test sets.
The partitioning is performed by randomly withholding some ratings
for all or some of the users.
The User Hold-Out cross validation removes from the test set
all the user that are not present in the training set.
Parameters
----------
ratio: float, optional
Ratio between the train set .
For instance, 0.7 means that the train set is 70% of the
original dataset, while the test set is 30% of it.
Default is 80% for the train set and 20% for the test set.
times: int, optional
Number of times to run Hold-out cross validation.
Higher values of it result in less variance in the result score.
Default is 10.
user_idx: int, optional
Indicates the user column index in the transaction data.
Default is 0.
item_idx: int, optional
Indicates the item column index in the transaction data
Default is 1.
random_state : int, RandomState instance or None, optional, default=None
If int, random_state is the seed used by the random number generator;
If RandomState instance, random_state is the random number generator;
If None, the random number generator is the RandomState instance used
by `np.random`. Used when ``shuffle`` == True.
"""
def __init__(self,
ratio=0.8,
times=10,
user_idx=0,
item_idx=1,
random_state=None):
super(UserHoldOut, self).__init__()
self._times = times
self._ratio = ratio
self._user_idx = user_idx
self._item_idx = item_idx
self._random_state = check_random_state(random_state)
def _iter_indices_mask(self, x, y, indices):
data = pd.DataFrame(x)[[self._user_idx, self._item_idx]]
mask = np.zeros(data.shape[0], dtype=np.bool)
for i in range(self._times):
copy_mask = np.copy(mask)
grouped = data.groupby(0)
for _, g in grouped:
idx_shuffled = g.index.values.reshape(-1)
n_observed = int((1 - self._ratio) * len(idx_shuffled))
self._random_state.shuffle(idx_shuffled)
if n_observed == 0:
if self._random_state.randn() < 0.5:
copy_mask[idx_shuffled[0]] = True
else:
copy_mask[idx_shuffled[0:n_observed]] = True
# This block o f code checks whether the user and the item
# in the test set belong to the train_set otherwise
# they are dropped
# # cleaning
# train_split = data.ix[indices[np.logical_not(copy_mask)]]
# test_split = data.ix[indices[copy_mask]]
#
# # remove new user and new items from the test split
# train_items = train_split[self._item_idx].unique()
# test_idx = test_split.index[~test_split[self._item_idx].isin(train_items)]
# copy_mask[test_idx] = False
yield copy_mask
def create_cross_validator(cv):
"""
Return an instance of a cross validator.
Parameters
----------
cv: string, :class:`divmachines.validate`, optional
Determines the cross-validation splitting strategy.
Returns
-------
cv: :class:`divmachines.validate.CrossValidator`
An instance of a Cross Validation strategy
"""
if isinstance(cv, str):
cv = _get_cv(cv)()
elif not hasattr(cv, "split"):
raise ValueError("Input Cross Validator must be an "
"instance child of CrossValidator class")
return cv
CROSS_VALIDATOR = dict(
kFold=KFold,
leaveOneOut=LeaveOneOut,
naiveHoldOut=NaiveHoldOut,
userHoldOut=UserHoldOut
)
|
StarcoderdataPython
|
3217094
|
<reponame>tomasdubec/openstack-cinder
# Copyright 2011 OpenStack LLC. # All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""
Tests For Scheduler Host Filters.
"""
import httplib
import stubout
from cinder import context
from cinder import db
from cinder import exception
from cinder.openstack.common import jsonutils
from cinder.openstack.common.scheduler import filters
from cinder import test
from cinder.tests.scheduler import fakes
from cinder.tests import utils as test_utils
from cinder import utils
DATA = ''
def stub_out_https_backend(stubs):
"""
Stubs out the httplib.HTTPRequest.getresponse to return
faked-out data instead of grabbing actual contents of a resource
The stubbed getresponse() returns an iterator over
the data "I am a teapot, short and stout\n"
:param stubs: Set of stubout stubs
"""
class FakeHTTPResponse(object):
def read(self):
return DATA
def fake_do_request(self, *args, **kwargs):
return httplib.OK, FakeHTTPResponse()
class HostFiltersTestCase(test.TestCase):
"""Test case for host filters."""
def setUp(self):
super(HostFiltersTestCase, self).setUp()
self.stubs = stubout.StubOutForTesting()
stub_out_https_backend(self.stubs)
self.context = context.RequestContext('fake', 'fake')
self.json_query = jsonutils.dumps(
['and', ['>=', '$free_capacity_gb', 1024],
['>=', '$total_capacity_gb', 10 * 1024]])
# This has a side effect of testing 'get_filter_classes'
# when specifying a method (in this case, our standard filters)
filter_handler = filters.HostFilterHandler('cinder.scheduler.filters')
classes = filter_handler.get_all_classes()
self.class_map = {}
for cls in classes:
self.class_map[cls.__name__] = cls
def _stub_service_is_up(self, ret_value):
def fake_service_is_up(service):
return ret_value
self.stubs.Set(utils, 'service_is_up', fake_service_is_up)
@test.skip_if(not test_utils.is_cinder_installed(),
'Test requires Cinder installed')
def test_capacity_filter_passes(self):
self._stub_service_is_up(True)
filt_cls = self.class_map['CapacityFilter']()
filter_properties = {'size': 100}
service = {'disabled': False}
host = fakes.FakeHostState('host1',
{'free_capacity_gb': 200,
'updated_at': None,
'service': service})
self.assertTrue(filt_cls.host_passes(host, filter_properties))
@test.skip_if(not test_utils.is_cinder_installed(),
'Test requires Cinder installed')
def test_capacity_filter_fails(self):
self._stub_service_is_up(True)
filt_cls = self.class_map['CapacityFilter']()
filter_properties = {'size': 100}
service = {'disabled': False}
host = fakes.FakeHostState('host1',
{'free_capacity_gb': 120,
'reserved_percentage': 20,
'updated_at': None,
'service': service})
self.assertFalse(filt_cls.host_passes(host, filter_properties))
@test.skip_if(not test_utils.is_cinder_installed(),
'Test requires Cinder installed')
def test_capacity_filter_passes_infinite(self):
self._stub_service_is_up(True)
filt_cls = self.class_map['CapacityFilter']()
filter_properties = {'size': 100}
service = {'disabled': False}
host = fakes.FakeHostState('host1',
{'free_capacity_gb': 'infinite',
'updated_at': None,
'service': service})
self.assertTrue(filt_cls.host_passes(host, filter_properties))
@test.skip_if(not test_utils.is_cinder_installed(),
'Test requires Cinder installed')
def test_capacity_filter_passes_unknown(self):
self._stub_service_is_up(True)
filt_cls = self.class_map['CapacityFilter']()
filter_properties = {'size': 100}
service = {'disabled': False}
host = fakes.FakeHostState('host1',
{'free_capacity_gb': 'unknown',
'updated_at': None,
'service': service})
self.assertTrue(filt_cls.host_passes(host, filter_properties))
@test.skip_if(not test_utils.is_cinder_installed(),
'Test requires Cinder installed')
def test_retry_filter_disabled(self):
# Test case where retry/re-scheduling is disabled.
filt_cls = self.class_map['RetryFilter']()
host = fakes.FakeHostState('host1', {})
filter_properties = {}
self.assertTrue(filt_cls.host_passes(host, filter_properties))
@test.skip_if(not test_utils.is_cinder_installed(),
'Test requires Cinder installed')
def test_retry_filter_pass(self):
# Node not previously tried.
filt_cls = self.class_map['RetryFilter']()
host = fakes.FakeHostState('host1', {})
retry = dict(num_attempts=2, hosts=['host2'])
filter_properties = dict(retry=retry)
self.assertTrue(filt_cls.host_passes(host, filter_properties))
@test.skip_if(not test_utils.is_cinder_installed(),
'Test requires Cinder installed')
def test_retry_filter_fail(self):
# Node was already tried.
filt_cls = self.class_map['RetryFilter']()
host = fakes.FakeHostState('host1', {})
retry = dict(num_attempts=1, hosts=['host1'])
filter_properties = dict(retry=retry)
self.assertFalse(filt_cls.host_passes(host, filter_properties))
|
StarcoderdataPython
|
1624412
|
<gh_stars>1-10
import requests
from bs4 import BeautifulSoup
import pprint
res = requests.get('https://news.ycombinator.com/news')
soup = BeautifulSoup(res.text, 'html.parser') ## html.parser gives us an html doc instead of string which we can than manipulate
links = soup.select('.storylink')
subtext = soup.select('.subtext')
def sort_Stories_by_points(hnlist):
return sorted(hnlist,key= lambda k:k['votes'] ,reverse=True)
def custom_hn(links, subtext):
hn = []
for idx, item in enumerate(links):
title = item.getText()
href = item.get('href')
vote = subtext[idx].select('.score')
if len(vote):
points = int(vote[0].getText().replace(' points', ''))
if points > 99:
hn.append({'title':title, 'href': href, 'votes':points})
return sort_Stories_by_points(hn)
pprint.pprint(custom_hn(links, subtext))
|
StarcoderdataPython
|
118457
|
<reponame>murd0/codonPython<gh_stars>0
from setuptools import setup, find_packages
setup(
name='codonPython',
version='0.1',
license='BSD',
packages=['codonPython',],
install_required=[
'numpy',
're',
'pandas',
'random',
'sqlalchemy'
],
author='NHS Digital DIS Team',
author_email='<EMAIL>',
url='https://digital.nhs.uk/data-and-information',
description='This is a first attempt at how our package will work.'
)
|
StarcoderdataPython
|
192484
|
<filename>dailyReport/migrations/0008_auto_20220109_1959.py<gh_stars>0
# Generated by Django 3.2 on 2022-01-09 18:59
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('dailyReport', '0007_auto_20220109_1951'),
]
operations = [
migrations.CreateModel(
name='Pastry',
fields=[
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('product', models.CharField(choices=[('meat_pie', 'Meat Pie'), ('chicken_pie', 'Chicken Pie'), ('doughnut', 'Doughnut')], max_length=255)),
],
),
migrations.DeleteModel(
name='Pastries',
),
migrations.AddField(
model_name='rawmaterialrecieved',
name='pastry',
field=models.CharField(choices=[('meat_pie', 'Meat Pie'), ('chicken_pie', 'Chicken Pie'), ('doughnut', 'Doughnut')], default='meat_pie', max_length=50),
preserve_default=False,
),
]
|
StarcoderdataPython
|
4814880
|
import time
import shutil
# from manimlib.scene.scene_file_writer import SceneFileWriter
from manimlib import Scene, Point, Camera, ShowCreation, Write, Color, VGroup, VMobject
from manimlib.utils.rate_functions import linear, smooth
from manimlib.extract_scene import get_scene_config
import manimlib.config
from manimlib.utils.color import rgb_to_hex
from sparrow import ppath
import manimlib.mobject.svg.tex_mobject
from pathlib import Path
from manimlib.event_handler.event_type import EventType
from manimlib.event_handler import EVENT_DISPATCHER
from manimlib.logger import log
import numpy as np
class SceneGL(Scene):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.camera: Camera
self.pause = 0
if self.preview:
global key, Window
from pyglet.window import key
from manimlib.window import Window
def on_mouse_drag(self, point, d_point, buttons, modifiers):
self.mouse_drag_point.move_to(point)
event_data = {"point": point, "d_point": d_point, "buttons": buttons, "modifiers": modifiers}
propagate_event = EVENT_DISPATCHER.dispatch(EventType.MouseDragEvent, **event_data)
if propagate_event is not None and propagate_event is False:
return
frame = self.camera.frame
# Left mouse button
if buttons == 1:
frame.increment_theta(-d_point[0] * 1.5)
frame.increment_phi(d_point[1] * 1.5)
# Right mouse button
elif buttons == 4:
shift = -d_point
shift[0] *= frame.get_width() / 2
shift[1] *= frame.get_height() / 2
transform = frame.get_inverse_camera_rotation_matrix()
shift = np.dot(np.transpose(transform), shift)
frame.shift(shift)
def on_mouse_scroll(self, point, offset):
event_data = {"point": point, "offset": offset}
propagate_event = EVENT_DISPATCHER.dispatch(EventType.MouseScrollEvent, **event_data)
if propagate_event is not None and propagate_event is False:
return
frame = self.camera.frame
if self.window.is_key_pressed(key.Z) or self.window.is_key_pressed(key.LCTRL):
factor = 1 + np.arctan(27 * offset[1])
frame.scale(1 / factor, about_point=point)
else:
transform = frame.get_inverse_camera_rotation_matrix()
shift = np.dot(np.transpose(transform), offset)
frame.shift(-100.0 * shift)
def on_key_press(self, symbol, modifiers):
try:
char = chr(symbol)
except OverflowError:
log.warning("The value of the pressed key is too large.")
return
event_data = {"symbol": symbol, "modifiers": modifiers}
propagate_event = EVENT_DISPATCHER.dispatch(EventType.KeyPressEvent, **event_data)
if propagate_event is not None and propagate_event is False:
return
if symbol == key.R:
self.camera.frame.to_default_state()
elif symbol in (key.Q, key.TAB, key.ENTER): # key.APOSTROPHE,
self.quit_interaction = True
elif symbol in (key.SPACE, key.LALT, key.RALT):
self.pause = self.pause ^ 1
time_pause_start = time.time()
if self.pause:
print("\nPausing animation...")
if not self.pause:
print("\n Continue")
while self.pause == 1:
self.window: Window
self.window.clear()
if symbol == key.SPACE:
self.camera.clear()
self.camera.capture(*self.mobjects)
self.window.swap_buffers()
time_delta = time.time() - time_pause_start
self.real_animation_start_time += time_delta
else:
self._clip_control(symbol)
def _clip_control(self, symbol):
pass
|
StarcoderdataPython
|
1702089
|
# (c) 2019 Red Hat Inc.
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible. If not, see <http://www.gnu.org/licenses/>.
# Make coding more python3-ish
from __future__ import absolute_import, division, print_function
__metaclass__ = type
from textwrap import dedent
from ansible_collections.cisco.nxos.tests.unit.compat.mock import patch
from ansible_collections.cisco.nxos.tests.unit.modules.utils import (
AnsibleFailJson,
)
from ansible_collections.cisco.nxos.plugins.modules import nxos_vlans
from ansible_collections.cisco.nxos.plugins.module_utils.network.nxos.config.vlans.vlans import (
Vlans,
)
from .nxos_module import TestNxosModule, load_fixture, set_module_args
ignore_provider_arg = True
class TestNxosVlansModule(TestNxosModule):
module = nxos_vlans
def setUp(self):
super(TestNxosVlansModule, self).setUp()
self.mock_FACT_LEGACY_SUBSETS = patch(
"ansible_collections.cisco.nxos.plugins.module_utils.network.nxos.facts.facts.FACT_LEGACY_SUBSETS"
)
self.FACT_LEGACY_SUBSETS = self.mock_FACT_LEGACY_SUBSETS.start()
self.mock_get_resource_connection_config = patch(
"ansible_collections.ansible.netcommon.plugins.module_utils.network.common.cfg.base.get_resource_connection"
)
self.get_resource_connection_config = (
self.mock_get_resource_connection_config.start()
)
self.mock_get_resource_connection_facts = patch(
"ansible_collections.ansible.netcommon.plugins.module_utils.network.common.facts.facts.get_resource_connection"
)
self.get_resource_connection_facts = (
self.mock_get_resource_connection_facts.start()
)
self.mock_edit_config = patch(
"ansible_collections.cisco.nxos.plugins.module_utils.network.nxos.config.vlans.vlans.Vlans.edit_config"
)
self.edit_config = self.mock_edit_config.start()
self.mock_get_device_data = patch(
"ansible_collections.cisco.nxos.plugins.module_utils.network.nxos.facts.vlans.vlans.VlansFacts.get_device_data"
)
self.get_device_data = self.mock_get_device_data.start()
self.mock_get_platform = patch(
"ansible_collections.cisco.nxos.plugins.module_utils.network.nxos.config.vlans.vlans.Vlans.get_platform"
)
self.get_platform = self.mock_get_platform.start()
def tearDown(self):
super(TestNxosVlansModule, self).tearDown()
self.mock_FACT_LEGACY_SUBSETS.stop()
self.mock_get_resource_connection_config.stop()
self.mock_get_resource_connection_facts.stop()
self.mock_edit_config.stop()
self.mock_get_platform.stop()
def prepare(self, test=""):
if test == "_no_facts":
self.get_device_data.side_effect = self.load_from_file_no_facts
else:
self.get_device_data.side_effect = self.load_from_file
self.get_platform.return_value = "N9K-NXOSv"
def load_from_file(self, *args, **kwargs):
cmd = args[1]
filename = str(cmd).split(" | ", 1)[0].replace(" ", "_")
return load_fixture("nxos_vlans", filename)
def load_from_file_no_facts(self, *args, **kwargs):
cmd = args[1]
filename = str(cmd).split(" | ", 1)[0].replace(" ", "_")
filename += "_no_facts"
return load_fixture("nxos_vlans", filename)
def test_1(self):
"""
**NOTE** This config is for reference only! See fixtures files for real data.
vlan 1,3-5,8
vlan 3
name test-vlan3
!Note:vlan 4 is present with default settings
vlan 5
shutdown
name test-changeme
mode fabricpath
state suspend
vn-segment 942
!Note:vlan 7 is not present
vlan 8
shutdown
name test-changeme-not
state suspend
"""
self.prepare()
self.get_platform.return_value = "N7K-Cxxx"
playbook = dict(
config=[
dict(vlan_id=4),
dict(vlan_id=5, mapped_vni=555, mode="ce"),
dict(
vlan_id=7, mapped_vni=777, name="test-vlan7", enabled=False
),
dict(vlan_id="8", state="active", name="test-changeme-not")
# vlan 3 is not present in playbook.
]
)
merged = [
# Update existing device states with any differences in the playbook.
"vlan 5",
"vn-segment 555",
"mode ce",
"vlan 7",
"vn-segment 777",
"name test-vlan7",
"shutdown",
"vlan 8",
"state active",
]
playbook["state"] = "merged"
set_module_args(playbook, ignore_provider_arg)
self.execute_module(changed=True, commands=merged)
self.get_platform.return_value = "N9K-NXOSv"
deleted = [
# Reset existing device state to default values. Scope is limited to
# objects in the play when the 'config' key is specified. For vlans
# this means deleting each vlan listed in the playbook and ignoring
# any play attrs other than 'vlan_id'.
"no vlan 4",
"no vlan 5",
"no vlan 8",
]
playbook["state"] = "deleted"
set_module_args(playbook, ignore_provider_arg)
self.execute_module(changed=True, commands=deleted)
self.get_platform.return_value = "N5K-Cxxx"
overridden = [
# The play is the source of truth. Similar to replaced but the scope
# includes all objects on the device; i.e. it will also reset state
# on objects not found in the play.
"no vlan 1",
"no vlan 3",
"vlan 5",
"mode ce",
"vn-segment 555",
"no state",
"no shutdown",
"no name",
"vlan 8",
"no shutdown",
"state active",
"vlan 7",
"name test-vlan7",
"shutdown",
"vn-segment 777",
]
playbook["state"] = "overridden"
set_module_args(playbook, ignore_provider_arg)
self.execute_module(changed=True, commands=overridden)
self.get_platform.return_value = "N7K-NXOSv"
replaced = [
# Scope is limited to objects in the play.
# replaced should ignore existing vlan 3.
"vlan 5",
"mode ce",
"vn-segment 555",
"no state",
"no shutdown",
"no name",
"vlan 7",
"shutdown",
"name test-vlan7",
"vn-segment 777",
"vlan 8",
"no shutdown",
"state active",
]
playbook["state"] = "replaced"
set_module_args(playbook, ignore_provider_arg)
self.execute_module(changed=True, commands=replaced)
def test_2(self):
# Test when no 'config' key is used in playbook.
self.prepare()
deleted = [
"no vlan 1",
"no vlan 3",
"no vlan 4",
"no vlan 5",
"no vlan 8",
]
playbook = dict(state="deleted")
set_module_args(playbook, ignore_provider_arg)
self.execute_module(changed=True, commands=deleted)
for test_state in ["merged", "replaced", "overridden"]:
set_module_args(dict(state=test_state), ignore_provider_arg)
self.execute_module(failed=True)
def test_3(self):
# Test no facts returned
self.prepare(test="_no_facts")
playbook = dict(state="deleted")
set_module_args(playbook, ignore_provider_arg)
self.execute_module(changed=False)
def test_4(self):
self.prepare()
# Misc tests to hit codepaths highlighted by code coverage tool as missed.
playbook = dict(config=[dict(vlan_id=8, enabled=True)])
replaced = [
# Update existing device states with any differences in the playbook.
"vlan 8",
"no shutdown",
"no state",
"no name",
]
playbook["state"] = "replaced"
playbook["_ansible_check_mode"] = True
set_module_args(playbook, ignore_provider_arg)
self.execute_module(changed=True, commands=replaced)
def test_5(self):
"""
Idempotency test
"""
self.prepare()
playbook = dict(
config=[
dict(vlan_id=1, name="default", enabled=True),
dict(vlan_id=3, name="test-vlan3", enabled=True),
dict(vlan_id=4, enabled=True),
dict(
vlan_id=5,
name="test-changeme",
mapped_vni=942,
state="suspend",
enabled=False,
),
dict(
vlan_id=8,
name="test-changeme-not",
state="suspend",
enabled=False,
),
]
)
playbook["state"] = "merged"
set_module_args(playbook, ignore_provider_arg)
r = self.execute_module(changed=False)
playbook["state"] = "overridden"
set_module_args(playbook, ignore_provider_arg)
r = self.execute_module(changed=False)
playbook["state"] = "replaced"
set_module_args(playbook, ignore_provider_arg)
r = self.execute_module(changed=False)
|
StarcoderdataPython
|
37994
|
<gh_stars>1-10
from collections import Counter
from konlpy.tag import Hannanum
import pytagcloud
f = open('D:\\KYH\\02.PYTHON\\crawled_data\\cbs2.txt', 'r', encoding='UTF-8')
data = f.read()
nlp = Hannanum()
nouns = nlp.nouns(data)
count = Counter(nouns)
tags2 = count.most_common(200)
taglist = pytagcloud.make_tags(tags2, maxsize=80)
pytagcloud.create_tag_image(taglist, 'D:\\KYH\\02.PYTHON\\crawled_data\\wordcloud.jpg', size=(400, 300), fontname='korean', rectangular=False)
f.close()
|
StarcoderdataPython
|
46300
|
<filename>backend/apps/users/filters.py
from django_filters import rest_framework as filters
from django.db.models import Q
from django.contrib.auth import get_user_model
from users.models import tGroup
User = get_user_model()
class UsersFilter(filters.FilterSet):
'''
用户过滤
'''
username = filters.CharFilter(lookup_expr='icontains')
mobile = filters.CharFilter(lookup_expr='icontains')
email = filters.CharFilter(lookup_expr='icontains')
class Meta:
model = User
fields = ('username', 'mobile', 'email', 'is_active')
class tGroupFilter(filters.FilterSet):
'''
用户组过滤
'''
name = filters.CharFilter(lookup_expr='icontains')
class Meta:
model = tGroup
fields = ('name',)
|
StarcoderdataPython
|
1780897
|
<gh_stars>0
"""
Description: filereader client
"""
import os
import logging
import csv
from core.general.exceptions import SIDException
from core.general.sidhelper import generate_filename, convert_field
class Reader():
"""
The class responsiblities are:
Read csv file, header record etc
if you want to use this class on its own then
setup filename and call setup(), read()
"""
def __init__(self, *args, **kwargs):
self.filename = None
self.fileptr = None
self.reader = None
self.filesize = 0
self.header_fields = []
self.encoding = 'utf-8-sig'
self.delimiter = ','
self.lineterminator = '\n'
allowed_fields = set(['user_id', 'run_date', 'config'])
for field in allowed_fields:
try:
setattr(self, field, kwargs[field])
except Exception:
setattr(self, field, None)
if not self.config.encoding or self.config.encoding == 'utf-8':
self.encoding = 'utf-8-sig'
else:
self.encoding = self.config.encoding
if not self.config.delimiter:
self.delimiter = ','
else:
self.delimiter = self.config.delimiter
if not self.config.lineterminator or \
self.config.lineterminator in ['LF', '\n']:
self.lineterminator = '\n'
else:
self.lineterminator = '\r\n'
def get_filename(self):
"""
get the filename from config
"""
if not self.config.filepath or not self.config.filestartwith:
raise SIDException('Mandatory field is missing', 'filename')
self.filename = generate_filename(
self.config.filepath,
self.config.filestartwith,
self.config.fileendwith,
self.run_date,
self.config.filemask
)
def set_filename(self, filename):
"""
set the filename
"""
self.filename = filename
def setup(self):
"""
setup connection
"""
self.get_filename()
if not os.path.isfile(self.filename):
return False
self.open()
def open(self):
"""
open file
"""
self.fileptr = open(
self.filename,
mode='r',
encoding=self.encoding)
self.reader = csv.DictReader(
self.fileptr, quotechar='"',
delimiter=self.delimiter,
quoting=csv.QUOTE_ALL,
skipinitialspace=True,
lineterminator=self.lineterminator)
if not self.reader:
raise SIDException('error reading file', self.filename)
size = os.path.getsize(self.filename)
try:
self.filesize = size / 1024 / 1024
except Exception:
logging.error('Error reading file size')
@property
def header(self):
"""
return header
"""
self.fetchheader()
return self.header_fields
@property
def input_object(self):
if self.filename:
return os.path.basename(self.filename)
return None
def fetchmodel(self):
"""
get model record
"""
modellist = []
"""
populate model record
this is filename with datetime stamp
"""
name = self.file_name
record = {
'name': name,
'label': None,
'readable': None,
'writeable': None
}
modellist.append(record)
return modellist
def fetchheader(self):
"""
get header record
"""
if self.reader:
for field in self.reader.fieldnames:
"""
populate header record
in future we will derive the datatype
"""
self.header_fields.append(convert_field(field))
return self.header_fields
def read(self):
"""
get file details
"""
for record in self.reader:
yield record
def down(self):
"""
clean up
"""
if self.fileptr:
self.fileptr.close()
|
StarcoderdataPython
|
186162
|
class HandlerMissingException(Exception):
"""Raised when an event handler is missing a handler for a specific event."""
pass
class DataTypeError(Exception):
"""Raised when data type doesn't correspond to the connection's data type."""
pass
class HeaderSizeError(Exception):
"""Raised when the header's size is greater than the protocol's header size."""
pass
class DataSizeError(Exception):
"""Raised the data size doesn't correspond to the connection's data size."""
pass
|
StarcoderdataPython
|
3303711
|
from penteston.onenote import OneNoteAPI
from jinja2 import Environment, FileSystemLoader
import json
import argparse
import pyperclip
def main(ona):
parser = argparse.ArgumentParser()
parser.add_argument('profile', metavar='profile',
type=str, help='Path to Configuration JSON')
parser.add_argument('--notebook', metavar='notebook', type=str,
help='OneNote Notebook to work with. Must exist.')
parser.add_argument('--section', metavar='section', type=str,
help='Section within OneNote Notebook to work with.')
parser.add_argument('--pagename', metavar='page', type=str,
help='Path within OneNote Notebook to work with.')
parser.add_argument('--create', default=False, action='store_true')
parser.add_argument('--pid', action="store",default=None)
parser.add_argument('--list', default=False, action='store_true')
parser.add_argument('--pagetemplate', metavar='pageTemplate',
default='template.html', help='Path to jinja template to create page.')
parser.add_argument('--nmaptemplate', metavar='nmapTemplate',
default='nmapservice.html', help='Path to jinja template to create nmap table.')
parser.add_argument('--dump', default=False, action='store_true')
parser.add_argument('--dumpids', default=False, action='store_true')
parser.add_argument('--contentclip', default=False, action='store_true')
parser.add_argument('--nmapxml', action="store",default=None)
parser.add_argument('--contentid', action="store",default=None)
parser.add_argument('--content', action="store",default=None)
parser.add_argument('--pw', action="store",default=None)
parser.add_argument('--pwclip', default=False, action='store_true')
parser.add_argument('--pwall', default=False, action='store_true')
parser.add_argument('--updatetbl', action="store",default=None)
parser.add_argument('--updatetblid', action="store",default=None)
parser.add_argument('--matchtbl', action="store",default=None)
args = parser.parse_args()
file_loader = FileSystemLoader('templates')
env = Environment(loader=file_loader)
config=json.load(open(args.profile,"r"))
ona._auth(config["client_id"], config["authority"],config["scope"])
if "access_token" in ona.auth:
#graph_data = requests.get( "https://graph.microsoft.com/v1.0/me", headers={'Authorization': 'Bearer ' + result['access_token']},).json()
#print("Graph API call result: %s" % json.dumps(graph_data, indent=2))
me = ona._me()
if args.list and not args.notebook:
print(ona._notebooks())
return
nid =ona._notebook(args.notebook)
if nid:
if args.list and not args.section:
print(ona._sections(nid))
return
if args.list and not args.pagename and not args.pid:
print(ona._pages(nid,args.section))
if args.create and args.pagename:
sid = ona._section(nid, args.section)
if not sid:
sid = _createSection(nid, args.section)
template = env.get_template(args.pagetemplate)
body = template.render(title=args.pagename, args=args, me=me)
pid = ona._createPage(sid, body)
print("Created: %s" % pid)
elif args.pid:
pid=args.pid
try:
ids=ona._pageIds( pid)
if args.dumpids:
print(json.dumps(ids, indent=2))
if args.nmapxml:
template = env.get_template(args.nmaptemplate)
atemplate = env.get_template("nmap-a.html")
btemplate = env.get_template("nmap-b.html")
ona._nmap(pid,_getIdForDataId(ids,"nmap-service-output"),template,atemplate,btemplate,args.nmapxml)
if args.contentid:
centent=""
if args.contentclip:
content=pyperclip.paste()
print(content)
else:
content=args.content
ona._updatePageSection(pid,content,ona._getIdForDataId(ids,args.contentid),"append")
if args.pw or args.pwclip:
fpw=None
if args.pw:
fpw=open(args.pw)
elif args.pwclip:
fpw=io.StringIO(pyperclip.paste())
for l in fpw:
s=l.split(":")
if not args.pwall and int(s[2])<499 and int(s[2])>0:
continue
print(s[0])
if args.updatetblid and args.updatetbl and args.matchtbl:
t=_getDataIdElement(result,pid,args.updatetblid)
ona._updateRow(t,json.loads(args.matchtbl),json.loads(args.updatetbl))
c=lxml.html.tostring(t,encoding="unicode")
ona._updatePageSection(result,pid,c ,ona._getIdForDataId(ids,args.updatetblid),"replace")
except:
pass
if args.dump:
print(ona._pageContent(pid))
else:
print(result.get("error"))
print(result.get("error_description"))
# You may need this when reporting a bug
print(result.get("correlation_id"))
if __name__ == "__main__":
# execute only if run as a script
app=OneNoteAPI()
main(app)
|
StarcoderdataPython
|
12294
|
<reponame>kplachkov/UkDatabase
import pymongo
from bson.json_util import dumps
from pymongo import MongoClient
from UkDatabaseAPI.database.database import Database
from UkDatabaseAPI.database.query_builder.mongo_query_builder import MongoQueryBuilder
MONGO_URI = "mongodb://localhost:27017"
"""str: The MongoDB URI."""
class MongoDB(Database):
def __init__(self):
"""Client for a MongoDB instance."""
# Opening db connection.
self.__client = MongoClient(MONGO_URI)
self.__db = self.__client.UkDatabase
def __del__(self):
"""Close the connection."""
self.close_connection()
def crate_collection_text_index(self):
"""Create a text index for the collection."""
self.__db.posts.create_index([('TEXT', pymongo.TEXT)], name='text', default_language='english')
def close_connection(self):
"""Close the connection."""
self.__client.close()
def find_posts(self, text: str, post_pub_date: str, number_of_results: int) -> str:
"""Find posts containing text or/and within a time range.
Args:
text: The text search criterion, from the URL argument.
post_pub_date: The date or time range search criterion, from the URL argument.
number_of_results: The number of results to return, from the URL argument.
Returns:
The posts containing the text or/and within a time range.
"""
queries = {}
if text:
queries.update(MongoQueryBuilder
.get_query_for_search_by_text(text))
if post_pub_date:
queries.update(MongoQueryBuilder
.get_query_for_search_by_post_date(post_pub_date))
result = self.__db.posts.find({"$and": [queries]}, {"score": {"$meta": "textScore"}})
if number_of_results:
# If int argument provided by the URL, the results are limited and sorted.
result = result.sort([("score", {"$meta": "textScore"})]).limit(number_of_results)
else:
# Return all matched results sorted.
result = result.sort([("score", {"$meta": "textScore"})])
return dumps(result)
|
StarcoderdataPython
|
3237908
|
# -*- coding: utf-8 -*-
# Copyright (c) 2020, <NAME> and Contributors
# License: QL. See license.txt
import frappe
import os, json
from frappe import _
from frappe.modules import scrub, get_module_path
from frappe.utils import (
flt,
cint,
cstr,
get_html_format,
get_url_to_form,
gzip_decompress
)
from frappe.desk.query_report import(
get_report_doc,
get_prepared_report_result,
generate_report_result
)
from frappe.model.utils import render_include
from six import string_types, iteritems
@frappe.whitelist()
@frappe.read_only()
def run(report_name, filters=None, user=None, ignore_prepared_report=False, custom_columns=None):
report = get_report_doc(report_name)
if not user:
user = frappe.session.user
if not frappe.has_permission(report.ref_doctype, "report"):
frappe.msgprint(_("Must have report permission to access this report."),
raise_exception=True)
result = None
if report.prepared_report and not report.disable_prepared_report and not ignore_prepared_report and not custom_columns:
if filters:
if isinstance(filters, string_types):
filters = json.loads(filters)
dn = filters.get("prepared_report_name")
filters.pop("prepared_report_name", None)
else:
dn = ""
result = get_prepared_report_result(report, filters, dn, user)
else:
result = generate_report_result(report, filters, user, custom_columns)
result["add_total_row"] = report.add_total_row and not result.get('skip_total_row', False)
allowed_roles= ['Accounts Manager']
if "result" not in result:
return result
for ar in allowed_roles:
if ar in frappe.get_roles():
return result
if(report_name == "Stock Ledger"):
for i, o in enumerate(result['result']):
del o['incoming_rate']
del o['valuation_rate']
del o['stock_value']
elif(report_name == "Stock Balance"):
for i, o in enumerate(result['result']):
if "in_val" in o:
o.pop('out_val')
o.pop('bal_val')
o.pop('in_val')
o.pop('opening_val')
o.pop('val_rate')
return result
|
StarcoderdataPython
|
3274120
|
from ct.crypto import cert
from observation import Observation
class IpAddressObservation(Observation):
def __init__(self, description, *args, **kwargs):
super(IpAddressObservation, self).__init__(
"IPAddres: " + description, *args, **kwargs)
class IPv6(IpAddressObservation):
def __init__(self):
super(IPv6, self).__init__("IPv6")
class Private(IpAddressObservation):
def __init__(self, details):
super(Private, self).__init__(
"IP address in IANA-reserved private range",
details=details)
class CorruptIPAddress(IpAddressObservation):
def __init__(self):
super(CorruptIPAddress, self).__init__("corrupt extension")
class CheckPrivateIpAddresses(object):
@staticmethod
def check(certificate):
"""Checks if certificate contains IPv4 address in private range.
Returns:
array containing Private for each private address,
or empty array there are no observations.
"""
observations = []
try:
for address in certificate.subject_ip_addresses():
octets = address.as_octets()
if len(octets) == 16:
if octets[0] == ord('\xfd'):
observations += [Private(str(address))]
else:
private = False
# check 10.0.0.0 to 10.255.255.255
if octets[0] == 10:
private = True
# check 172.16.0.0 to 172.31.255.255
elif (octets[0] == 172 and 16 <= octets[1] <= 31):
private = True
# check 192.168.0.0 to 192.168.255.255
elif (octets[0] == 192 and octets[1] == 168):
private = True
if private:
observations += [Private(str(address))]
except cert.CertificateError:
pass
return observations
class CheckCorruptIpAddresses(object):
@staticmethod
def check(certificate):
"""Checks if ip addresses are corrupt in certificate.
Returns:
array containing CorruptIPAddress or None
"""
try:
certificate.subject_ip_addresses()
except cert.CertificateError:
return [CorruptIPAddress()]
|
StarcoderdataPython
|
68211
|
# Licensed under a 3-clause BSD style license - see PYFITS.rst
import gzip
import io
from ..file import _File
from .base import NonstandardExtHDU
from .hdulist import HDUList
from ..header import Header, _pad_length
from ..util import fileobj_name
from ....extern.six import string_types
from ....utils import lazyproperty
class FitsHDU(NonstandardExtHDU):
"""
A non-standard extension HDU for encapsulating entire FITS files within a
single HDU of a container FITS file. These HDUs have an extension (that is
an XTENSION keyword) of FITS.
The FITS file contained in the HDU's data can be accessed by the `hdulist`
attribute which returns the contained FITS file as an `HDUList` object.
"""
_extension = 'FITS'
@lazyproperty
def hdulist(self):
self._file.seek(self._data_offset)
fileobj = io.BytesIO()
# Read the data into a BytesIO--reading directly from the file
# won't work (at least for gzipped files) due to problems deep
# within the gzip module that make it difficult to read gzip files
# embedded in another file
fileobj.write(self._file.read(self.size))
fileobj.seek(0)
if self._header['COMPRESS']:
fileobj = gzip.GzipFile(fileobj=fileobj)
return HDUList.fromfile(fileobj, mode='readonly')
@classmethod
def fromfile(cls, filename, compress=False):
"""
Like `FitsHDU.fromhdulist()`, but creates a FitsHDU from a file on
disk.
Parameters
----------
filename : str
The path to the file to read into a FitsHDU
compress : bool, optional
Gzip compress the FITS file
"""
return cls.fromhdulist(HDUList.fromfile(filename), compress=compress)
@classmethod
def fromhdulist(cls, hdulist, compress=False):
"""
Creates a new FitsHDU from a given HDUList object.
Parameters
----------
hdulist : HDUList
A valid Headerlet object.
compress : bool, optional
Gzip compress the FITS file
"""
fileobj = bs = io.BytesIO()
if compress:
if hasattr(hdulist, '_file'):
name = fileobj_name(hdulist._file)
else:
name = None
fileobj = gzip.GzipFile(name, mode='wb', fileobj=bs)
hdulist.writeto(fileobj)
if compress:
fileobj.close()
# A proper HDUList should still be padded out to a multiple of 2880
# technically speaking
padding = (_pad_length(bs.tell()) * cls._padding_byte).encode('ascii')
bs.write(padding)
bs.seek(0)
cards = [
('XTENSION', cls._extension, 'FITS extension'),
('BITPIX', 8, 'array data type'),
('NAXIS', 1, 'number of array dimensions'),
('NAXIS1', len(bs.getvalue()), 'Axis length'),
('PCOUNT', 0, 'number of parameters'),
('GCOUNT', 1, 'number of groups'),
]
# Add the XINDn keywords proposed by Perry, though nothing is done with
# these at the moment
if len(hdulist) > 1:
for idx, hdu in enumerate(hdulist[1:]):
cards.append(('XIND' + str(idx + 1), hdu._header_offset,
'byte offset of extension {}'.format(idx + 1)))
cards.append(('COMPRESS', compress, 'Uses gzip compression'))
header = Header(cards)
return cls._readfrom_internal(_File(bs), header=header)
@classmethod
def match_header(cls, header):
card = header.cards[0]
if card.keyword != 'XTENSION':
return False
xtension = card.value
if isinstance(xtension, string_types):
xtension = xtension.rstrip()
return xtension == cls._extension
# TODO: Add header verification
def _summary(self):
# TODO: Perhaps make this more descriptive...
return (self.name, self.ver, self.__class__.__name__, len(self._header))
|
StarcoderdataPython
|
1782256
|
# -----------------------------------------------------------------------------
# Copyright (c) 2014--, The Qiita Development Team.
#
# Distributed under the terms of the BSD 3-clause License.
#
# The full license is in the file LICENSE, distributed with this software.
# -----------------------------------------------------------------------------
from functools import partial
from future import standard_library
from json import loads
import qiita_db as qdb
with standard_library.hooks():
from configparser import ConfigParser
SUPPORTED_PARAMS = ['preprocessed_sequence_illumina_params',
'preprocessed_sequence_454_params',
'processed_params_sortmerna']
def load_study_from_cmd(owner, title, info):
r"""Adds a study to the database
Parameters
----------
owner : str
The email address of the owner of the study_abstract
title : str
The title of the study_abstract
info : file-like object
File-like object containing study information
"""
# Parse the configuration file
config = ConfigParser()
config.readfp(info)
optional = dict(config.items('optional'))
def get_optional(name):
return optional.get(name, None)
get_required = partial(config.get, 'required')
required_fields = ['timeseries_type_id', 'mixs_compliant',
'reprocess', 'study_alias',
'study_description', 'study_abstract',
'metadata_complete', 'principal_investigator']
optional_fields = ['funding', 'most_recent_contact', 'spatial_series',
'vamps_id', 'study_id']
infodict = {}
for value in required_fields:
infodict[value] = get_required(value)
for value in optional_fields:
optvalue = get_optional(value)
if optvalue is not None:
infodict[value] = optvalue
with qdb.sql_connection.TRN:
lab_name_email = get_optional('lab_person')
if lab_name_email is not None:
lab_name, lab_email, lab_affiliation = lab_name_email.split(',')
infodict['lab_person_id'] = qdb.study.StudyPerson.create(
lab_name.strip(), lab_email.strip(), lab_affiliation.strip())
pi_name_email = infodict.pop('principal_investigator')
pi_name, pi_email, pi_affiliation = pi_name_email.split(',', 2)
infodict['principal_investigator_id'] = qdb.study.StudyPerson.create(
pi_name.strip(), pi_email.strip(), pi_affiliation.strip())
return qdb.study.Study.create(qdb.user.User(owner), title, infodict)
def load_artifact_from_cmd(filepaths, filepath_types, artifact_type,
prep_template=None, parents=None,
dflt_params_id=None, required_params=None,
optional_params=None):
r"""Adds an artifact to the system
Parameters
----------
filepaths : iterable of str
Paths to the artifact files
filepath_types : iterable of str
Describes the contents of the files
artifact_type : str
The type of artifact
prep_template : int, optional
The prep template id
parents : list of int, optional
The list of artifacts id of the parent artifacts
dflt_params_id : int, optional
The id of the default parameter set used to process the artifact
required_params : str, optional
JSON string with the required parameters used to process the artifact
optional_params : str, optional
JSON string with the optional parameters used to process the artifact
Returns
-------
qiita_db.artifact.Artifact
The newly created artifact
Raises
------
ValueError
If the lists `filepaths` and `filepath_types` don't have the same
length
"""
if len(filepaths) != len(filepath_types):
raise ValueError("Please provide exactly one filepath_type for each "
"and every filepath")
with qdb.sql_connection.TRN:
fp_types_dict = qdb.util.get_filepath_types()
fps = [(fp, fp_types_dict[ftype])
for fp, ftype in zip(filepaths, filepath_types)]
if prep_template:
prep_template = qdb.metadata_template.prep_template.PrepTemplate(
prep_template)
if parents:
if len(parents) > 1 and required_params is None:
raise ValueError("When you pass more than 1 parent you need "
"to also pass required_params")
parents = [qdb.artifact.Artifact(pid) for pid in parents]
params = None
if dflt_params_id:
if required_params:
required_dict = loads(required_params)
else:
# if we reach this point we know tha we only have one parent
required_dict = loads('{"input_data": %d}' % parents[0].id)
optional_dict = loads(optional_params) if optional_params else None
params = qdb.software.Parameters.from_default_params(
qdb.software.DefaultParameters(dflt_params_id),
required_dict, optional_dict)
return qdb.artifact.Artifact.create(
fps, artifact_type, prep_template=prep_template, parents=parents,
processing_parameters=params)
def load_sample_template_from_cmd(sample_temp_path, study_id):
r"""Adds a sample template to the database
Parameters
----------
sample_temp_path : str
Path to the sample template file
study_id : int
The study id to which the sample template belongs
"""
sample_temp = qdb.metadata_template.util.load_template_to_dataframe(
sample_temp_path)
return qdb.metadata_template.sample_template.SampleTemplate.create(
sample_temp, qdb.study.Study(study_id))
def load_prep_template_from_cmd(prep_temp_path, study_id, data_type):
r"""Adds a prep template to the database
Parameters
----------
prep_temp_path : str
Path to the prep template file
study_id : int
The study id to which the prep template belongs
data_type : str
The data type of the prep template
"""
prep_temp = qdb.metadata_template.util.load_template_to_dataframe(
prep_temp_path)
return qdb.metadata_template.prep_template.PrepTemplate.create(
prep_temp, qdb.study.Study(study_id), data_type)
def update_artifact_from_cmd(filepaths, filepath_types, artifact_id):
"""Updates the artifact `artifact_id` with the given files
Parameters
----------
filepaths : iterable of str
Paths to the artifact files
filepath_types : iterable of str
Describes the contents of the files
artifact_id : int
The id of the artifact to be updated
Returns
-------
qiita_db.artifact.Artifact
Raises
------
ValueError
If 'filepaths' and 'filepath_types' do not have the same length
"""
if len(filepaths) != len(filepath_types):
raise ValueError("Please provide exactly one filepath_type for each "
"and every filepath")
with qdb.sql_connection.TRN:
artifact = qdb.artifact.Artifact(artifact_id)
fp_types_dict = qdb.util.get_filepath_types()
fps = [(fp, fp_types_dict[ftype])
for fp, ftype in zip(filepaths, filepath_types)]
old_fps = artifact.filepaths
sql = "DELETE FROM qiita.artifact_filepath WHERE artifact_id = %s"
qdb.sql_connection.TRN.add(sql, [artifact.id])
qdb.sql_connection.TRN.execute()
qdb.util.move_filepaths_to_upload_folder(artifact.study.id, old_fps)
fp_ids = qdb.util.insert_filepaths(
fps, artifact.id, artifact.artifact_type)
sql = """INSERT INTO qiita.artifact_filepath (artifact_id, filepath_id)
VALUES (%s, %s)"""
sql_args = [[artifact.id, fp_id] for fp_id in fp_ids]
qdb.sql_connection.TRN.add(sql, sql_args, many=True)
qdb.sql_connection.TRN.execute()
return artifact
|
StarcoderdataPython
|
3312619
|
'''
@author: quarkonics
'''
import zstackwoodpecker.test_util as test_util
import zstackwoodpecker.test_lib as test_lib
import zstackwoodpecker.test_state as test_state
import zstackwoodpecker.operations.resource_operations as res_ops
import zstackwoodpecker.operations.export_operations as exp_ops
import zstackwoodpecker.operations.net_operations as net_ops
import os
test_stub = test_lib.lib_get_test_stub()
test_obj_dict = test_state.TestStateDict()
curr_deploy_conf = None
l3_name = None
l3 = None
def test():
global curr_deploy_conf
global l3_name
global l3
curr_deploy_conf = exp_ops.export_zstack_deployment_config(test_lib.deploy_config)
test_util.test_dsc('Create test vm and delete l3.')
l3_name = os.environ.get('l3VlanNetworkName1')
l3 = res_ops.get_resource(res_ops.L3_NETWORK, name = l3_name)[0]
vm = test_stub.create_vlan_vm(l3_name)
test_obj_dict.add_vm(vm)
vm.check()
net_ops.delete_l3(l3.uuid)
if len(test_lib.lib_find_vr_by_l3_uuid(l3.uuid)) != 0:
test_util.test_fail('VR VM should be delete when associated L3 is deleted')
vm.destroy()
net_ops.add_l3_resource(curr_deploy_conf, l3_name)
test_util.test_pass('Create VirtualRouter VM delete l3 Test Success')
#Will be called only if exception happens in test().
def error_cleanup():
global curr_deploy_conf
global l3_name
global l3
test_lib.lib_error_cleanup(test_obj_dict)
l3 = res_ops.get_resource(res_ops.L3_NETWORK, name = l3_name)
if not l3s:
try:
net_ops.add_l3_resource(curr_deploy_conf, l3_name)
except Exception as e:
test_util.test_warn('Fail to recover [l3:] %s resource. It will impact later test case.' % l3_name)
raise e
|
StarcoderdataPython
|
1691859
|
from app import create_app,db
from flask_script import Manager,Server
from app.models import User,Post
from flask_migrate import Migrate,MigrateCommand
app = create_app('development')
app = create_app('production')
manager = Manager(app)
manager.add_command('server',Server)
migrate = Migrate(app,db)
manager.add_command('db',MigrateCommand)
@manager.command
def test():
import unittest
test = unittest.TestLoader().discover('test')
unittest.TextTestRunner(verbosity=2).run(test)
@manager.shell
def make_shell_context():
return dict(app = app , db = db , User = User , Post=Post)
if __name__ == '__main__':
manager.run()
|
StarcoderdataPython
|
1717080
|
<reponame>HarinarayananP/Flask-Backend-AirPolutionMonitoring
# -*- encoding: utf-8 -*-
"""
Copyright (c) 2019 - present AppSeed.us
"""
from flask_login import UserMixin
from sqlalchemy import Binary, Column, Integer, String, DateTime, Boolean, ForeignKey, Float
from app import db, login_manager
from app.base.util import hash_pass
class User(db.Model, UserMixin):
__tablename__ = 'User'
id = Column(Integer, primary_key=True)
username = Column(String(20), unique=True)
email = Column(String(20), unique=True)
password = Column(Binary)
def __init__(self, **kwargs):
for property, value in kwargs.items():
# depending on whether value is an iterable or not, we must
# unpack it's value (when **kwargs is request.form, some values
# will be a 1-element list)
if hasattr(value, '__iter__') and not isinstance(value, str):
# the ,= unpack of a singleton fails PEP8 (travis flake8 test)
value = value[0]
if property == 'password':
value = hash_pass(value) # we need bytes here (not plain str)
setattr(self, property, value)
def __repr__(self):
return str(self.username)
class SensorData(db.Model, UserMixin):
__tablename__ = 'SensorData'
id = Column(Integer, primary_key=True)
sensorname = Column(String(20), ForeignKey("SensorDetails.name"))
time = Column(DateTime)
value = Column(Integer)
sensordetails = db.relationship("SensorDetails", lazy=True)
def __init__(self, **kwargs):
for property, value in kwargs.items():
# depending on whether value is an iterable or not, we must
# unpack it's value (when **kwargs is request.form, some values
# will be a 1-element list)
if hasattr(value, '__iter__') and not isinstance(value, str):
# the ,= unpack of a singleton fails PEP8 (travis flake8 test)
value = value[0]
setattr(self, property, value)
def __repr__(self):
return str(self.id)
class Settings(db.Model, UserMixin):
__tablename__ = 'Settings'
id = Column(Integer, primary_key=True)
name = Column(String(20))
value = Column(String(400))
def __init__(self, **kwargs):
for property, value in kwargs.items():
# depending on whether value is an iterable or not, we must
# unpack it's value (when **kwargs is request.form, some values
# will be a 1-element list)
if hasattr(value, '__iter__') and not isinstance(value, str):
# the ,= unpack of a singleton fails PEP8 (travis flake8 test)
value = value[0]
setattr(self, property, value)
def __repr__(self):
return self.value
class SensorDetails(db.Model, UserMixin):
__tablename__ = 'SensorDetails'
id = Column(Integer, primary_key=True)
name = Column(String(20), unique=True)
location = Column(String(400))
unit = Column(String(20))
warning_level = Column(Integer)
severe_level = Column(Integer)
active = Column(Boolean)
min_value = Column(Integer)
max_value = Column(Integer)
color = Column(String(15))
icon = Column(String(20))
def __init__(self, **kwargs):
for property, value in kwargs.items():
# depending on whether value is an iterable or not, we must
# unpack it's value (when **kwargs is request.form, some values
# will be a 1-element list)
if hasattr(value, '__iter__') and not isinstance(value, str):
# the ,= unpack of a singleton fails PEP8 (travis flake8 test)
value = value[0]
setattr(self, property, value)
def __repr__(self):
return str(self.id)
@login_manager.user_loader
def user_loader(id):
return User.query.filter_by(id=id).first()
@login_manager.request_loader
def request_loader(request):
username = request.form.get('username')
user = User.query.filter_by(username=username).first()
return user if user else None
|
StarcoderdataPython
|
1691943
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.11.3
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + [markdown] id="view-in-github" colab_type="text"
# <a href="https://colab.research.google.com/github/probml/pyprobml/blob/master/notebooks/pre_trained_image_classifier_torch.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
# + [markdown] id="Frv977yg2dww"
# # Apply a Resnet image classifier that has been pre-trained on ImageNet
# + id="z5a1FHe-vdkn"
import torch
from torchvision import models
# + id="Qgi8cSdSvk8z" colab={"base_uri": "https://localhost:8080/", "height": 35} outputId="10fb0e09-df03-43a7-dfac-36148deb3363"
torch.__version__
# + [markdown] id="ltduunBdnbKN"
# List of pre-trained models.
# + id="6LVoxV75vdko" colab={"base_uri": "https://localhost:8080/"} outputId="1834691f-4215-4db9-f51f-cc2f57ee827a"
dir(models)
# + id="PsC2lTh5vdkp" colab={"base_uri": "https://localhost:8080/", "height": 83, "referenced_widgets": ["23e85808a1c54210b612176371104cde", "2e750d0cfb50481f9d3ef39f635c4532", "d3291c822cd142d5a858b9872ee496e6", "62b84d51ca5b41b9a8f7d4bb659e0e18", "7e827d6e806b418995041d4c71e907b9", "0c8a19c2a83f4eeb8f5cffe1608975b3", "70ee9e93723e4b7da6963de6d1e04e75", "e042f19776db4cf48729524a21487f92"]} outputId="12d1098d-7cd9-48b7-8cb6-d256924ab313"
resnet = models.resnet101(pretrained=True)
# + id="byIForimoiAo" outputId="a33e13f5-826f-45be-a889-c6ef12bd96a9" colab={"base_uri": "https://localhost:8080/"}
resnet
# + id="6Jh6YBKIomQB" outputId="b1c40c7b-5679-4dff-c155-aa1d98361781" colab={"base_uri": "https://localhost:8080/"}
resnet.fc
# + id="N476SFdzvdkq"
from torchvision import transforms
preprocess = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]
)])
# + id="Wytu8FYpn5t3" outputId="f5c5593e-270d-4546-a5d9-2f14f765e0b3" colab={"base_uri": "https://localhost:8080/", "height": 497}
# !wget https://github.com/probml/pyprobml/blob/master/images/cat_dog.jpg?raw=true -q -O img.jpg
from PIL import Image
img = Image.open('img.jpg')
display(img)
# + id="xjlCv-lxvdkq" colab={"base_uri": "https://localhost:8080/"} outputId="1f561125-ce34-4720-9eca-18a727a00334"
print(type(img))
img_t = preprocess(img) # convert to tensor
print(type(img_t))
# + id="3u9oW64rvdkr" colab={"base_uri": "https://localhost:8080/"} outputId="0b6f3482-bd5d-4af5-db2c-0756225a48fa"
import torch
batch_t = torch.unsqueeze(img_t, 0)
print(img_t.shape)
print(batch_t.shape)
# + id="z1Y43v4yvdkr"
resnet.eval(); # set to eval mode (not training)
# + id="57BrgTzavdkr" colab={"base_uri": "https://localhost:8080/"} outputId="c887f8b9-aff7-46fe-e32f-42571077ebf2"
out = resnet(batch_t)
print(out.shape)
# + id="VtzgSke-vdkr" colab={"base_uri": "https://localhost:8080/"} outputId="0324e996-945c-44d3-ef6a-a3f93392fe91"
import urllib
import requests
url = "https://raw.githubusercontent.com/probml/pyprobml/master/data/imagenet_classes.txt"
response = requests.get(url)
file = urllib.request.urlopen(url)
labels = [line.strip() for line in file.readlines()]
print(labels)
# + id="TNjU-5Kwvdks" colab={"base_uri": "https://localhost:8080/"} outputId="fbe9f1c3-5ffd-4364-ec73-782b2c598f39"
# Show top 5 labels
_, indices = torch.sort(out, descending=True)
[(labels[idx], percentage[idx].item()) for idx in indices[0][:5]]
# + id="zuIDA1s4vdks"
|
StarcoderdataPython
|
108980
|
import logging
import logging.config
import os
from os import path
from pathlib import Path
import yaml
logger = logging.getLogger(__name__)
def get_logging_cfg():
cfg_file = os.getenv('LOGGING_CFG', './config/logging-cfg-local.yml')
if 'LOGS_DIR' not in os.environ:
# Build paths inside the project like this: BASE_DIR / 'subdir'.
logs_dir = Path(__file__).resolve(
strict=True
).parent.parent.parent / 'logs'
os.environ['LOGS_DIR'] = str(logs_dir)
print(f"LOGS_DIR is {os.environ['LOGS_DIR']}")
print(f"LOGGING_CFG is {cfg_file}")
config = {}
with open(cfg_file, 'rt', encoding='utf-8') as fd:
config = yaml.safe_load(path.expandvars(fd.read()))
logger.debug('Load logging configuration from file %s', cfg_file)
return config
def init_logging():
config = get_logging_cfg()
logging.config.dictConfig(config)
|
StarcoderdataPython
|
3316141
|
from setuptools import setup, find_packages
def get_version_and_cmdclass(package_path):
"""Load version.py module without importing the whole package.
Template code from miniver
"""
import os
from importlib.util import module_from_spec, spec_from_file_location
spec = spec_from_file_location("version", os.path.join(package_path, "_version.py"))
module = module_from_spec(spec)
spec.loader.exec_module(module)
return module.__version__, module.cmdclass
version, cmdclass = get_version_and_cmdclass("menpodetect")
setup(
name="menpodetect",
version=version,
cmdclass=cmdclass,
description="Object detection for Menpo",
author="The Menpo Development Team",
author_email="<EMAIL>",
packages=find_packages(),
package_data={"menpodetect": ["models/opencv/*.xml"]},
install_requires=["menpo>=0.9.0,<0.12.0"],
tests_require=["pytest>=5.0", "black>=20.0"],
)
|
StarcoderdataPython
|
3258997
|
<filename>landmasterlibrarygui/pdf_rotater.py
# pdf_rotater.py
# code in shift-jis
import os, sys
# IMPORT module FROM LandmasterLibrary
import dir_editor
sep = dir_editor.decide_seperator() # String seperator of directory.
import file_list_getter
def make_vertical(folder_list : list):
'''
folderList : list of file filtered with extension in the selected folder.
filename : fullname of selected file.
original : PdfFileReader of original files.
rotated : PdfFileWriter of rotated files.
rotated_dir : path of folder having rotated files.
sum_page : sum of page.
sum_rotating_page : rotating pages. count 1 if make their vertical.
'''
# PyPDF2 version is 1.26.0
from PyPDF2 import PdfFileWriter, PdfFileReader
if len(folder_list) != 0:
filename = folder_list[0]
else:
print('\nPDFRotater exits because of no target files.')
sys.exit(0)
rotated_dir = dir_editor.make_directory(filename)
for filename in folder_list:
print("Rotate all page of PDF:", filename)
original = PdfFileReader(filename)
rotated = PdfFileWriter()
# Display number of pages of original PDF file
sum_page = original.getNumPages()
print("page_num: ", sum_page)
# Count pages at the same time as making vertical.
sum_rotating_page = 0
for i in range(0, sum_page, 1):
print("Page ", i, " is ", original.getPage(i).get('/Rotate'), " degrees rotating")
angle_rotating = original.getPage(i).get('/Rotate')
if angle_rotating != 0:
sum_rotating_page += 1
rotated.addPage(original.getPage(i).rotateClockwise(360 - angle_rotating))
# new file entry
# output_filename = '{dirname}{sep}{basename}'.format(dirname=rotated_dir, sep=sep, basename=os.path.basename(filename))
output_filename = dir_editor.generate_file_name(rotated_dir, sep, os.path.basename(filename))
with open(output_filename, "wb") as outputStream:
rotated.write(outputStream)
print("\nPDFRotater is terminated.\nsum_rotating_page: ", sum_rotating_page, " / ", sum_page)
print('\n\nCheck new folder. "{}"'.format(rotated_dir))
def main():
make_vertical(file_list_getter.get_file_list(dir_editor.decide_now_dir(),'pdf'))
if __name__ == "__main__":
main()
|
StarcoderdataPython
|
1617907
|
<gh_stars>0
# Generated by Django 2.2.2 on 2019-08-02 14:05
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('core', '0070_auto_20190802_1331'),
]
operations = [
migrations.AddField(
model_name='people',
name='organizations',
field=models.ManyToManyField(blank=True, to='core.Organization'),
),
migrations.DeleteModel(
name='PeopleAffiliation',
),
]
|
StarcoderdataPython
|
3235798
|
from enum import Enum
import geopandas as gpd
from itertools import product
import numpy as np
import pandas as pd
from pathlib import Path
import pkg_resources
from typing import Union
from balsa.routines import distance_matrix, read_mdf
from balsa.logging import get_model_logger
from cheval import LinkedDataFrame
from .enums import TimeFormat, ZoneNums
def _load_model_activity_pairs() -> pd.Series:
stream = pkg_resources.resource_stream(__name__, 'resource_data/activity_pairs_model.csv')
return pd.read_csv(stream, index_col=[0, 1], squeeze=True)
class MicrosimData(object):
_households: LinkedDataFrame
_persons: LinkedDataFrame
_trips: LinkedDataFrame
_trip_modes: LinkedDataFrame
_trip_stations: LinkedDataFrame
_trip_passengers: LinkedDataFrame
_zone_coordinates: gpd.GeoDataFrame
_impedances: pd.DataFrame
_max_internal_zone: int
_logger = get_model_logger('gtam_tools.MicrosimData')
_household_spec = {
'household_id': np.int64, 'home_zone': np.int16, 'weight': np.int64, 'persons': np.int16,
'dwelling_type': np.int16, 'vehicles': np.int16, 'income_class': np.int16
}
_persons_spec = {
'household_id': np.int64, 'person_id': np.int32, 'age': np.int16, 'sex': 'category', 'license': bool,
'transit_pass': bool, 'employment_status': 'category', 'occupation': 'category', 'free_parking': bool,
'student_status': 'category', 'work_zone': np.int16, 'school_zone': np.int16, 'weight': np.int64
}
_trips_spec = {
'household_id': np.int64, 'person_id': np.int32, 'trip_id': np.int32, 'o_act': 'category', 'o_zone': np.int16,
'd_act': 'category', 'd_zone': np.int16, 'weight': np.int64
}
_trip_modes_spec = {
'household_id': np.int64, 'person_id': np.int32, 'trip_id': np.int32, 'mode': 'category', 'o_depart': str,
'd_arrive': str, 'weight': np.int64
}
_trip_stations_spec = {
'household_id': np.int64, 'person_id': np.int32, 'trip_id': np.int32, 'station': np.int16,
'direction': 'category', 'weight': np.int64
}
_passenger_spec = {
'household_id': np.int64, 'passenger_id': np.int32, 'passenger_trip_id': np.int32, 'driver_id': np.int32,
'driver_trip_id': np.int32, 'weight': np.int64
}
@property
def households_loaded(self):
return self._households is not None
@property
def persons_loaded(self):
return self._persons is not None
@property
def trips_loaded(self):
return self._trips is not None
@property
def trip_modes_loaded(self):
return self._trip_modes is not None
@property
def trip_stations_loaded(self):
return self._trip_stations is not None
@property
def trips_passengers_loaded(self):
return self._trip_passengers is not None
@property
def zone_coordinates_loaded(self):
return self._zone_coordinates is not None
@property
def households(self) -> LinkedDataFrame:
return self._households
@property
def persons(self) -> LinkedDataFrame:
return self._persons
@property
def trips(self) -> LinkedDataFrame:
return self._trips
@property
def trip_modes(self) -> LinkedDataFrame:
return self._trip_modes
@property
def trip_stations(self) -> LinkedDataFrame:
return self._trip_stations
@property
def trip_passengers(self) -> LinkedDataFrame:
return self._trip_passengers
@property
def zone_coordinates(self) -> gpd.GeoDataFrame:
return self._zone_coordinates
@property
def impedances(self) -> pd.DataFrame:
return self._impedances
@staticmethod
def load_folder(run_folder: Union[str, Path], *, link_tables: bool = True, derive_additional_variables: bool = True,
time_format=TimeFormat.MINUTE_DELTA, zones_file: Union[str, Path] = None, taz_col: str = None,
zones_crs: str = None, to_crs: str = 'EPSG:26917', coord_unit: float = 0.001,
max_internal_zone: Union[int, Enum] = ZoneNums.MAX_INTERNAL) -> 'MicrosimData':
"""Load GTAModel Microsim Result tables from a specified folder.
Args:
run_folder (Union[str, Path]): The path to the GTAModel Microsim Results folder
link_tables (bool, optional): Defaults to ``True``. A flag to link result tables together. Please note that
this option will take several minutes to complete.
derive_additional_variables (bool, optional): Defaults to ``True``. A flag to derive additional variables
based on the Microsim data. Requires ``link_tables=True``.
time_format (TimeFormat, optional): Defaults to ``TimeFormat.MINUTE_DELTA``. Specify the time format in the
Microsim results. Used for parsing times in the trip modes file.
zones_file (Union[str, Path], optional): Defaults to ``None``. The path to a file containing zone
coordinates. Accepts CSVs with x, y coordinate columns, or a zones shapefile. If providing a shapefile,
it will calculate the zone coordinate based on the centroid of each zone polygon.
taz_col (str, optional): Defaults to ``None``. Name of the TAZ column in ``zones_file``.
zones_crs (Union[str, CRS], optional): Defaults to ``None``. The coordinate reference system for
``zones_file``. Only applicable if ``zones_file`` is a CSV file. Value can be anything accepted by
``pyproj.CRS.from_user_input()``.
to_crs (str, optional): Defaults to ``'EPSG:26917'``. A coordinate reference system to reproject zone
coordinates to. Value can be anything accepted by ``pyproj.CRS.from_user_input()``.
coord_unit (float, optional): Defaults to ``0.001``. A value to adjust distance values with.
max_internal_zone (Union[int, Enum], optional): Defaults to ``ZoneNums.MAX_INTERNAL``. The highest internal
zone number allowed. Argument accepts an integer or an Enum attribute (e.g. ``ZoneNums.MAX_INTERNAL``).
Returns:
MicrosimData
"""
run_folder = Path(run_folder)
assert run_folder.exists(), f'Run folder `{run_folder.as_posix()}` not found'
assert run_folder.is_dir()
if zones_file is not None:
assert taz_col is not None, 'Please specify `taz_col`'
if derive_additional_variables:
assert link_tables, '`link_tables` must be enabled to derive additional variables'
def _prep_file(name: str) -> Path:
uncompressed = run_folder / (name + '.csv')
compressed = run_folder / (name + '.csv.gz')
if uncompressed.exists():
return uncompressed
if compressed.exists():
return compressed
raise FileNotFoundError(f'Could not find the `{name}` output file.')
households_fp = _prep_file('households')
persons_fp = _prep_file('persons')
trips_fp = _prep_file('trips')
trip_modes_fp = _prep_file('trip_modes')
trip_stations_fp = _prep_file('trip_stations')
try:
fpass_fp = _prep_file('facilitate_passenger')
except FileNotFoundError:
fpass_fp = None
if zones_file is not None:
zones_file = Path(zones_file)
if not zones_file.exists():
raise FileNotFoundError(f'Zone attribute file could not be found at {zones_file.as_posix()}')
MicrosimData._logger.tip(f'Loading Microsim Results from `{run_folder.as_posix()}`')
data = MicrosimData()
data._set_max_internal_zone(max_internal_zone)
data._load_tables(households_fp, persons_fp, trips_fp, trip_modes_fp, trip_stations_fp, fpass_fp=fpass_fp,
zones_fp=zones_file, taz_col=taz_col, zones_crs=zones_crs, to_crs=to_crs)
if data.zone_coordinates_loaded:
data._calc_base_impedences(coord_unit)
data._verify_integrity()
if link_tables:
data._link_tables()
if derive_additional_variables:
data._classify_times(time_format)
data._derive_household_variables()
data._derive_person_variables()
data._derive_trip_variables()
data._reweight_trips()
MicrosimData._logger.tip('Microsim Results successfully loaded!')
return data
def add_impedance_skim(self, name: str, skim_fp: Union[str, Path], *, scale_unit: float = 1.0,
ignore_missing_ods: bool = False):
"""Add a skim from a matrix binary file as impedance values to the impedances table.
Args:
name (str): The reference name for the impedance skim.
skim_fp (Union[str, Path]): The file path to the skim matrix binary file.
scale_unit (float, optional): Defaults to ``1.0``. A scalar value to adjust skim values.
ignore_missing_ods (bool, optional): Defaults to ``False``. A flag to ignore missing ODs. If ``True``, skim
values for missing ODs will be set to zero.
"""
assert self.zone_coordinates_loaded, 'Cannot add skim unless zone coordinates are loaded'
skim_fp = Path(skim_fp)
assert skim_fp.exists(), f'Skim file not found at `{skim_fp.as_posix()}`'
skim_data = read_mdf(skim_fp, raw=False, tall=True)
mask1 = skim_data.index.get_level_values(0) <= self._max_internal_zone
mask2 = skim_data.index.get_level_values(1) <= self._max_internal_zone
skim_data = skim_data[mask1 & mask2].reindex(self.impedances.index)
skim_data = skim_data * scale_unit
if ignore_missing_ods:
skim_data.fillna(0, inplace=True)
else:
assert np.all(~skim_data.isna()), 'Skim is not compatible with the dataset zone system'
self.impedances[name] = skim_data
self._logger.report(f'Added `{name}` to impedances')
def add_zone_ensembles(self, name: str, definition_fp: Union[str, Path], taz_col: str, *,
ensemble_col: str = 'ensemble', missing_val: int = 9999,
ensemble_names_fp: Union[str, Path] = None, ensemble_names_col: str = 'name'):
"""Add zone ensemble definitions to the zone coordinates table.
Args:
name (str): The reference name for the ensemble definitions.
definition_fp (Union[str, Path]): The file path to the zone ensemble correspondence file. Can be a CSV
file or shapefile.
taz_col (str): Name of the TAZ column in ``definition_fp``.
ensemble_col (str, optional): Defaults to ``'ensemble'``. Name of the ensembles column in ``definition_fp``.
missing_val (int, optional): Defaults to ``9999``. A value to use for all TAZs without an
assigned ensemble.
ensemble_names_fp (Union[str, Path], optional): Defaults to ``None``. The file path to a CSV file containing
zone ensemble names. The ensemble id column in this file must be the same as ``ensemble_col``.
ensemble_names_col (str, optional): Defaults to ``'name'``. The name of the column containing the ensemble
names. Will only be used if ``ensemble_names_fp`` is specified.
"""
assert self.zone_coordinates_loaded, 'Cannot add zone ensembles unless zone coordinates are loaded'
taz_col = taz_col.lower()
ensemble_col = ensemble_col.lower()
definition_fp = Path(definition_fp)
assert definition_fp.exists(), f'Correspondence file not found at `{definition_fp.as_posix()}`'
if definition_fp.suffix == '.csv':
correspondence = pd.read_csv(definition_fp)
elif definition_fp.suffix == '.shp':
correspondence = gpd.read_file(definition_fp)
else:
raise RuntimeError(f'An unsupported zones file type was provided ({definition_fp.suffix})')
correspondence.columns = correspondence.columns.str.lower()
correspondence.set_index(taz_col, inplace=True)
correspondence = correspondence[ensemble_col].reindex(self.zone_coordinates.index, fill_value=missing_val)
correspondence = correspondence.to_frame(name=ensemble_col)
if ensemble_names_fp is not None:
ensemble_names_fp = Path(ensemble_names_fp)
assert ensemble_names_fp.exists(), f'Ensemble names file not found at `{ensemble_names_fp.as_posix()}`'
ensemble_names = pd.read_csv(ensemble_names_fp)
correspondence = correspondence.merge(ensemble_names, how='left', on=ensemble_col)
self.zone_coordinates[name] = correspondence[ensemble_col].values
if ensemble_names_fp is not None:
self.zone_coordinates[f'{name}_label'] = correspondence[ensemble_names_col]
self._logger.report('Added ensembles to zone coordinates')
def _set_max_internal_zone(self, max_internal_zone: int):
self._max_internal_zone = int(max_internal_zone)
def _load_zones_file(self, fp: Path, taz_col: str, zones_crs: str, to_crs: str) -> gpd.GeoDataFrame:
if fp.suffix == '.csv':
zones_df = pd.read_csv(fp)
zones_df.columns = zones_df.columns.str.lower()
zones_df = gpd.GeoDataFrame(zones_df, geometry=gpd.points_from_xy(zones_df['x'], zones_df['y']),
crs=zones_crs)
elif fp.suffix == '.shp':
zones_df = gpd.read_file(fp.as_posix())
zones_df.columns = zones_df.columns.str.lower()
zones_df['geometry'] = zones_df.centroid
else:
raise RuntimeError(f'An unsupported zones file type was provided ({fp.suffix})')
taz_col = taz_col.lower()
zones_df[taz_col] = zones_df[taz_col].astype(int)
zones_df = zones_df[zones_df[taz_col] <= self._max_internal_zone].copy() # Keep internal zones only
zones_df.set_index(taz_col, inplace=True)
zones_df = zones_df.to_crs(to_crs) # reproject
zones_df['x'] = zones_df.geometry.x
zones_df['y'] = zones_df.geometry.y
zones_df.sort_index(inplace=True)
return zones_df[['geometry', 'x', 'y']].copy()
def _load_tables(self, households_fp: Path, persons_fp: Path, trips_fp: Path, trip_modes_fp: Path,
trip_stations_fp: Path, fpass_fp: Path = None, zones_fp: Path = None, taz_col: str = None,
zones_crs: str = None, to_crs: str = 'EPSG:26917'):
self._logger.info(f'Loading result tables')
table = LinkedDataFrame.read_csv(households_fp, dtype=self._household_spec)
self._logger.report(f'Loaded {len(table)} household entries')
self._households = table
table = LinkedDataFrame.read_csv(persons_fp, dtype=self._persons_spec)
self._logger.report(f'Loaded {len(table)} person entries')
self._persons = table
table = LinkedDataFrame.read_csv(trips_fp, dtype=self._trips_spec)
self._logger.report(f'Loaded {len(table)} trip entries')
self._trips = table
table = LinkedDataFrame.read_csv(trip_modes_fp, dtype=self._trip_modes_spec)
self._logger.report(f'Loaded {len(table)} trip mode entries')
self._trip_modes = table
table = LinkedDataFrame.read_csv(trip_stations_fp, dtype=self._trip_stations_spec)
self._logger.report(f'Loaded {len(table)} trip station entries')
self._trip_stations = table
if fpass_fp is not None:
table = LinkedDataFrame.read_csv(fpass_fp, dtype=self._passenger_spec)
self._logger.report(f'Loaded {len(table)} trip passenger entries')
self._trip_passengers = table
if zones_fp is not None:
table = self._load_zones_file(zones_fp, taz_col, zones_crs, to_crs)
self._logger.report(f'Loaded coordinates for {len(table)} internal zones')
self._zone_coordinates = table
def _classify_times(self, time_format: TimeFormat):
assert self.trip_modes_loaded
self._logger.info('Parsing time formats')
table = self.trip_modes
self._logger.debug('Parsing `o_depart`')
table['o_depart_hr'] = self._convert_time_to_hours(table['o_depart'], time_format)
self._logger.debug('Parsing `d_arrive`')
table['d_arrive_hr'] = self._convert_time_to_hours(table['d_arrive'], time_format)
self._logger.debug('Classifying `time_period`')
table['time_period'] = self._classify_time_period(table['o_depart_hr'])
@staticmethod
def _convert_time_to_hours(column: pd.Series, time_format: TimeFormat) -> pd.Series:
if time_format == TimeFormat.MINUTE_DELTA:
return MicrosimData._floordiv_minutes(column)
elif time_format == TimeFormat.COLON_SEP:
return MicrosimData._convert_text_to_datetime(column)
else:
raise NotImplementedError(time_format)
@staticmethod
def _convert_text_to_datetime(s: pd.Series) -> pd.Series:
colon_count = s.str.count(':')
filtr = colon_count == 1
new_time: pd.Series = s.copy()
new_time.loc[filtr] += ':00'
filtr = new_time.str.contains('-')
if filtr.sum() > 0:
new_time.loc[filtr] = "0:00:00"
print(f"Found {filtr.sum()} cells with negative time. These have been corrected to 0:00:00")
time_table = new_time.str.split(':', expand=True).astype(np.int8)
hours = time_table.iloc[:, 0]
return hours
@staticmethod
def _floordiv_minutes(column: pd.Series) -> pd.Series:
converted = column.astype(np.float64)
return (converted // 60).astype(np.int32)
@staticmethod
def _classify_time_period(start_hour: pd.Series) -> pd.Series:
new_col = pd.Series('DN', index=start_hour.index)
new_col.loc[start_hour.between(6, 8)] = 'AM'
new_col.loc[start_hour.between(9, 14)] = 'MD'
new_col.loc[start_hour.between(15, 18)] = 'PM'
new_col.loc[start_hour.between(19, 23)] = 'EV'
return new_col.astype('category')
def _calc_base_impedences(self, coord_unit: float):
self._logger.info('Calculating standard impedances from zone coordinates')
methods = ['manhattan', 'euclidean']
impedances = {
method: distance_matrix(self._zone_coordinates['x'], self._zone_coordinates['y'], tall=True, method=method,
coord_unit=coord_unit) for method in methods
}
self._impedances = pd.DataFrame(impedances)
self._impedances.index.names = ['o', 'd']
def _verify_integrity(self):
if self.households_loaded and self.persons_loaded:
hh_sizes = self.persons['household_id'].value_counts(dropna=False)
isin = hh_sizes.index.isin(self.households['household_id'])
n_homeless = hh_sizes.loc[~isin].sum()
if n_homeless > 0:
raise RuntimeError('Found `%s` persons with invalid or missing household IDs' % n_homeless)
def _link_tables(self):
self._logger.info('Precomputing table linkages')
self.persons.link_to(self.households, 'household', on='household_id')
self.households.link_to(self.persons, 'persons', on='household_id')
self.persons['home_zone'] = self.persons.household.home_zone
self._logger.debug('Linked households to persons')
self.trips.link_to(self.persons, 'person', on=['household_id', 'person_id'])
self._logger.debug('Linked persons to trips')
self.trip_modes.link_to(self.trips, 'trip', on=['household_id', 'person_id', 'trip_id'])
self.trips.link_to(self.trip_modes, 'modes', on=['household_id', 'person_id', 'trip_id'])
self.trip_modes.link_to(self.persons, 'person', on=['household_id', 'person_id'])
self.trip_modes.link_to(self.households, 'household', on='household_id')
self._logger.debug('Linked trip modes to households, persons, and trips')
self.trip_stations.link_to(self.trips, 'trip', on=['household_id', 'person_id', 'trip_id'])
self._logger.debug('Linked trip stations to trips')
if self.zone_coordinates_loaded:
self.trips.link_to(self.impedances, 'imped', on_self=['o_zone', 'd_zone'])
self._logger.debug('Linked impedances to trips')
def _derive_household_variables(self):
households = self.households
self._logger.info('Deriving additional household variables')
self._logger.debug('Summarizing `drivers`')
households['drivers'] = households.persons.sum('license * 1')
self._logger.debug('Classifying `auto_suff`')
households['auto_suff'] = 'suff'
households.loc[households.eval('drivers > vehicles'), 'auto_suff'] = 'insuff'
households.loc[households['vehicles'] == 0, 'auto_suff'] = 'nocar'
households['auto_suff'] = households['auto_suff'].astype('category')
def _derive_person_variables(self):
persons = self.persons
self._logger.info('Deriving additional persons variables')
# self._logger.debug('Classifying `person_type`')
# persons['person_type'] = 'O'
# persons.loc[persons['age'] >= 65, 'person_type'] = 'R' # Retired
# persons.loc[persons['employment_status'] == 'F', 'person_type'] = 'F' # Full-time Worker
# persons.loc[persons['employment_status'] == 'P', 'person_type'] = 'P' # Part-time Worker
# persons.loc[persons['age'] <= 18, 'person_type'] = 'S' # Student
# persons.loc[(persons['age'] > 18) & (persons['student_status'].isin({'F', 'P'})), 'person_type'] = 'U' # University/College
# persons['person_type'] = persons['person_type'].astype('category')
self._logger.debug('Classifying `student_class`')
persons['student_class'] = 'O'
mask1 = persons['student_status'] != 'O'
stu_class_groups = {'P': (5, 13), 'S': (14, 17), 'U': (18, 100)}
for stu_class, age_range in stu_class_groups.items():
mask2 = persons['age'].between(*age_range)
persons.loc[mask1 & mask2, 'student_class'] = stu_class
persons['student_class'] = persons['student_class'].astype('category')
self._logger.debug('Classifying `occ_emp`') # combine occupation and employment status into one identifier
persons['occ_emp'] = 'O'
occs = 'G P M S'.split(' ')
emp_stat_groups = {'F': {'F', 'H'}, 'P': {'P', 'J'}} # Only look at full or part time workers
for occ, status in product(occs, emp_stat_groups.keys()):
mask1 = persons['occupation'] == occ
mask2 = persons['employment_status'].isin(emp_stat_groups[status])
persons.loc[mask1 & mask2, 'occ_emp'] = f'{occ}{status}'
persons['occ_emp'] = persons['occ_emp'].astype('category')
self._logger.debug('Classifying `work_from_home`')
persons['work_from_home'] = persons['employment_status'].isin({'H', 'J'})
def _derive_trip_variables(self):
trips = self.trips
self._logger.info('Deriving additional trip variables')
self._logger.debug('Classifying `purpose`')
lookup_table = _load_model_activity_pairs() # Essentially, `purpose` is being classified on `d_act`...
indexer = pd.MultiIndex.from_arrays([trips['o_act'], trips['d_act']])
trips['purpose'] = lookup_table.reindex(indexer, fill_value='NHB').values
trips['purpose'] = trips['purpose'].astype('category')
self._logger.debug('Classifying `direction`')
orig_is_home = trips['o_act'] == 'Home'
dest_is_home = trips['d_act'] == 'Home'
trips['direction'] = 'NHB'
trips.loc[orig_is_home & dest_is_home, 'direction'] = 'H2H'
trips.loc[orig_is_home & ~dest_is_home, 'direction'] = 'Outbound'
trips.loc[~orig_is_home & dest_is_home, 'direction'] = 'Inbound'
trips['direction'] = trips['direction'].astype('category')
def _reweight_trips(self):
trips = self.trips
trip_modes = self.trip_modes
self._logger.info('Reweighting trips and trip mode tables')
self._logger.debug('Summarizing `repetitions` in the trips table')
trips['repetitions'] = trips.modes.sum('weight')
self._logger.debug('Calculating `full_weight` in the trip modes table')
trip_modes['full_weight'] = trip_modes.weight / trip_modes.trip.repetitions * trip_modes.trip.weight
|
StarcoderdataPython
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.