1. Krepšinis (2012 ITVBE)

U1.txt
/*
8
9 5 7 -5 13 -4 11
7 5 -3 12 -5 17 -3
25 7 12 -3 5 -5 7 -5 3
14 5 12 -3 10 -7 8
5 1 -40
33 5 15 -5 9 -3 8
11 5 -12 8 -5 12 -3
13 5 3 -4 15 -5 3
*/

#include <iostream>
#include <iomanip>
#include <fstream>
using namespace std;

const char duomF[] = "U1.txt";
const char rezF[] = "U1Rez.txt";
const int CMax = 100;

// ----------------------------------------------------------------------------------------------

struct krepsininkai {
    int numeris;            // Krepsininko numeris
    bool startinis;
    int max;                // Daugiausia laiko praleide aiksteleje krepsininkai
    int min;                // Daugiausia laiko praleide ant suolelio krepsininkai
    };

// ----------------------------------------------------------------------------------------------

void reset(krepsininkai A[])
{
    for (int i = 0; i < CMax; i++)
    {
        A[i].numeris = 0;
        A[i].startinis = false;
        A[i].max = 0;
        A[i].min = 0;
    }
}

void skaitymas(krepsininkai A[], int &n, int &k)
{
    int startTikr;
    int laikas;
    int kiek;
    ifstream df(duomF);

    df >> n;                    // Krepsininku skaicius
    for (int i = 0; i < n; i++)
    {
        df >> k;                // Krepsininko numeris STARTINIAI:  9 13 14 25 33
        A[i].numeris = k;
        df >> kiek;             // Kiek laiku reiksmiu yra
        df >> startTikr;        // Kintamasis skirtas tikrinti ar zaidejas yra startinio penketo sudetyje
        if (startTikr >= 0)
        {
            A[i].startinis = true;
        }

        if (A[i].startinis == true)
        {
            for (int j = 1; j < kiek; j++)
            {
                A[i].max += startTikr;
                df >> laikas;
                if (laikas >= 0)
                {
                    A[i].max += laikas;
                }
                else
                {
                    A[i].min += laikas;
                }
            }
        }
        else
        {
            for (int j = 1; j < kiek; j++)
            {
                A[i].min += startTikr;
                df >> laikas;
                if (laikas >= 0)
                {
                    A[i].max += laikas;
                }
                else
                {
                    A[i].min += laikas;
                }
            }
        }
    }
    df.close();
}

void sprendimas(krepsininkai A[], int n)
{
    int startPenketas[5];           // Masyvas skirtas laikyti stariniam penketui
    int startsk = 0;                // Atskiras skaitliukas paminetam masyvui
    int temp;                       // Laikinas kintamasis skirtas rykiavimui
    int maxsk, max = 0;
    int minsk, min = 100;

    for (int i = 0; i < n; i++)
    {
        if (A[i].startinis == true)
        {
             startPenketas[startsk] = A[i].numeris;
             startsk++;
        }

        if (A[i].max > max) // Didziausio ieskojimas
        {
            maxsk = i;
            max = A[i].max;
        }

        if (A[i].min < min) // Maziausio ieskojimas
        {
            minsk = i;
            min = A[i].min;
        }
    }

    ofstream rf(rezF);
    for (int i = 0; i < 5; i++)
    {
        for (int j = i; j < 5; j++)
        if (startPenketas[i] > startPenketas[j])
        {
            temp = startPenketas[i];
            startPenketas[i] = startPenketas[j];
            startPenketas[j] = temp;

        }
        rf << startPenketas[i] << " ";
    }
    rf << " " << endl;
    rf << A[maxsk].numeris << " " << A[maxsk].max << endl; // Daugiausia
    rf << A[minsk].numeris << " " << A[minsk].min - A[minsk].min - A[minsk].min << endl; // Maziausia


    rf.close();
}

int main()
{
    krepsininkai A[CMax];
    int k, n, startsk;

    reset(A);
    skaitymas(A, n, k);
    sprendimas(A, n);

    return 0;
}