Software para carrera contrarreloj

Estoy buscando una pieza de software para conducir una carrera contrarreloj local. Habrá unos 50 corredores: lo suficientemente grandes como para hacer que el trabajo de preparar los resultados de la carrera con lápiz y papel pelados sea bastante duro y lento, pero demasiado pequeño para usar sistemas de chips de carrera completos.

Los pasajeros comenzarán con un intervalo de un minuto y en la línea de llegada habrá un hombre anunciando la hora al operador. Entonces, el operador solo tendrá que ingresar el tiempo del piloto para el programa. El programa debería poder producir la tabla de resultados sobre la marcha a medida que los ciclistas cruzan la línea.

Entiendo que crear este tipo de software no es tan difícil, pero esperaba que haya soluciones gratuitas disponibles que pueda usar para mi evento. Avísame si alguna vez has oído hablar de alguno.

Esto se ejecutará en python (solo 3.X, no 2.7), un lenguaje de programación gratuito para instalar. Simplemente guarde lo siguiente como un final de archivo .py, por ejemplo timetrials.py. Luego abra IDLE3 (menú de inicio) y abra el archivo ( Ctrl+ O). Finalmente, presione F5para iniciarlo.

import datetime
from operator import itemgetter

def get_int_input(prompt, min_=0, max_=None):
    """Get a valid integer input."""
    while True:
        try:
            i = int(input(prompt))
        except ValueError:
            print("Please enter an integer.")
        else:
            if min_ is not None and i < min_:
                print("Must be at least {0}.".format(min_))
                continue
            elif max_ is not None and i > max_:
                print("Must be at most {0}.".format(max_))
                continue
            return i

def get_time():
    """"Get a time input as a datetime.time object."""
    h = get_int_input("Hours (0-23): ", max_=23)
    m = get_int_input("Minutes (0-59): ", max_=59)
    s = get_int_input("Seconds (0-59): ", max_=59)
    ms = get_int_input("Milliseconds (0-999): ", max_=999)
    return datetime.time(h, m, s, ms*1000)

def get_results(competitors):
    """Get a dict of finishing times for all competitors."""
    results = {}
    for _ in range(competitors):
        while True:
            competitor = get_int_input("Enter competitor number: ", min_=1, max_=competitors+1)
            if competitor not in results:
                results[competitor] = get_time()
                break
            print("Time already entered.")
        print_results(results)
    return results

def print_results(results):
    """Display the race results in a table, fastest first."""
    linet = '┌' + "─" * 12 + '┬' + '─' * 17 + '┐'
    linec = '├' + "─" * 12 + '┼' + '─' * 17 + '┤'
    lineb = '└' + "─" * 12 + '┴' + '─' * 17 + '┘'
    print(linet)
    print("│ Competitor │ Time (H:M:S)    │")
    for n, t in sorted(results.items(), key=itemgetter(1)):
        print(linec)
        print("│ {0:<10d} │ {1!s:<15} │".format(n, t))
    print(lineb)

def race():
    """Handle race times for a user-specified number of competitors."""
    n = get_int_input("Enter number of competitors (2-): ", min_=2)
    results = get_results(n)

if __name__ == "__main__":
    race()

Cuando todos hayan terminado, se verá así:

┌──────────────┬───────────────┐  
│  Con Num     │ Time H:M:S    │  
├──────────────┼───────────────┤  
│  1           │ 5:4:3.2       │  
├──────────────┼───────────────┤  
│  2           │ 8:7:6.5       │  
├──────────────┼───────────────┤  
│  3           │ 2:2:2.2       │  
└──────────────┴───────────────┘  

Una opción es RaceSplitter . Esta es una aplicación para iOS, cuesta $ 35. Necesitará un iPad, iPhone o iPod Touch adecuado para ejecutarlo.

Puede ingresar una lista de inicio por adelantado. Luego, durante la carrera, solo tiene que ingresar el número de piloto mientras cruzan la línea de meta, y registrará su tiempo. Luego puede publicar los resultados en el sitio web y exportarlos a Excel, etc.

No lo he intentado yo mismo, pero lo he visto en uso en algunas carreras locales. Parece funcionar bien para el tiempo, y obtuvieron los resultados en línea poco después de la carrera.

Hemos utilizado una aplicación para teléfonos Android hecha por Liuto. Fue genial, fácil de aprender / usar y barato: solo $ 1.11. Básicamente, cuando cada jinete sale por número de inicio, toca su número correspondiente en su regreso y se completa el cálculo de su tiempo versus el tiempo transcurrido general. ¡Chasquido!