Statistiche gare Bebras italiano 2024¶

In [1]:
from IPython.display import HTML

HTML('''<script>
code_show=true; 
function code_toggle() {
 if (code_show){
 $('div.input').hide();
 } else {
 $('div.input').show();
 }
 code_show = !code_show
} 
$( document ).ready(code_toggle);
</script>
<input type="button" value="Clicca per vedere/nascondere il codice Python" onclick="code_toggle()">''')
Out[1]:
In [2]:
import warnings
#warnings.filterwarnings('once')
warnings.filterwarnings('ignore')

Distribuzione dei punteggi¶

In [3]:
import pandas as pd
import numpy as np
import json, hashlib, urllib, os.path

pd.options.display.max_rows = None
pd.options.display.max_columns = None
In [4]:
CATS = ('kilo','mega','giga','tera','peta')
CATEGORIES = tuple(f'{c}' for c in CATS)
CAT_FILES = tuple(f'{c}' for c in CATS)
In [5]:
with open('secret.key') as k:
    key = k.readline().strip()

for i, k in enumerate(CAT_FILES):
    if not os.path.exists(f"results-{k}.json"):
        r = urllib.request.urlopen(f"https://bebras.it/api?key={key}&view=exams&edition=bebras_2024&events=0&test={121+i}")
        with open(f"results-{k}.json", "w") as tw:
            tw.writelines(r.read().decode('utf-8'))
In [6]:
score = []
for k in CATEGORIES:
    with open(f"results-{k}.json", "r") as t:
        j = json.load(t)
        score += j['exams']
In [7]:
scoredf = pd.DataFrame(score)
In [8]:
# L'orario va corretto per il fuso orario

scoredf['server_start'] = pd.to_datetime(scoredf['exam_date'].astype('int64') + 60*60, unit='s')
scoredf['orainizio'] = np.floor((scoredf['exam_date'].astype('int64') + 60*60) / (45*60)) # ore da 45', il tempo di gara
scoredf['punteggio'] = pd.to_numeric(scoredf['score'])
scoredf['punteggio_norm'] = scoredf['punteggio'].map(lambda x: x if x >= 0 else 0)
scoredf['anonid'] = scoredf['team_id'].map(lambda x: hashlib.md5(str(x).encode('utf8')).hexdigest())
scoredf['categoria'] = scoredf['category'].str.lower().astype(pd.api.types.CategoricalDtype(categories = CATEGORIES, ordered=True))
In [9]:
valid = scoredf[scoredf['exam_valid_score'] == 1]
valid.to_csv('anonris.csv', columns=['anonid', 'categoria', 'orainizio', 'punteggio', 'punteggio_norm', 'time'])
In [10]:
from IPython.display import display, Markdown

txt = '''<table>
<caption>Squadre partecipanti al Bebras 2024/25 con risultati correttamente registrati</caption>
<thead>
  <tr><th>Categoria</th>
  <th>squadre</th>
  <th> min </th>
  <th> max </th>
  <th> media </th>
  <th> std.dev. </th>
  <th>I quartile </th>
  <th>mediana </th>
  <th>III quartile</th>
  <th>Squadre al minimo</th>
  <th>Squadre al massimo</th>
</tr>
<tbody>
'''
for k in valid['categoria'].unique().sort_values():
    s = valid[valid['categoria'] == k]['punteggio_norm'].describe()
    top = valid[(valid['categoria'] == k) & (valid['punteggio_norm'] == int(s['max']))]
    bottom = valid[(valid['categoria'] == k) & (valid['punteggio_norm'] == int(s['min']))]
    txt += "<tr><th>{}</th><td>{}</td><td>{}</td><td>{}</td><td>{:.1f}</td>\
<td>{:3.1f}</td><td>{}</td><td>{}</td><td>{}</td><td>{:.1f}%</td><td>{:.1f}%</td></tr>".format(k, 
                                                              int(s['count']),
                                                              int(s['min']),
                                                              int(s['max']),
                                                              float(s['mean']),
                                                              float(s['std']),
                                                              int(s['25%']), 
                                                              int(s['50%']), 
                                                              int(s['75%']),
                                                              100*len(bottom)/float(s['count']),
                                                              100*len(top)/float(s['count']))
txt += '<tfoot><tr><th>Totale</th><td>{}</td></tr>'.format(valid['punteggio_norm'].count())
txt += '</table>'
display(Markdown(txt))
Squadre partecipanti al Bebras 2024/25 con risultati correttamente registrati
Categoria squadre min max media std.dev. I quartile mediana III quartile Squadre al minimo Squadre al massimo
kilo346204821.010.31320280.7%0.4%
mega1069404823.110.11623300.6%0.4%
giga500804821.49.51520270.6%0.4%
tera265304817.28.61116220.5%0.3%
peta188204813.57.7812181.9%0.2%
Totale23699
In [11]:
%matplotlib inline
import matplotlib.pyplot as plt
plt.style.use('ggplot')

histograms = valid['punteggio_norm'].hist(by=valid['categoria'], bins=24, figsize=(10,16), layout=(5, 2))
No description has been provided for this image

Percentili per punteggio¶

In [12]:
for k in valid['categoria'].unique().sort_values():
    tot = float(valid[(valid['categoria'] == k)]['punteggio'].count())
    top = int(valid[(valid['categoria'] == k)]['punteggio'].max())
    pp = [100 * valid[(valid['categoria'] == k) & (valid['punteggio'] < i)]['punteggio'].count()/tot for i in range(1,top+1)]
    txt = '''<table>
    <caption>Percentili per la categoria {} (che percentuale di squadre si supera con un dato punteggio)</caption>
    <thead>'''.format(k)
    txt += ''.join(['<td>{}</td>'.format(i) for i in range(1,top+1)])
    txt += '<tbody>'
    txt += ''.join(['<td>{:.1f}</td>'.format(f) for f in pp])
    txt += '</table>'
    display(Markdown(txt))    
Percentili per la categoria kilo (che percentuale di squadre si supera con un dato punteggio)
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748
0.71.11.92.93.95.97.510.112.014.817.219.722.826.129.232.536.139.643.546.950.754.156.860.963.967.269.672.375.678.581.083.285.487.589.090.692.293.594.795.796.697.198.298.399.299.299.599.6
Percentili per la categoria mega (che percentuale di squadre si supera con un dato punteggio)
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748
0.61.01.52.12.93.74.96.27.69.111.213.616.018.621.424.127.230.433.737.340.944.448.251.955.559.062.666.269.272.675.578.380.883.285.487.489.491.392.894.395.496.297.298.098.499.099.499.6
Percentili per la categoria giga (che percentuale di squadre si supera con un dato punteggio)
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748
0.60.81.11.92.43.54.45.97.39.711.814.417.220.724.228.132.736.541.645.150.153.357.661.065.468.572.875.178.380.583.284.987.188.390.291.292.793.694.895.796.797.398.198.598.699.299.599.6
Percentili per la categoria tera (che percentuale di squadre si supera con un dato punteggio)
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748
0.50.81.82.64.35.77.810.814.517.822.627.132.537.142.546.951.856.361.464.968.872.275.478.681.183.586.588.690.291.292.393.193.994.695.496.397.197.797.998.298.498.799.199.399.499.699.799.7
Percentili per la categoria peta (che percentuale di squadre si supera con un dato punteggio)
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748
1.92.05.05.910.913.319.023.128.632.638.944.050.353.959.163.467.972.376.079.782.785.188.090.091.793.195.095.996.997.397.798.098.098.498.698.698.899.199.499.499.499.599.599.699.699.699.899.8

Analisi delle risposte¶

In [13]:
rr = []
errors = 0
for r in valid.itertuples():
    for q in r.exam_data['questions']:
        try:
            t = dict((k, q[k]) for k in ('q_id','q_class','q_score','q_scoreMax','q_time'))
            t['anonid'] = r.anonid
            rr.append(t)
        except Exception as e:
            errors += 1
print(errors)
2448
In [14]:
quiz = pd.DataFrame(rr)
In [15]:
quiz['q_id'] = quiz['q_id'].str.split(pat='_', expand=True)[1]
In [16]:
MAPNAMES = {
    'Q01': 'La strada smarrita',
    'Q02': 'Vestiti',
    'Q03': 'Giocattoli in ordine',
    'Q04': 'La macchina del gelato',
    'Q05': 'Barca in porto',
    'Q06': 'Il pirata e il tesoro',
    'Q07': 'Bebramon',
    'Q08': 'Tastiera rotta',
    'Q10': 'Animali in viaggio',
    'Q11': "L'alfabeto dei Tuareg",
    'Q12': 'Palline binarie',
    'Q13': "Buon compleanno!",
    'Q15': 'Bilancia',
    'Q16': 'Videogioco',
    'Q17': 'Muretti a secco',
    'Q18': 'Passeggiata tra gli alberi',
    'Q19': 'Catene di parole',
    'Q20': 'La macchina dei palloncini',
    'Q21': 'Macchinine automatiche',
    'Q22': 'Animali in ordine',
    'Q23': 'Frecce che spariscono',
    'Q24': 'Arte programmata',
    'Q25': "Mappa del tesoro",
    'Q27': 'La mappa delle monete',
    'Q28': 'Robot da disegno',
    'Q29': 'Trasformazione di immagini',
    'Q30': 'I doni di Babbo Castoro',
    'Q31': 'Tastiera crittografica'
}

assert set(MAPNAMES.keys()) == set(quiz['q_id'].unique())
In [17]:
quiz = quiz.rename(columns={'q_time': 'time', 'q_score': 'score', 'q_scoreMax': 'score_max', 'q_class': 'cat'})
In [18]:
quiz['nome'] = quiz['q_id']
quiz['edizione'] = '2024'
quiz['completo'] = quiz['score'] == quiz['score_max']
quiz['parziale'] = (quiz['score'] > 0) & (quiz['score'] != quiz['score_max'])
quiz['penalizzato'] = quiz['score'] < 0
quiz['voto'] = quiz['score'] / quiz['score_max'].astype('float64')
quiz['minuti'] = quiz['time'].map(lambda x: float(x)/60. if float(x) >= 0 and float(x) <= 45*60 else np.NaN)

quiz.to_csv('quiz.csv', columns=['anonid', 'cat', 'edizione', 'nome', 'score', 'score_max', 'time'])
In [19]:
vquiz = pd.merge(valid[['anonid', 'categoria', 'punteggio','punteggio_norm','orainizio','teacher_id','school_cap']], quiz, on='anonid')
In [20]:
fig, ax = plt.subplots(ncols=1, nrows=len(valid['categoria'].unique()), figsize=(16, 40))
for j, k in enumerate(valid['categoria'].unique().sort_values()):
    ax[j].set_ylim([0, 1])
    m = vquiz[vquiz['categoria'] == k].groupby('nome', sort=False)\
        [['completo','voto', 'parziale', 'penalizzato', 'minuti','score_max']].mean()
    m['vparziale'] = m['voto'] - m['completo']
    c = ax[j].bar(np.arange(m.index.size), m['completo'], color='blue')
    p = ax[j].bar(np.arange(m.index.size), m['parziale'], bottom=m['completo'], color='lightblue')
    ax[j].set_xticks(np.arange(m.index.size), map(lambda x: MAPNAMES[x], m.index.tolist()), rotation=45)
    ax[j].set_yticks(np.arange(0,1.2,.2), [f'{100*y:.0f}%' for y in np.arange(0,1.2,.2)])
    for i, y in enumerate(m['voto'].tolist()):
        ax[j].annotate(text=f"{m['minuti'].iloc[i]:.0f}'", xy=(i, .75*m['completo'].iloc[i]), color='white')
        ax[j].annotate(text=f"{m['score_max'].iloc[i]:.0f}", xy=(i-.15, .02), color='yellow', fontsize='x-large')
    ax[j].legend((c[0],p[0]), ('completo','parziale'), loc=(.92,.6))
    ax[j].set_title(f'{k}: tassi di soluzione (il numero in alto indica i minuti spesi in media sul quesito, \
il numero in basso il punteggio massimo ottenibile)')

fig.tight_layout()
fig.savefig('tassisol.png')
No description has been provided for this image
In [21]:
fig, ax = plt.subplots(ncols=1, nrows=len(valid['categoria'].unique()), figsize=(16, 40))
for j, k in enumerate(valid['categoria'].unique().sort_values()):
    ax[j].set_ylim([-1, 1])
    m = vquiz[vquiz['categoria'] == k].groupby('nome', sort=False)\
        [['completo','voto', 'parziale', 'penalizzato', 'minuti','score_max']].mean()
    m['vparziale'] = m['voto'] - m['completo']

    c = ax[j].bar(np.arange(m.index.size), m['voto'], color='green')
    z = ax[j].bar(np.arange(m.index.size), -m['penalizzato'], color='red')
    ax[j].set_yticks(np.arange(-1,1.2,.2), [f'{100*abs(y):.0f}%' for y in np.arange(-1,1.2,.2)])
 
    ax[j].set_xticks(np.arange(m.index.size), map(lambda x: MAPNAMES[x], m.index.tolist()), rotation=45)
    for i, y in enumerate(m['voto'].tolist()):
        ax[j].annotate(text=f'{m['score_max'].iloc[i]:.0f}', xy=(i, -.8), color='blue')
    
    ax[j].legend((c[0],z[0]), ('punteggio','penalità'), loc=(0.91,.725))
    ax[j].set_title(f'{k}: percentuale di punteggio attribuito in media, in rosso la percentuale di penalizzati (il numero in basso è il punteggio massimo)')

fig.tight_layout()
fig.savefig('punti.png')