def classificacao():
q = Queries()
resultado = None
while not resultado:
id_aleatorio = random.randrange(1324911, 5324911)
query_txt = 'SELECT id, tribunal, texto_decisao from jurisprudencia_2_inst.jurisprudencia_2_inst where lower(texto_decisao) like "%saúde%" and classificacao is null and id = "{}";'.format(
str(id_aleatorio))
# id_aleatorio = random.randrange(19803,321358) # ID ALEATÓRIO STF
# QUERY STF
# query_txt = 'SELECT id, texto_decisao from stf.decisoes where lower(texto_decisao) like "%saúde%" and classificacao is null and id = "{}";'.format(str(id_aleatorio))
# id_aleatorio = random.randrange(448,299891) # ID ALEATÓRIO STj
# QUERY STJ
# query_txt = 'SELECT id, voto from stj.votos where lower(voto) like "%saúde%" and classificacao is null and id = "{}";'.format(str(id_aleatorio))
dados = q.query_padrao(query_text=query_txt)
if dados:
resultado = 1
session['id_p'] = dados[0][0]
id_p = dados[0][0]
# 2ª INSTÂNCIA
tribunal = dados[0][1]
texto_decisao = dados[0][2].replace('\n', '</p>\n<p>')
# STF
# tribunal = 'STF'
# texto_decisao = dados[0][1].replace('\n', '</p>\n<p>')
# STj
# tribunal = 'STj'
# texto_decisao = dados[0][1].replace('\n', '</p>\n<p>')
return render_template('classificacao.html',
texto_decisao=texto_decisao,
id_p=id_p,
tribunal=tribunal)
def getQueryDoesntSpendMost(l30, target_code, target, str_un, un_code,
str_filters, str_dna, loyalty_program, regions,
str_join, filters):
"""
Lealdade 7 Gasta mais com produtos concorrentes do que com meu produto
"""
query, table = Queries().LealdadeSpendMostMyProduct()
queries = []
str_join_item = ""
if target == 'SUB-CATEGORIA':
loyalty = 'is_loyal_l30'
elif target == 'CATEGORIA':
loyalty = 'is_loyal_l40'
else:
loyalty = 'is_loyal_b'
for l30_item in l30:
if len(str_dna) > 0:
str_join_item = str_join.format(table=table.format(l30=l30_item),
filter_personas=str_dna)
queries.append(
query.format(l30=l30_item,
filters=str_filters,
loyal='false',
program=loyalty_program,
regions=regions,
joins=str_join_item,
loyalty=loyalty))
final_query = "select count(*) from ({queries}) AS T;".format(
queries=" union ".join(queries))
return final_query
def getQueryAudienceUN(l30, target, str_filters, str_dna, loyalty_program,
regions, str_join):
"""
get audience query for loyalty 5 with UN
"""
query, table = Queries().LealdadeDoesntBuyProductAudience()
queries = []
str_join_item = ""
if target == 'SUB-CATEGORIA':
loyalty = 'is_loyal_l30'
elif target == 'CATEGORIA':
loyalty = 'is_loyal_l40'
else:
loyalty = 'is_loyal_b'
if loyalty_program == "AND loyalty_program_code in ('3')":
loyalty_program == ""
for l30_item in l30:
if len(str_dna) > 0:
str_join_item = str_join.format(table=table.format(l30=l30_item),
filter_personas=str_dna)
queries.append(
query.format(l30=l30_item,
filters=str_filters,
program=loyalty_program,
regions=regions,
joins=str_join_item,
loyalty=loyalty))
final_queries = " {queries} ".format(queries=" union ".join(queries))
return final_queries
class BaseHandler(RequestHandler):
def get_user_locale(self):
return tornado.locale.get('is_IS')
def get_current_user(self):
if self.cookies and 'user' in self.cookies:
id = self.get_secure_cookie('user')
try:
return self.q.db.query(User).filter_by(id=id, active=True).one()
except:
self.clear_cookie('user')
return None
def get_template_namespace(self):
namespace = RequestHandler.get_template_namespace(self)
namespace.update(dict(q = self.q))
return namespace
def prepare(self):
self.q = Queries(self)
def on_finish(self):
self.q.close()
def get_index_info(conn, modalidade):
"""
Get basic information about product or L20
"""
query = Queries().IndexInfoProd().replace('\n', '').strip()
prod_code = None
try:
# try to find data for l20 if product wasnt found
result, conn = execute_query_temp(query, conn)
result = result[0]
if result[0] is None:
query = Queries().IndexInfoL20().replace('\n', '').strip()
result, conn = execute_query_temp(query, conn)
result = result[0]
if result[0] is None:
raise Exception()
except Exception as e:
print("\n**** Too Bad! It seems your l20 wasnt found either! ****")
raise L20notfound(
"Nao encontrado dados para os seguintes parametros: {}".format(
str(modalidade)))
# return information about l20 or product
return {
'units_per_visit': result[0],
'min_perc_disc': result[1],
'weight_flag': result[2],
'is_alcohol': result[3]
}
def getQueryLaunchProduct(l30, target_code, target, str_un, un_code,
str_filters, str_dna, loyalty_program, regions,
str_join, filters):
"""
Lealdade 10 Compra lancamentos e minha categoria
"""
query, table = Queries().LealdadeLaunchProduct()
queries = []
str_join_item = ""
query, table = Queries().LealdadeLaunchProduct()
if len(str_dna) > 0:
str_join_item = str_join.format(table=table, filter_personas=str_dna)
queries.append(
query.format(lcode=target_code,
filters=str_filters,
program=loyalty_program,
regions=regions,
joins=str_join_item))
final_query = "select count(*) from ({queries}) AS T;".format(
queries=" union ".join(queries))
return final_query
def getQuerySpendMostloyaty10(l30, target_code, target, str_un, un_code,
str_filters, str_dna, loyalty_program, regions,
str_join, filters):
"""
Lealdade 6 gasta mais com meu produto usado na lealdade 10
"""
query, table = Queries().LealdadeSpendMostMyProductLoyalty10()
queries = []
str_join_item = ""
if loyalty_program == "AND loyalty_program_code in ('3')":
loyalty_program = ""
for l30_item in l30:
if len(str_dna) > 0:
str_join_item = str_join.format(table=table.format(l30=l30_item),
filter_personas=str_dna)
queries.append(
query.format(l30=l30_item,
filters=str_filters,
program=loyalty_program,
regions=regions,
joins=str_join_item,
loyalty=''))
final_queries = "select count(distinct prsn_id) from ({queries})".format(
queries=" union ".join(queries))
return final_queries
def getQueryAudienceUN(l30, target, str_filters, str_dna, loyalty_program,
regions, str_join):
"""
get audience query for loyalty 5 with UN
"""
query, table = Queries().LealdadeDoesntBuyProductAudience()
queries = []
str_join_item = ""
if target == 'SUB-CATEGORIA':
loyalty = 'is_loyal_l30'
elif target == 'CATEGORIA':
loyalty = 'is_loyal_l40'
else:
loyalty = 'is_loyal_b'
for l30_item in l30:
# check if l30 table exists
if checkl30(l30_item):
raise Exception('Nao existe cubo para:{}'.format(l30_item))
if len(str_dna) > 0:
str_join_item = str_join.format(table=table.format(l30=l30_item),
filter_personas=str_dna)
queries.append(
query.format(l30=l30_item,
filters=str_filters,
program=loyalty_program,
regions=regions,
joins=str_join_item,
loyalty=loyalty))
final_queries = " {queries} ".format(queries=" union ".join(queries))
return final_queries
def getQueryLaunchProduct(l30, target_code, target, str_un, un_code,
str_filters, str_dna, loyalty_program, regions,
str_join, filters):
"""
Lealdade 10 Compra lancamentos e minha categoria
"""
query, table = Queries().LealdadeLaunchProduct()
queries = []
str_join_item = ""
if len(str_dna) > 0:
str_join_item = str_join.format(table=table, filter_personas=str_dna)
queries.append(
query.format(lcode=target_code,
filters=str_filters,
program=loyalty_program,
regions=regions,
joins=str_join_item))
subtract_query = getQuerySpendMostloyaty10(l30, target_code, target,
str_un, un_code, str_filters,
str_dna, loyalty_program,
regions, str_join, filters)
final_query = "SELECT (select sum(qty) from ({queries}) as t ) - ({subquery} as d) as c".format(
queries=" union ".join(queries), subquery=subtract_query)
return final_query
class Validator(object):
def __init__(self, clientName, fileName, fileType):
self.clientName = clientName
self.fileName = fileName
self.fileType = fileType
self.queries = Queries()
self.rawTableName = self.queries.getRawTableName(self.clientName, self.fileName)
if self.validateHeader() is not True:
exit(1)
self.readfile = ReadFile(self.fileName, self.clientName)
if self.validateContent() is True:
exit(0)
else:
exit(1)
def validateHeader(self):
databaseHeader = self.queries.getDatabaseColumns('raw_file_columns', self.clientName, self.rawTableName)
fileHeader = self.readfile.getFileHeader()
for i in range(len(databaseHeader)):
if databaseHeader[i] != fileHeader[i]:
return False
return True
def validateContent(self):
dataType = self.queries.getDatabaseColumns('data_type', self.clientName, self.rawTableName)
fileContent = self.readfile.getFileContent()
for line in fileContent:
for i in range(len(line)):
if line[i] != dataType[i]:
return False
return True
def pesquisa():
if request.method == 'POST':
try:
q = Queries()
return str(q.query_tribunais(request.form['query'],tribunal='segunda_inst'))
except Exception as e:
return e
else:
return 'Preencha o formulário corretamente, por favor.'
def createQueries(config):
q = Queries(int(config['query']['runs']), config['others']['output-dir'],
config['query']['output-dir'],
config['observation']['start_timestamp'],
int(config['observation']['days']),
int(config['query']['num-locations']),
int(config['query']['num-sensors']),
int(config['query']['time-delta']))
q.generateQueries()
def __init__(self):
AuctionScanner.__init__(self)
self.q = Queries()
self.base_url = 'https://www.tutti.ch/api/v10/list.json?aggregated=1&limit=50&o=1&q=lego&with_all_regions=true'
self.headers = {
'User-Agent':
'Mozilla/5.0 (X11; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0',
'Accept': 'application/json, text/plain, */*',
'X-Tutti-Hash': '858521e7-f8d9-40ef-a534-6ae88d93165c'
}
def main():
# Input: SQLite3
conn = sqlite3.connect(
'../ExampleData/example_data_before_migration.sqlite3')
conn.row_factory = sqlite3.Row
# Output: MongoDB
client = MongoClient('localhost', 27017)
db = client.db_before_migration
if db.user.count_documents({}) == 0:
print('Loading data\n')
data_loader.populate_database(conn, db)
else:
print('Warning: Database already exists; not reloading data\n')
# Read parameters and reference results
tc_file = open('../ExampleData/query_results_before_migration.json')
test_cases = TestCases(tc_file)
queries = Queries(db, test_cases)
results, metrics = queries.execute()
failed = False
# Write complexity metrics to file
metrics.to_csv('metrics.csv')
if len(test_cases) != len(results):
raise RuntimeError('There are {} queries but {} tests'.format(
len(results), len(test_cases)))
for result in results:
if len(result.violation_indexes) == 0:
# Success
print(
'{0.name} Succeeded in {0.elapsed_time:.4f} s\n----------------'
.format(result))
else:
# Error
actual = pretty_print_json(result.actual)
expected = pretty_print_json(result.expected)
print('''{result.name} FAILED
Mismatch indexes: {result.violation_indexes}
Actual results: {actual}
Expected results: {expected}
----------------'''.format(result=result, actual=actual, expected=expected))
failed = True
if failed:
raise RuntimeError('Some tests failed')
def getl20_30Plu(modalidade, vendor):
"""
Create a temporary table with the products of this target by a PLU list
return L20 and l30 of the product
"""
query = Queries().ProductStructure()
str_prod_codes = list2str(modalidade._value.get("produto"))
query = query.format(
wheres=" prod_code in ({prods})".format(prods=str_prod_codes),
vendor=vendor)
return query
def classificacao():
q = Queries()
resultado = None
while not resultado:
id_aleatorio = random.randrange(1324911,5324911)
query_txt = 'SELECT id, tribunal, texto_decisao from jurisprudencia_2_inst.jurisprudencia_2_inst where lower(texto_decisao) like "%saúde%" and classificacao is null and id = "{}";'.format(str(id_aleatorio))
dados = q.query_padrao(query_text=query_txt)
if dados:
resultado = 1
session['id_p'] = dados[0][0]
id_p = dados[0][0]
tribunal = dados[0][1]
texto_decisao = dados[0][2].replace('\n', '</p>\n<p>')
return render_template('classificacao.html', texto_decisao = texto_decisao, id_p = id_p, tribunal = tribunal)
def post(self):
# Region Set Up
#create resultService object
_resultsService = ResultsService()
#load queries
q = Queries()
# create connection to postgres database
_connector = Connector()
conn = _connector.connect(1)
# create cursor
cur = conn.cursor()
#define query parameters
_failID = self.get_argument("_failureId")
# endregion
# Region main block
cur.execute(q._email_failure, (_failID, ))
_result = cur.fetchall()
_result_to_json = _resultsService.parse(_result)
self.render("emailMonitor.html", results=_result)
cur.close()
conn.close
def checkl30(l30):
query = Queries().TableExists().format('t_audience_l21_{}'.format(l30))
result = pd.DataFrame(execute_query(query), columns=['Table'])
return result['Table'][0] == None
def getQueryDoesntBuyL20(l21, l20, target, str_un, un_code, str_filters,
str_dna, loyalty_program, regions, str_join, filters):
query, table = Queries().LealdadeDoesntBuyl20()
if len(str_dna) > 0:
str_join = str_join.format(table=table, filter_personas=str_dna)
query = query.format(condition=str_un,
filters=str_filters,
un_code=un_code,
program=loyalty_program,
regions=regions,
joins=str_join)
return query
def get_redemption(banner, level_code, audience_type, vendor, conn):
query = Queries().conversion_rates().format(level=level_code)
if banner:
query += " AND banner ='{}' ".format(banner)
if audience_type:
query += " AND aba = '{}'".format(audience_type)
if vendor != "":
query += " AND cr.supplier_code = '{}'".format(vendor)
result, conn = execute_query_temp(query, conn)
result = pd.DataFrame(result)
if result['conversion_rate'][0] == 0:
message = "Redemption rate not found for level {l}, aba {a}, banner {b}".format(
l=level_code, a=audience_type, b=banner)
print(message)
try:
now = datetime.now()
f = open("L20ConversionNotfound.log", "a")
f.write("\n{0} - Erro: {1} ".format(
now.strftime("%d/%m/%Y %H:%M:%S"), message))
f.flush()
f.close()
finally:
r = False
else:
r = result['conversion_rate'][0]
r = format(r, '.4f')
return r
def post(self):
# Region Set Up
#create resultService object
_resultsService = ResultsService()
#load queries
q = Queries()
# create connection to postgres database
_connector = Connector()
conn = _connector.connect(2)
# create cursor
cur = conn.cursor()
#define query parameters
_firstname = self.get_argument("_firstname_field")
_lastname = self.get_argument("_lastname_field")
_timenow = datetime.datetime.now()
# endregion
# Region main block
_query = q._get_all_users
cur.execute(_query)
_result = cur.fetchall()
_result_to_json = _resultsService.parse(_result)
_query = q._create_new_user
cur.execute(_query, (_firstname, _lastname, _timenow))
conn.commit()
cur.close()
conn.close
self.redirect("/users")
def post(self):
# Region Set Up
_resultsService = ResultsService()
_q = Queries()
_connector = Connector()
conn = _connector.connect(2)
cur = conn.cursor()
# endregion
# Region Main Block
cur.execute(_q._get_all_users)
_result = cur.fetchall()
_result_to_json = _resultsService.parse(_result)
for item in _result:
_rID = str(item[3])
_id = self.get_arguments("_checkbox")
if _rID in _id:
print("Deleting " + str(item[0]))
cur.execute(_q._delete_user, (item[3], ))
conn.commit()
cur.close()
conn.close()
self.redirect("/users")
def getQueryLoyaltyUnder50(l21, l20, target, str_un, un_code, str_filters,
str_dna, loyalty_program, regions, str_join,
filters):
query, table = Queries().Lealdade50()
if len(str_dna) > 0:
str_join = str_join.format(table=table.format(l21=l21),
filter_personas=str_dna)
query = query.format(l21=l21,
filters=str_filters,
loyal='false',
program=loyalty_program,
regions=regions,
joins=str_join)
return query
def __init__(self, set_number, condition='new'):
self._url = 'http://www.bricklink.com/catalogPG.asp?S={}-1&ColorID=0'.format(
set_number)
self._headers = {
'User-Agent':
'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.132 Safari/537.36'
}
self.condition = condition
self.prices = {}
self.set_number = set_number
self.scan_date = datetime.now()
self.exchange_rates = {}
self.toCurrency = 'CHF'
self.result = {}
self.db = MySQLDatabase()
self.q = Queries()
self._parse_prices()
def getl20_30category(modalidade, vendor):
"""
Create a temporary table with the products of this target by a category
return L20 and l30 of the product
"""
query = Queries().ProductStructure()
depart = modalidade._value.get('departamento')
categoria = modalidade._value.get('categoria')
code = (depart, categoria)
str_codes = "".join(code)
query = query.format(
wheres="prod_hier_l40_code in ('{grupo}')".format(grupo=str_codes),
vendor=vendor)
return query
def getl20_30Familia(modalidade, vendor):
"""
Create a temporary table with the products of this target by a PLU and Familia
return L20 and l30 of the product
"""
query = Queries().ProductStructureFamily()
family_code = modalidade._value.get("familia")
#subgrupo = modalidade._value.get("subgrupo")
#modalidade.subgrupo
query = query.format(subgrupo=modalidade.subgrupo,
family=family_code,
vendor=vendor)
return query
def getinfoPLU(self):
modalidade = self._value
strquery = Queries.getProductInfo()
strquery = strquery.format(produto)
subcategoria = ""
grupo = ""
subgrupo = ""
subgrupo = ""
def get_average_price(self, conn):
"""
return average price for the products, need the connection that holds product temporary table
"""
query = Queries().AveragePrice()
result, conn = execute_query_temp(query, conn)
result = pd.DataFrame(
result, columns=['avg_prod_price_clex', 'avg_prod_price_pa'])
return result['avg_prod_price_clex'][0], result['avg_prod_price_pa'][
0],
def getQueryRecover(l30, target_code, target, str_un, un_code, str_filters,
str_dna, loyalty_program, regions, str_join, filters):
"""
Lealdade 20 Compra lancamentos e minha categoria
"""
query, table = Queries().LealdadeRecoverProduct()
#query = query.format(l21=l21,
# filters=str_filters, loyal='true',
# program=loyalty_program, regions=regions,
# joins=str_join)
queries = []
str_join_item = ""
if target == 'SUB-CATEGORIA':
loyalty = 'is_loyal_l30'
elif target == 'CATEGORIA':
loyalty = 'is_loyal_l40'
else:
loyalty = 'is_loyal_b'
for l30_item in l30:
# check if l30 table exists
if checkl30(l30_item):
raise Exception('Nao existe cubo para:{}'.format(l30_item))
if len(str_dna) > 0:
str_join_item = str_join.format(table=table.format(l30=l30_item),
filter_personas=str_dna)
queries.append(
query.format(l30=l30_item,
filters=str_filters,
loyal='true',
program=loyalty_program,
regions=regions,
joins=str_join_item,
loyalty=loyalty))
final_query = "select count(*) from ({queries}) AS T;".format(
queries=" union ".join(queries))
return final_query
def getQueryRecover(l30, target_code, target, str_un, un_code, str_filters,
str_dna, loyalty_program, regions, str_join, filters):
"""
Lealdade 20 Compra lancamentos e minha categoria
"""
query, table = Queries().LealdadeRecoverProduct()
#query = query.format(l21=l21,
# filters=str_filters, loyal='true',
# program=loyalty_program, regions=regions,
# joins=str_join)
queries = []
str_join_item = ""
if target == 'SUB-CATEGORIA':
loyalty = 'is_loyal_l30'
elif target == 'CATEGORIA':
loyalty = 'is_loyal_l40'
else:
loyalty = 'is_loyal_b'
if loyalty_program == "AND loyalty_program_code in ('3')":
loyalty_program == ""
for l30_item in l30:
if len(str_dna) > 0:
str_join_item = str_join.format(table=table.format(l30=l30_item),
filter_personas=str_dna)
queries.append(
query.format(l30=l30_item,
filters=str_filters,
loyal='true',
program=loyalty_program,
regions=regions,
joins=str_join_item,
loyalty=loyalty))
final_query = "select count(distinct t.prsn_id) from ({queries}) AS T;".format(
queries=" union ".join(queries))
return final_query
def __init__(self, config):
self.query_f = Queries.get_by_name(config['query'])
self.score_f = Scores.get_by_name(config['score'])
self.create_model = Models.get_by_name(config['model'])
if 'encoder' in config:
self.create_encoder = Encoders.get_by_name(config['encoder'])
self.init_size = config['init_size']
self.batch_size = config['batch_size']
self.total_size = config['total_size']
self.queries_number = config['queries_number']
self.random_state = config['random_state']
class TestSimpleQueries(unittest.TestCase):
def setUp(self):
self.connection = mysql.connector.connect(user='******', password='******', database='test_data')
self.cursor = self.connection.cursor()
self.queries = Queries(self.cursor)
def tearDown(self):
self.cursor.close()
self.connection.close()
@weight(1)
def test_department_budget(self):
"""Get department budget by name"""
val = self.queries.department_budget("Engineering")
self.assertEqual(val, 1000000)
@weight(1)
def test_department_expenses(self):
"""Get department expenses by name"""
val = self.queries.department_expenses("Engineering")
self.assertEqual(val, 200000)
def __init__(self, clientName, fileName, fileType):
self.clientName = clientName
self.fileName = fileName
self.fileType = fileType
self.queries = Queries()
self.rawTableName = self.queries.getRawTableName(self.clientName, self.fileName)
if self.validateHeader() is not True:
exit(1)
self.readfile = ReadFile(self.fileName, self.clientName)
if self.validateContent() is True:
exit(0)
else:
exit(1)
def add_test_data(app, db):
cpp = ProgrammingLanguage(name='C++', compile_cmd="g++ %(file)s -o %(exe)s -O3", run_cmd="./%(exe)s")
db.add(cpp)
db.flush()
fk2012 = Contest(name=u'Forritunarkeppni Framhaldsskólanna 2012',
public=True,
start_time=datetime.datetime(2012, 3, 16, 9, 0, 0),
registration_start=datetime.datetime(2012, 1, 1, 0, 0, 0))
db.add(fk2012)
db.flush()
p1 = Problem(name=u'Lóðarí',
public=True,
description=u"""
<p>Sveitarfélag nokkurt á austurlandi hefur nýlega hafið að selja ferningslaga lóðir. Lóðirnar liggja allar í beinni línu frá norðri til suðurs, en vegna skipulagsmistaka, þá er engin lóð jafn stór og önnur, því fyrir sérhverja lóð, þá er lóðin fyrir sunnan hana einum metra lengri á hvorn kant. Þetta hefur valdið bæjaryfirvöldum miklum höfuðverk og þið hafið verið kölluð til aðstoðar.</p>
<p>Þið fáið það hlutverk að skrifa forrit sem að reiknar muninn á flatarmáli samliggjandi lóða. Það er, að gefinni hliðarlengd lóðar (sem er ekki syðsta lóðin), þá eigið þið að reikna út hversu mörgum fermetrum stærri lóðin er fyrir sunnan gefnu lóðina.</p>
<h2>Inntak</h2>
<p>Inntakið byrjar á einni heiltölu <tt>C</tt>, sem gefur fjölda prófunartilvika sem á eftir koma. Hvert prófunartilvik samanstendur af einni línu sem inniheldur eina heiltölu <tt>1 ≤ x ≤ 100000</tt>, sem gefur hliðarlengd lóðar.</p>
<h2>Úttak</h2>
<p>Fyrir sérhvert prófunartilvik á að skrifa út eina línu sem inniheldur eina heiltölu, sem gefur hversu mörgum fermetrum lóðin fyrir sunnan gefnu lóðina er stærri en gefna lóðin.</p>
<h2>Dæmi um inntak</h2>
<pre><tt>2
3
8</tt></pre>
<h2>Dæmi um úttak</h2>
<pre><tt>7
17</tt></pre>
""",
solution=u"""
#include<iostream>
using namespace std;
#ifndef ONLINE_JUDGE
#define DEBUG 0
#endif
//-------------------
#ifdef ONLINE_JUDGE
#define DEBUG 0
#endif
#if DEBUG > 1
#define dout cout
#else
#define dout 0 && cout
#endif
#if DEBUG > 0
#include<cstdio>
#define read(file) freopen(file,"r",stdin)
#define write(file) freopen(file,"w",stdout)
#else
#define read(file)
#define write(file)
#endif
int main()
{
read("in.txt");
int test_cases;
int curr;
cin >> test_cases;
while(test_cases--)
{
cin >> curr;
cout << 2 * curr + 1 << '\n';
}
return 0;
}
""",
solution_lang_id=cpp.id,
time_limit=3*1000,
memory_limit=64*1024*1024)
db.add(p1)
db.flush()
p1c = ContestProblem(short_id='A', problem_id=p1.id, contest_id=fk2012.id)
db.add(p1c)
db.flush()
p1t1 = Test(problem_id=p1.id,
input=u"""5
1
2
3
7
15
""", output=u"""3
5
7
15
31
""")
db.add(p1t1)
db.flush()
p2 = Problem(name="Biskupinn", public=True, description=u"""
<p>Í þessu verkefni ímyndum við okkur að við séum með <tt>N×N</tt> skákborð og
jafnframt ímyndum við okkur að það sé aðeins einn leikmaður á borðinu, þ.e.
biskupinn. Staðsetningar, eða reitir, á skákborðinu eru táknaðar með raðpari <tt>(r,c)</tt>, þ.a. <tt>1 ≤ r,c ≤ N</tt>, þar sem <tt>r</tt> segir til um í hvaða röð reiturinn er og <tt>c</tt> segir til um í hvaða dálki reiturinn er. Staðsetningin <tt>(1,1)</tt> vísar þá til reitsins
sem er neðst í vinstra horninu og <tt>(N,N)</tt> vísar til reitsins efst í hægra horninu.</p>
<p>Verkefni ykkar er nú að finna fæstu mögulegu hreyfingar sem þarf til að koma biskupnum á ákveðinn
reit á skákborðinu, ef það er yfir höfuð hægt. Hreyfingar biskupsins eru eins og í hefðbundinni skák,
þ.e. hann getur ferðast á ská eins marga reiti og vera vill.</p>
<h2>Inntak</h2>
<p>Inntakið byrjar á einni heiltölu <tt>C</tt>, sem gefur fjölda prófunartilvika sem á eftir koma. Á eftir þessari línu
kemur auð lína, og að auki kemur auð lína milli prófunartilvika.</p>
<p>Fyrsta lína hvers prófunartilviks inniheldur eina heiltölu <tt>1 ≤ T ≤ 100</tt>, sem gefur fjölda prófana í því
prófunartilviki. Önnur línan inniheldur eina heiltölu <tt>1 ≤ N ≤ 100.000.000</tt> (stærð skákborðsins er <tt>N×N</tt>). Á eftir þeirri línu koma svo <tt>T</tt> línur, hver með einni prófun. Hver lína inniheldur fjórar
heiltölur, aðskildar með einu orðabili. Fyrstu tvær tölurnar gefa röð og dálk biskupsins og seinni tvær
gefa röð og dálk reitsins sem að biskupinn vill komast á.</p>
<h2>Úttak</h2>
<p>Fyrir sérhverja prófun, á að skrifa út eina línu. Línan á að innihalda eina heiltölu, sem gefur minnsta
fjölda hreifinga sem þarf til að færa biskupinn á gefna reitinn, eða <tt>“impossible”</tt> ef ómögulegt er
fyrir biskupinn að komast á reitinn.</p>
<h2>Dæmi um inntak</h2>
<pre><tt>2
3
8
3 6 6 3
4 2 2 3
7 2 1 4
2
6
1 2 6 5
2 3 5 1</tt></pre>
<h2>Dæmi um úttak</h2>
<pre><tt>1
impossible
2
2
impossible</tt></pre>
""", solution=u"""
#include<iostream>
using namespace std;
#ifndef ONLINE_JUDGE
#define DEBUG 0
#endif
//-------------------
#ifdef ONLINE_JUDGE
#define DEBUG 0
#endif
#if DEBUG > 1
#define dout cout
#else
#define dout 0 && cout
#endif
#if DEBUG > 0
#include<cstdio>
#define read(file) freopen(file,"r",stdin)
#define write(file) freopen(file,"w",stdout)
#else
#define read(file)
#define write(file)
#endif
int total_test_cases, test_cases, board_size;
int bishop_r, bishop_c;
int target_r, target_c;
int abs(int a)
{
return a < 0 ? -a : a;
}
int main()
{
read("in.txt");
cin >> total_test_cases;
while(total_test_cases--)
{
cin >> test_cases;
cin >> board_size;
while(test_cases--)
{
cin >> bishop_r >> bishop_c >> target_r >> target_c;
if( (bishop_r + bishop_c) % 2 != (target_r + target_c) % 2 )
{
cout << "impossible\n";
}
else if(bishop_r == target_r && bishop_c == target_c)
{
cout << 0 << '\n';
}
else if( abs(bishop_r - target_r) == abs(bishop_c - target_c) )
{
cout << 1 << '\n';
}
else
{
cout << 2 << '\n';
}
}
}
return 0;
}
""", solution_lang_id=cpp.id, time_limit=3*1000, memory_limit=64*1024*1024)
db.add(p2)
db.flush()
p2c = ContestProblem(short_id='B', problem_id=p2.id, contest_id=fk2012.id)
db.add(p2c)
db.flush()
p2t1 = Test(problem_id=p2.id, input=u"""3
4
8
3 6 6 3
4 2 2 3
7 2 1 4
3 3 3 3
9
12
1 1 10 10
1 1 10 9
1 2 7 4
6 3 4 1
6 3 2 7
6 3 7 2
6 3 11 8
6 5 4 5
6 5 6 6
2
10000000
150 723 9010024 7234123
1 1 10000000 10000000
""", output=u"""1
impossible
2
0
1
impossible
2
1
1
1
1
2
impossible
2
1
""")
db.add(p2t1)
db.flush()
test_user = User(username="******", password_hash=Queries._User_hash_password("test", "test", app.settings["cookie_secret"]), email='*****@*****.**', active=True)
db.add(test_user)
db.flush()
test_user_team = Team(name="test", locked=True)
db.add(test_user_team)
db.flush()
db.add(TeamMember(user_id=test_user.id, team_id=test_user_team.id, leader=True))
db.flush()
db.add(Registration(team_id=test_user_team.id, contest_id=fk2012.id))
cs_p1_1 = Submission(team_id=test_user_team.id, problem_id=p1.id, contest_id=fk2012.id, verdict='WA', solution='', solution_lang_id=cpp.id)
cs_p1_2 = Submission(team_id=test_user_team.id, problem_id=p1.id, contest_id=fk2012.id, verdict='AC', solution='', solution_lang_id=cpp.id)
cs_p2_1 = Submission(team_id=test_user_team.id, problem_id=p2.id, contest_id=fk2012.id, verdict='WA', solution='', solution_lang_id=cpp.id)
db.add(cs_p1_1)
db.add(cs_p1_2)
db.add(cs_p2_1)
for i in range(-100, 8):
db.add(Contest(name='Test %d' % i,
public=True,
start_time=datetime.datetime.now() + datetime.timedelta(0, i * 60 * 60, 0),
registration_start=datetime.datetime.now() + datetime.timedelta(0, i * 60 * 60, 0) - datetime.timedelta(0, 2 * 60 * 60, 0),
registration_end=datetime.datetime.now() + datetime.timedelta(0, i * 60 * 60, 0) - datetime.timedelta(0, 1 * 60 * 60, 0),
duration=3 * 60))
db.add(Message(user_to_id=test_user.id, user_from_id=test_user.id, subject=u"Halló Heimur", content=u"Halló! Þetta er prufa..."))
db.add(Message(user_to_id=test_user.id, user_from_id=test_user.id, subject=u"Meeoooww", content=u"Halló! Þetta er meiri prufa..."))
db.add(Message(user_to_id=test_user.id, user_from_id=test_user.id, subject=u"Mooo", content=u"Þetta er meiri prufa...", read=True))
db.add(User(username='******', api_key='65d13f6a296145338e12a26cda0a0eea', active=True))
db.commit()
def prepare(self):
self.q = Queries(self)
