Aceasta pagina e in constructie

LimeEval

Este un evaluator gratuit pentru mediul Windows, care automatizeaza procesului de compilare si punctare a problemelor de natura algoritmica. Creat in special pentru a aduce suport schimbarilor necesare Olimpiadei Judetene de Informatica, trecerea la compilatoare pe 32 de biti Destinat OJI-ului si a concursurilor de informatica (interjudetene, pe clasa etc..) pentru a facilita o compilare si evaluare a concurentilor automatizata intr-un mediu sigur. Destinat elevilor si profesorilor care sustin o activitate de pregatire la informatica cu probleme de concurs <br> Linkurile de download sunt in dreapta. Pentru a rula evaluatorul aveti nevoie de un sistem de operare Windows XP, si framework-ul .NET 2.0 instalat. <br> Screenshots Structura de fisiere a evaluatorului Instructiuni de folosire Tutorial 1 : Instalare si configurare compilatoare Tutorial 2 : Creare si definire runda Tutorial 3 : Compilarea si evaluarea unei runde definite anterior Tutorial 4 : Consola grafica - warninguri si erori Tutorial 5 : Rulare evaluator in mod consola Download runde Intrebari frecvente Sursa verif <br>

Versiune : 0.9.3.11 Framework .NET : 2.0 Functii generale : - mod consola / mod grafic - configurare completa din interfata - compilare automata surse concurenti (selectiva sau totala) - posibilitate de specificare a compilatoare multiple - directive custom de compilare - salvare output compilatoare pe fiecare sursa - xml generat cu rezultatele compilarii tuturor concurentilor - evaluare (selectiva sau totala) in mod sandbox - limitare de timp si limitare de memorie - evaluare test cu test, sau rapida - salvarea in fisier individual outputului produs de fiecare concurent pe fiecare test - salvare in fisier individual rezultate evaluare pe fiecare test (punctaj, timp, memorie, mesaj verif) - xml generat cu rezultatele totale ale evaluarii - curatare foldere concurenti \ filtrare surse \ redenumire surse - error reporting, exceptii, warninguri, erori, salvate in fisiere si afisate in consola grafica To Do : - clasament real time, si detasat din tab control - exportare borderouri in *.txt-uri individuale pentru fiecare concurent - exportare clasament in *.xls (Excel) Buguri cunoscute : - in timpul evaluarii in mod grafic (fara pauza), daca se tot face resize la tabel, aplicatia se blocheaza. (thread deadlock)

<br><br>

Screenshots

<br><br><br>

Structura de fisiere a evaluatorului

In folderul root al evaluatorului :

! Numele de mai jos sunt doar exemple nu sunt fixe, ele depind de configurarea fiecarei runde

Undeva pe disc :

In surse se poate copia orice. Folderele si fisierele care nu sunt solutii la probleme si nu au extensiile valide
vor fi sterse

Pentru fiecare problema specificata in fisierul cu teste trebuie sa fie un folder cu numele acesteia. Acesta trebuie sa contina testele de intrare, testele de iesire corecte si un (verificator) verif.exe - care verifica corectitudinea raspunsului concurentului pe out-ul produs de acesta. (mai multe in "Intrebari frecvente":(#intrebari) )

Se va creea de catre evaluator pentru fiecare id un folder cu valoarea id-ului, si pentru fiecare compilator cu care s-au compilat sursele concurentului, va exista un folder si in fiecare folder va exista un executabil, cu numele problemei compilate (Daca compilarea a avut succes). Ex :

In acest folder se vor copia in mod repetat fisiere in, se vor redenumi, se vor copia binarele concurentilor, in acest folder se vor rula, aici se va rula verif-ul etc..
(Vezi : Cum se produce evaluarea? in "Intrebari frecvente":(#intrebari) )

Evaluatorul va crea (depinde de flagurile cu care este rulat), fisiere xml cu rezultatele totale ale compilarii si evaluarii

In /rezultate/compilare/ se va creea pentru fiecare id, si pentru fiecare compilator folosit un folder, in care se vor pune fisiere de forma : "problema.compilator" , in care va fi exact outputul produs de compilator.

De ex : g++-ul si gcc-ul, la o compilare reusita, scrie 2-3 linii noi. La o compilare gresita e stackul de erori.
Ex : /rezultate/compilare/1/g++/problema.g++

In /rezultate/evaluare/ pentru fiecare id si pentru fiecare compilator se vor creea fisiere de forma :

In /rezultate/log/ se vor crea :

<br>

Instructiuni de folosire

Instructiunile de folosire sunt sub forma de screenshoturi insotite de text explicativ si indicatii.

Tutorial 1 - Instalare si configurare compilatoare

Tutorial 2 - Creare si definire runda

Tutorial 3 - Compilarea si evaluarea unei runde definite anterior

Tutorial 4 - ConsolaGrafica - warninguri si erori
img1 img2

Tutorial 5 - Rulare evaluator in mod consola
img1 img2 img3 img4 img5 img6 img7 img8

<br>

Download runde

<br>

Intrebari frecvente

• 1. Runde
  • 1.1 Ce este o runda?
  • 1.2 Prin ce se defineste o problema intr-o runda?
  • 1.3. Prin ce se defineste un id valid?
  • 1.4 Ce path-uri catre foldere specifice sunt intr-o runda?
• 2. Compilatoare
  • 2.1 Ce contine o configurare de compilatoare?
• 3. Compilare
  • 3.1 Cum se produce compilarea?
• 4. Evaluare
  • 4.1 Cum se produce evaluarea?
  • 4.2 Ce trebuie sa indeplineasca \ implementeze un verificator?
• 5. Runtime
  • 5.1 Ce se intampla in cazul unei exceptii aparute la rularea solutiei concurentului?

1. Runde

1.1 Ce este o runda?
O runda e o colectie de probleme, iduri valide pentru acea runda, si path-uri catre foldere specifice.

1.2 Prin ce se defineste o problema intr-o runda?

• Un nume unic (sa nu mai existe in aceeasi runda o problema cu acelasi nume)

• Un timp de executie (cat e limita de timp pe acea problema)

• O limita de memorie (cat e limita de memorie pe acea problema)
  nu specificati limita prea joasa , de ex, este o limita inferioara de memorie necesara oricarui program compilat astfel incat el sa ruleze (chiar daca contine doar
  

  int main() { }

  
  si nu foloseste nici o variabila). El totusi foloseste memorie pentru a rula. A se da o valoare astfel incat sa se tina cont de asta.

• O masca de teste IN
  Adica ce nume au testele in. de ex :
  "test*.in"  steluta se va inlocui cu numarul testului => (test1.in, test2.in ..)
  sau :
  problema.*I => (problema.1I, problema.2I ..)

• O masca de teste OUT (la fel ca si la in)

• Un interval de teste, intre ce valoari avem teste, ex : teste de la 0 la 20 sau 1 la 10

• campul de autor al problemei este optional (nu are utilitate)

1.3. Prin ce se defineste un id valid?
Un id valid este un id care va fi luat in considerare la compilare \ evaluare
In folderul cu surse se pot copia orice foldere si fisiere. Toate foldere ce nu au nume de iduri valide vor fi sterse automat

1.4 Ce path-uri catre foldere specifice sunt intr-o runda?

2.1 Ce contine o configurare de compilatoare?
Contine o lista de compilatoare care au definite :

• Un Limbaj

• O extenise a fisierelor sursa pentru acel compilator.
  Trebuie specificata cu punct! Ex : ".cpp" , ".pas"

• Un nume unic care identifica compilatorul (sa nu existe 2 compilatoare cu acelasi nume) "g++", "gcc" ..

• O directiva de compilare
  Aceasta trebuie sa fie formata astfel : Path catre compilator (executabil) + flaguri.
  De ex : "C:\Dev-Cpp\bin\g++.exe -o * *.cpp"
  prima parte e path-ul, iar "-o * *.cpp" sunt parametrii.
  Steluta va fi inlocuita cu numele problemei compilate. Daca am compila problema 'arbore' intreaga directiva ar arata asa :
  "C:\Dev-Cpp\bin\g++.exe -o arbore arbore.cpp"
  Adica produce ca output un executabil cu numele dat dupa flagul -o compiland sursa arbore.cpp

3.1 Cum se produce compilarea?

4.1 Cum se produce evaluarea?

4.2 Ce trebuie sa indeplineasca \ implementeze un verificator?

5.1 Ce se intampla in cazul unei exceptii aparute la rularea solutiei concurentului?

<br><br><br>

Sursa verif

Verificatorul este necesar pentru a puncta fisierul OUT produs de concurent. Trebuie pus sub forma de executabil in fisierul cu testele problemei.

Mai jos este o sursa generala de verificator. Sursa are implementate functii de comparare bit la bit, si a numarului din fisier. Pentru probleme cu solutii multiple sau un alt mod de verificare vor trebui implementate si alte functii de verificare a rezultatului.
Shimbati #define-urile INFILE, OUTFILE, si OKFILE cu numele corespunzatoare.

#include <stdio.h>

/* !!! schimba <problema> cu numele problemei */
#define INFILE "problema.in"
#define OUTFILE "problema.out"
#define OKFILE "problema.ok"

FILE *fIN, *fOUT, *fOK, *fV;

bool openFiles();        /* deschide fisierele si verifica existenta lor */
void closeHandles();     /* inchide fisierele */
bool compareBitByBit();  /* compara out si ok, bit la bit */
bool compareNumber();    /* compara numerele din out si ok */

int main()
{
    if(!openFiles()) return 0;
    if (compareBitByBit())
        fprintf(fV, "10\nCorect");
    else
        fprintf(fV, "0\nGresit");
    closeHandles();
    
    return 0;
}

bool openFiles()
{
    fIN = fopen(INFILE, "r");
    fOUT = fopen(OUTFILE, "r");
    fOK = fopen(OKFILE, "r");
    fV = fopen("punctaj.verif", "w");
    if (!fIN)
    {
        fprintf(fV, "0\nFisier IN lipsa.");
        closeHandles();
        return false;
    }
    if (!fOUT)
    {
        fprintf(fV, "0\nFisier OUT lipsa.");
        closeHandles();
        return false;
    }
    if (!fOK)
    {
        fprintf(fV, "0\nFisier OK lipsa.");
        closeHandles();
        return false;
    }
    return true;
}

void closeHandles()
{
    if (fIN) fclose(fIN);
    if (fOUT) fclose(fOUT);
    if (fOK) fclose(fOK);
    if (fV) fclose(fV);
}

bool compareBitByBit()
{
    char b1, b2;
    int ret1, ret2;
    while (1)
    {
        ret1 = fscanf(fOUT, "%c", &b1);
        ret2 = fscanf(fOK, "%c", &b2);
        if (ret1 > 0 && ret2 <= 0) return false;
        if (ret1 <= 0 && ret2 > 0)  return false;
        if (b1 != b2) return false;
        if (ret1 <= 0 && ret2 <= 0) return true;
    }
    return true;
}

bool compareNumber()
{
     int nr1, nr2;
     fscanf(fOUT, "%d", &nr1);
     fscanf(fOK, "%d", &nr2);
     if (nr1 != nr2) return false;
     return true;
}