Tekstifailide kasutamise näited

Allpool on mõned näited tekstifailide kasutamisest tüüpilistes situatsioonides, mis esinevad programmeerimisolümpiaadidel.


Failist lugemine

Ülesanne

On antud koordinaattelgedega paralleelsete servadega ristküliku vasaku alumise ja parema ülemise nurga täisarvulised koordinaadid. Kirjutada programm, mis arvutab selle ristküliku pindala. Nurkade koordinaadid on tekstifailis ristkyl.sis. Faili esimesel real on vasaku alumise nurga X- ja Y-koordinaat, teisel real parema ülemise nurga X- ja Y-koordinaat. Samal real olevad arvud on üksteisest eraldatud tühikuga. Tulemus väljastada ekraanile.

Lahendus Pascal'is

var
   sisf : text;                                            { failimuutuja }
   x1, y1, x2, y2 : integer;                       { tippude koordinaadid }
   pind : integer;                                              { pindala }
begin
   { loeme andmed }
   assign(sisf, 'ristkyl.sis');              { seome failimuutuja failiga }
   reset(sisf);                                  { avame faili lugemiseks }
   readln(sisf, x1, y1);                { loeme esimeselt realt kaks arvu }
   readln(sisf, x2, y2);                  { loeme teiselt realt kaks arvu }
   close(sisf);                                           { sulgeme faili }

   { arvutame pindala }
   pind := (x2 - x1) * (y2 - y1);

   { väljastame tulemuse }
   writeln('Pindala on ', pind);
end.

Lahendus C's

#include <stdio.h>

int main(void)
{
   FILE *sisf;                                           /* failimuutuja */
   int x1, y1, x2, y2;                           /* tippude koordinaadid */
   int pind;                                                  /* pindala */

   /* loeme andmed */
   sisf = fopen("ristkyl.sis", "rt");          /* avame faili lugemiseks */
   fscanf(sisf, "%d %d", &x1, &y1);                   /* loeme kaks arvu */
   fscanf(sisf, "%d %d", &x2, &y2);              /* loeme veel kaks arvu */
   fclose(sisf);                                        /* sulgeme faili */

   /* arvutame pindala */
   pind = (x2 - x1) * (y2 - y1);

   /* väljastame tulemuse */
   printf("Pindala on %dn", pind);
   return 0;
}

Lahendus C++'s

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

int main(void)
{
   ifstream sisf;                                           // failimuutuja
   int x1, y1, x2, y2;                              // tippude koordinaadid
   int pind;                                                     // pindala

   // loeme andmed
   sisf.open("ristkyl.sis");                      // avame faili lugemiseks
   sisf >> x1 >> y1;                                     // loeme kaks arvu
   sisf >> x2 >> y2;                                // loeme veel kaks arvu
   sisf.close();                                           // sulgeme faili

   // arvutame pindala
   pind = (x2 - x1) * (y2 - y1);

   // väljastame tulemuse
   cout << "Pindala on " << pind << endl;
   return 0;
}

Lahendus Java's

import java.io.*;
import java.util.*;

public class ristkyl
{
   public static void main(String args[])
      throws Exception
   {
      BufferedReader sisf;                                  // failimuutuja
      StringTokenizer st;                                  // rea tükeldaja
      int x1, y1, x2, y2;                           // tippude koordinaadid
      int pind;                                                  // pindala

      // loeme andmed
      sisf = new BufferedReader(
            new FileReader("ristkyl.sis"));       // avame faili lugemiseks
      st = new StringTokenizer(sisf.readLine());       // loeme esimese rea
      x1 = Integer.parseInt(st.nextToken());      // eraldame X-koordinaadi
      y1 = Integer.parseInt(st.nextToken());      // eraldame Y-koordinaadi
      st = new StringTokenizer(sisf.readLine());         // loeme teise rea
      x2 = Integer.parseInt(st.nextToken());      // eraldame X-koordinaadi
      y2 = Integer.parseInt(st.nextToken());      // eraldame Y-koordinaadi

      // arvutame pindala
      pind = (x2 - x1) * (y2 - y1);

      // väljastame tulemuse
      System.out.println("Pindala on " + pind);
   }
}

Lahendus C#'s

using System;
using System.IO;                                                // readerite, writerite ja failide klassid

namespace ristkyl
{
    class Ristkyl
    {
        static void Main()
        {
            string[] pt1;
            string[] pt2;

            string[] lines = File.ReadAllLines("ristkyl.sis");  // lihtne meetod faili kogu sisu lugemiseks

            int x1 = int.Parse(lines[0].Split()[0]);            // eraldame koordinaadid
            int y1 = int.Parse(lines[0].Split()[1]);
            int x2 = int.Parse(lines[1].Split()[0]);
            int y2 = int.Parse(lines[1].Split()[1]);

            int s = Math.Abs((x1 - x2) * (y1 - y2));            // arvutame pindala

            Console.WriteLine("Pindala on " + s);               // väljastame konsoolile
        }
    }
}

Lahendus Python'is

# loeme andmed
f = open("ristkyl.sis", "r")                       # avame faili lugemiseks
s = f.readline()                                        # loeme esimese rea
(x1, y1) = map(int, s.split())                 # eraldame sellest kaks arvu
s = f.readline()                                          # loeme teise rea
(x2, y2) = map(int, s.split())                 # eraldame sellest kaks arvu
f.close()                                                   # sulgeme faili

# arvutame pindala
pind = (x2 - x1) * (y2 - y1)

# väljastame tulemuse
print "Pindala on", pind

Lahendus BASIC'us

DIM x1 AS INTEGER, y1 AS INTEGER                     ' tippude koordinaadid
DIM x2 AS INTEGER, y2 AS INTEGER                     ' tippude koordinaadid
DIM pind AS INTEGER                                               ' pindala

' loeme andmed
OPEN "ristkyl.sis" FOR INPUT AS #1                 ' avame faili lugemiseks
INPUT #1, x1, y1                          ' loeme esimeselt realt kaks arvu
INPUT #1, x2, y2                            ' loeme teiselt realt kaks arvu
CLOSE #1                                                    ' sulgeme faili

' arvutame pindala
pind = (x2 - x1) * (y2 - y1)

' väljastame tulemuse
PRINT "Pindala on"; pind
SYSTEM

Faili kirjutamine

Ülesanne

On antud kolmnurga tippude reaalaarvulised koordinaadid. Kirjutada programm, mis arvutab selle kolmnurga pindala. Tekstifailis kolmnurk.sis on kolmnurga tippude X- ja Y-koordinaadid, iga tipu koordinaadid omaette real. Tulemus väljastada tekstifaili kolmnurk.val.

Lahendus Pascal'is

var
   sisf, valf : text;                                     { failimuutujad }
   x1, y1, x2, y2, x3, y3 : real;                  { tippude koordinaadid }
   a, b, c : real;                                     { külgede pikkused }
   p, pind : real;
begin
   { loeme andmed }
   assign(sisf, 'kolmnurk.sis');             { seome failimuutuja failiga }
   reset(sisf);                                  { avame faili lugemiseks }
   readln(sisf, x1, y1);                { loeme esimeselt realt kaks arvu }
   readln(sisf, x2, y2);                  { loeme teiselt realt kaks arvu }
   readln(sisf, x3, y3);               { loeme kolmandalt realt kaks arvu }
   close(sisf);                                           { sulgeme faili }

   { arvutame pindala Heroni valemi järgi }
   a := sqrt(sqr(x1 - x2) + sqr(y1 - y2));
   b := sqrt(sqr(x2 - x3) + sqr(y2 - y3));
   c := sqrt(sqr(x3 - x1) + sqr(y3 - y1));
   p := (a + b + c) / 2;
   pind := sqrt(p * (p - a) * (p - b) * (p - c));

   { väljastame tulemuse }
   assign(valf, 'kolmnurk.val');             { seome failimuutuja failiga }
   rewrite(valf);                             { avame faili kirjutamiseks }
   writeln(valf, pind);                                      { väljastame }
   close(valf);                                           { sulgeme faili }
end.

Lahendus C's

#include <stdio.h>
#include <math.h>

int main(void)
{
   FILE *sisf, *valf;                                   /* failimuutujad */
   double x1, y1, x2, y2, x3, y3;                /* tippude koordinaadid */
   double a, b, c;                                   /* külgede pikkused */
   double p, pind;

   /* loeme andmed */
   sisf = fopen("kolmnurk.sis", "rt");         /* avame faili lugemiseks */
   fscanf(sisf, "%lf %lf", &x1, &y1);                 /* loeme kaks arvu */
   fscanf(sisf, "%lf %lf", &x2, &y2);            /* loeme veel kaks arvu */
   fscanf(sisf, "%lf %lf", &x3, &y3);            /* loeme veel kaks arvu */
   fclose(sisf);                                        /* sulgeme faili */

   /* arvutame pindala Heroni valemi järgi */
   a = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
   b = sqrt((x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3));
   c = sqrt((x3 - x1) * (x3 - x1) + (y3 - y1) * (y3 - y1));
   p = (a + b + c) / 2;
   pind = sqrt(p * (p - a) * (p - b) * (p - c));

   /* väljastame tulemuse */
   valf = fopen("kolmnurk.val", "wt");      /* avame faili kirjutamiseks */
   fprintf(valf, "%lfn", pind);                           /* väljastame */
   fclose(valf);                                        /* sulgeme faili */
   return 0;
}

Lahendus C++'s

#include <fstream>
#include <cmath>
using namespace std;

int main(void)
{
   ifstream sisf;                            // failimuutuja sisendiks
   ofstream valf;                           // failimuutuja väljundiks
   double x1, y1, x2, y2, x3, y3;              // tippude koordinaadid
   double a, b, c;                                 // külgede pikkused
   double p, pind;

   // loeme andmed
   sisf.open("kolmnurk.sis");                // avame faili lugemiseks
   sisf >> x1 >> y1;                                // loeme kaks arvu
   sisf >> x2 >> y2;                           // loeme veel kaks arvu
   sisf >> x3 >> y3;                           // loeme veel kaks arvu
   sisf.close();                                      // sulgeme faili

   // arvutame pindala Heroni valemi järgi
   a = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
   b = sqrt((x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3));
   c = sqrt((x3 - x1) * (x3 - x1) + (y3 - y1) * (y3 - y1));
   p = (a + b + c) / 2;
   pind = sqrt(p * (p - a) * (p - b) * (p - c));

   // väljastame tulemuse
   valf.open("kolmnurk.val");             // avame faili kirjutamiseks
   valf << pind << endl;                                 // väljastame
   valf.close();                                      // sulgeme faili
   return 0;
}

Lahendus Java's

import java.io.*;
import java.util.*;

public class kolmnurk
{
   public static void main(String args[])
      throws Exception
   {
      BufferedReader sisf;                        // failimuutuja sisendiks
      StringTokenizer st;                                  // rea tükeldaja
      PrintWriter valf;                          // failimuutuja väljundiks
      double x1, y1, x2, y2, x3, y3;                // tippude koordinaadid
      double a, b, c;                                   // külgede pikkused
      double p, pind;

      // loeme andmed
      sisf = new BufferedReader(
            new FileReader("kolmnurk.sis"));      // avame faili lugemiseks
      st = new StringTokenizer(sisf.readLine());       // loeme esimese rea
      x1 = Double.parseDouble(st.nextToken());    // eraldame X-koordinaadi
      y1 = Double.parseDouble(st.nextToken());    // eraldame Y-koordinaadi
      st = new StringTokenizer(sisf.readLine());         // loeme teise rea
      x2 = Double.parseDouble(st.nextToken());    // eraldame X-koordinaadi
      y2 = Double.parseDouble(st.nextToken());    // eraldame Y-koordinaadi
      st = new StringTokenizer(sisf.readLine());      // loeme kolmanda rea
      x3 = Double.parseDouble(st.nextToken());    // eraldame X-koordinaadi
      y3 = Double.parseDouble(st.nextToken());    // eraldame Y-koordinaadi

      // arvutame pindala
      a = Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
      b = Math.sqrt((x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3));
      c = Math.sqrt((x3 - x1) * (x3 - x1) + (y3 - y1) * (y3 - y1));
      p = (a + b + c) / 2;
      pind = Math.sqrt(p * (p - a) * (p - b) * (p - c));

      // väljastame tulemuse
      valf = new PrintWriter(
            new FileWriter("kolmnurk.val"));   // avame faili kirjutamiseks
      valf.println(Double.toString(pind));                    // väljastame
      valf.flush();                       // tühjendame väljundfaili puhvri
   }
}

Lahendus C#'s

using System;
using System.Globalization;  // CultureInfo jaoks
using System.IO;

namespace kolmnurk
{
    class Kolmnurk
    {
        static void Main()
        {
            string[] pt1 = Console.ReadLine().Split();                              // Loeme konsoolilt kolm rida ja tükeldame
            string[] pt2 = Console.ReadLine().Split();                              // Kasutaja peab need õigesti sisestama :)
            string[] pt3 = Console.ReadLine().Split();

            // Kuna olümpiaadiülesannetes on kümnendkoha eraldajaks alati punkt,
            // anname parsimisel kaasa CultureInfo.InvariantCulture, et tagada 
            // punkti kasutamine juhuks, kui meil muidu on mingi muu keelne keskkond.
            // Alternatiivina võib kasutada 
            // System.Threading.Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture
            // siis pole igale operatsioonile vaja seda eraldi parameetrina anda.

            double x1 = double.Parse(pt1[0], CultureInfo.InvariantCulture);         // teisendame stringid reaalarvudeks
            double y1 = double.Parse(pt1[1], CultureInfo.InvariantCulture);         
            double x2 = double.Parse(pt2[0], CultureInfo.InvariantCulture);         
            double y2 = double.Parse(pt2[1], CultureInfo.InvariantCulture);         
            double x3 = double.Parse(pt3[0], CultureInfo.InvariantCulture);         
            double y3 = double.Parse(pt3[1], CultureInfo.InvariantCulture);

            double a = Math.Sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));    // leiame pindala Heroni valemiga
            double b = Math.Sqrt((x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3));
            double c = Math.Sqrt((x3 - x1) * (x3 - x1) + (y3 - y1) * (y3 - y1));

            double p = (a + b + c) / 2;
            double s = Math.Sqrt(p * (p - a) * (p - b) * (p - c));

            File.WriteAllText("kolmnurk.val", s.ToString(CultureInfo.InvariantCulture));  // lihtne meetod ühe stringi kirjutamiseks faili
        }
    }
}

Lahendus Python'is

import math

# loeme andmed
f = open("kolmnurk.sis", "r")                      # avame faili lugemiseks
(x1, y1) = map(float, f.readline().split())     # esimeselt realt kaks arvu
(x2, y2) = map(float, f.readline().split())       # teiselt realt kaks arvu
(x3, y3) = map(float, f.readline().split())    # kolmandalt realt kaks arvu
f.close()                                                   # sulgeme faili

# arvutame pindala Heroni valemi järgi
a = math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
b = math.sqrt((x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3))
c = math.sqrt((x3 - x1) * (x3 - x1) + (y3 - y1) * (y3 - y1))
p = (a + b + c) / 2
pind = math.sqrt(p * (p - a) * (p - b) * (p - c))

# väljastame tulemuse
f = open("kolmnurk.val", "w")                   # avame faili kirjutamiseks
f.write("%fn" % pind)                                         # väljastame
f.close()                                                   # sulgeme faili

Lahendus BASIC'us

DIM x1 AS DOUBLE, y1 AS DOUBLE                       ' tippude koordinaadid
DIM x2 AS DOUBLE, y2 AS DOUBLE                       ' tippude koordinaadid
DIM x3 AS DOUBLE, y3 AS DOUBLE                       ' tippude koordinaadid
DIM a AS DOUBLE, b AS DOUBLE, c AS DOUBLE                ' külgede pikkused
DIM p AS DOUBLE, pind AS DOUBLE

' loeme andmed
OPEN "kolmnurk.sis" FOR INPUT AS #1                ' avame faili lugemiseks
INPUT #1, x1, y1                          ' loeme esimeselt realt kaks arvu
INPUT #1, x2, y2                            ' loeme teiselt realt kaks arvu
INPUT #1, x3, y3                         ' loeme kolmandalt realt kaks arvu
CLOSE #1                                                    ' sulgeme faili

' arvutame pindala Heroni valemi järgi
a = SQR((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
b = SQR((x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3))
c = SQR((x3 - x1) * (x3 - x1) + (y3 - y1) * (y3 - y1))
p = (a + b + c) / 2
pind = SQR(p * (p - a) * (p - b) * (p - c))

' väljastame tulemuse
OPEN "kolmnurk.val" FOR OUTPUT AS #2            ' avame faili kirjutamiseks
PRINT #2, pind                                                 ' väljastame
CLOSE #2                                                    ' sulgeme faili
SYSTEM

Mitme faili samaaegne kasutamine

Ülesanne

Kirjutada programm, mis sisestab klaviatuurilt kahe tekstifaili nimed ja kopeerib esimesest failist teise kõik read, mille pikkus on paarisarv. Võib eeldada, et ei failinimede ega ühegi rea pikkus ei ületa 80 sümbolit.

Lahendus Pascal'is

var
   sisnimi, valnimi : string;
   sisf, valf : text;
   s : string;
begin
   { loeme failinimed }
   write('Sisendfaili nimi: '); readln(sisnimi);
   write('Väljundfaili nimi: '); readln(valnimi);

   { avame failid }
   assign(sisf, sisnimi); reset(sisf);
   assign(valf, valnimi); rewrite(valf);

   { kopeerime }
   while not eof(sisf) do begin
      readln(sisf, s);
      if length(s) mod 2 = 0 then begin
         writeln(valf, s);
      end;
   end;

   { sulgeme failid }
   close(sisf);
   close(valf);
end.

Lahendus C's

#include <stdio.h>
#include <string.h>

int main(void)
{
   char sisnimi[80 + 1], valnimi[80 + 1];
   FILE *sisf, *valf;
   char s[80 + 1 + 1];

   /* loeme failinimed */
   printf("Sisendfaili nimi: "); scanf("%80s", sisnimi);
   printf("Väljundfaili nimi: "); scanf("%80s", valnimi);

   /* avame failid */
   sisf = fopen(sisnimi, "rt");
   valf = fopen(valnimi, "wt");

   /* kopeerime */
   /* NB! ei tööta: while (fscanf(sisf, "%80s", s)) */
   while (fgets(s, sizeof(s), sisf) != NULL) {
      if (strlen(s) % 2 == 1) {               /* reavahetus on ka sümbol */
         fputs(s, valf);
      }
   }

   /* sulgeme failid */
   fclose(sisf);
   fclose(valf);
   return 0;
}

Lahendus C++'s

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

int main(void)
{
   string sisnimi, valnimi;
   ifstream sisf;
   ofstream valf;
   string s;

   // loeme failinimed
   cout << "Sisendfaili nimi: "; cin >> sisnimi;
   cout << "Väljundfaili nimi: "; cin >> valnimi;

   // avame failid
   sisf.open(sisnimi.c_str());
   valf.open(valnimi.c_str());

   // kopeerime
   // NB! ei tööta: while (sisf >> s)
   while (getline(sisf, s)) {
      if (s.length() % 2 == 0) {
         valf << s << endl;
      }
   }

   // sulgeme failid
   sisf.close();
   valf.close();
   return 0;
}

Lahendus Java's

import java.io.*;

public class kopeer
{
   public static void main(String args[])
      throws Exception
   {
      String sisnimi, valnimi;
      BufferedReader sisf; PrintWriter valf;
      String s;

      // loeme failinimed
      BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
      System.out.print("Sisendfaili nimi: "); sisnimi = in.readLine();
      System.out.print("Väljundfaili nimi: "); valnimi = in.readLine();

      // avame failid
      sisf = new BufferedReader(new FileReader(sisnimi));
      valf = new PrintWriter(new FileWriter(valnimi));

      // kopeerime
      while ((s = sisf.readLine()) != null) {
         if (s.length() % 2 == 0) {
            valf.println(s);
         }
      }

      // tühjendame väljundfaili puhvri
      valf.flush();
   }
}

Lahendus C#'s

using System;
using System.IO;

namespace kopeer
{
    class Kopeer
    {
        static void Main()
        {
            // loeme failinimed
            Console.Write("Sisendfaili nimi: ");
            string input = Console.ReadLine();
            Console.Write("Väljundfaili nimi: ");
            string output = Console.ReadLine();

            using (StreamReader reader = new StreamReader(input))
            {
                using (StreamWriter writer = new StreamWriter(output))
                {
                    string s;

                    // kopeerime
                    while ((s = reader.ReadLine()) != null)
                    {
                        if (s.Length % 2 == 0)
                        {
                            writer.WriteLine(s);
                        }
                    }
                } // "using" kasutamine tagab readerite ja writerite puhul, 
            }     // et failid suletakse vastava bloki lõpus automaatselt
        }
    }
}

Lahendus Python'is

# loeme failinimed
sisnimi = raw_input("Sisendfaili nimi: ")
valnimi = raw_input("Väljundfaili nimi: ")

# avame failid
sisf = open(sisnimi, "r")
valf = open(valnimi, "w")

# kopeerime
for s in sisf:
   if len(s) % 2 == 1:                            # reavahetus on ka sümbol
      valf.write(s)

# sulgeme failid
sisf.close()
valf.close()

Lahendus BASIC'us

DIM sisnimi AS STRING, valnimi AS STRING
DIM s AS STRING

' loeme failinimed
INPUT "Sisendfaili nimi"; sisnimi
INPUT "Väljundfaili nimi"; valnimi

' avame failid
OPEN sisnimi FOR INPUT AS #1
OPEN valnimi FOR OUTPUT AS #2

' kopeerime
WHILE NOT EOF(1)
   LINE INPUT #1, s
   IF LEN(s) MOD 2 = 0 THEN
      PRINT #2, s
   END IF
WEND

' sulgeme failid
CLOSE #1
CLOSE #2
SYSTEM

Veidi keerulisem näide

Ülesanne

Kirjutada programm, mis loeb andmed tekstifailist andmed.sis ja väljastab tulemuse tekstifaili andmed.val vastavalt järgnevale kirjeldusele:

Võib eeldada, et ühegi sisendrea pikkus ei ületa 200 sümbolit.

Lahendus Pascal'is

var
   sisf, valf : text;
   n, i : integer;
   x1, s1 : integer;
   x2, s2 : real;
   x : integer;
   s : string;
   i1, i2 : integer;
   e : boolean;
begin
   { avame failid }
   assign(sisf, 'andmed.sis'); reset(sisf);
   assign(valf, 'andmed.val'); rewrite(valf);

   { esimene plokk: täisarvude summa }
   readln(sisf, n);
   s1 := 0;
   for i := 1 to n do begin
      readln(sisf, x1);
      s1 := s1 + x1;
   end;
   writeln(valf, n, ' ', s1);

   { teine plokk: reaalarvude summa }
   read(sisf, n);
   s2 := 0;
   for i := 1 to n do begin
      read(sisf, x2);
      s2 := s2 + x2;
   end;
   readln(sisf);
   writeln(valf, n, ' ', s2 :0:3);

   { kolmas plokk: numbrite kuhjamine }
   read(sisf, n);
   for i := 1 to n do begin
      read(sisf, x);
      write(valf, x);
   end;
   readln(sisf);
   writeln(valf);

   { neljas plokk: antud pikkusega sõnad }
   readln(sisf, n);
   for i := 1 to n do begin
      readln(sisf, x, s);
      e := true; i1 := 1; s := s + ' ';
      for i2 := 2 to length(s) do begin
         if s[i2] = ' ' then begin
            if i2 - i1 = x + 1 then begin
               if not e then begin
                  write(valf, ',');
               end;
               write(valf, copy(s, i1 + 1, i2 - i1 - 1));
               e := false;
            end;
            i1 := i2;
         end;
      end;
      writeln(valf);
   end;

   { sulgeme failid }
   close(sisf);
   close(valf);
end.

Lahendus C's

#include <stdio.h>
#include <string.h>

int main(void)
{
   FILE *sisf, *valf;
   int n, i;
   int x1, s1;
   double x2, s2;
   int x;
   char s[200 + 1 + 1];
   int i1, i2;
   int e;

   /* avame failid */
   sisf = fopen("andmed.sis", "rt");
   valf = fopen("andmed.val", "wt");

   /* esimene plokk: täisarvude summa */
   fscanf(sisf, "%d", &n);
   s1 = 0;
   for (i = 0; i < n; ++i) {
      fscanf(sisf, "%d", &x1);
      s1 += x1;
   }
   fprintf(valf, "%d %dn", n, s1);

   /* teine plokk: reaalarvude summa */
   fscanf(sisf, "%d", &n);
   s2 = 0;
   for (i = 0; i < n; ++i) {
      fscanf(sisf, "%lf", &x2);
      s2 += x2;
   }
   fprintf(valf, "%d %0.3lfn", n, s2);

   /* kolmas plokk: numbrite kuhjamine */
   fscanf(sisf, "%d", &n);
   for (i = 0; i < n; ++i) {
      fscanf(sisf, "%d", &x);
      fprintf(valf, "%d", x);
   }
   fprintf(valf, "n");

   /* neljas plokk: antud pikkusega sõnad */
   fscanf(sisf, "%d", &n);
   for (i = 0; i < n; ++i) {
      fscanf(sisf, "%d", &x); fgets(s, sizeof(s), sisf);
      e = 1; i1 = 0; s[strlen(s) - 1] = ' ';
      for (i2 = 1; s[i2] != 0; ++i2) {
         if (s[i2] == ' ') {
            if (i2 - i1 == x + 1) {
               if (!e) {
                  fprintf(valf, ",");
               }
               s[i2] = 0;
               fprintf(valf, "%s", s + i1 + 1);
               e = 0;
            }
            i1 = i2;
         }
      }
      fprintf(valf, "n");
   }

   /* sulgeme failid */
   fclose(sisf);
   fclose(valf);
   return 0;
}

Lahendus C++'s

#include <fstream>
#include <sstream>
#include <iomanip>
#include <string>
using namespace std;

int main(void)
{
   ifstream sisf;
   ofstream valf;
   int n, i;
   int x1, s1;
   double x2, s2;
   int x;
   string s;
   stringstream ss;
   int i1, i2;
   int e;

   // avame failid
   sisf.open("andmed.sis");
   valf.open("andmed.val");

   // esimene plokk: täisarvude summa
   sisf >> n;
   s1 = 0;
   for (i = 0; i < n; ++i) {
      sisf >> x1;
      s1 += x1;
   }
   valf << n << " " << s1 << endl;

   // teine plokk: reaalarvude summa
   sisf >> n;
   s2 = 0;
   for (i = 0; i < n; ++i) {
      sisf >> x2;
      s2 += x2;
   }
   valf << n << " " << fixed << setprecision(3) << s2 << endl;

   // kolmas plokk: numbrite kuhjamine
   sisf >> n;
   for (i = 0; i < n; ++i) {
      sisf >> x;
      valf << x;
   }
   valf << endl;

   // neljas plokk: antud pikkusega sõnad
   sisf >> n;
   for (i = 0; i < n; ++i) {
      sisf >> x; getline(sisf, s);
      ss.clear(); ss << s; e = 1;
      while (ss >> s) {
         if (s.length() == x) {
            if (!e) {
               valf << ",";
            }
            valf << s;
            e = 0;
         }
      }
      valf << endl;
   }

   // sulgeme failid
   sisf.close();
   valf.close();
   return 0;
}

Lahendus Java's

import java.io.*;
import java.util.*;

public class andmed
{
   public static void main(String args[])
      throws Exception
   {
      BufferedReader sisf; StringTokenizer st;
      PrintWriter valf; 
      int n, i;

      // avame failid
      sisf = new BufferedReader(new FileReader("andmed.sis"));
      valf = new PrintWriter(new FileWriter("andmed.val"));

      // esimene plokk: täisarvude summa
      n = Integer.parseInt(sisf.readLine());
      int s1 = 0;
      for (i = 0; i < n; ++i) {
         s1 += Integer.parseInt(sisf.readLine());
      }
      valf.println(Integer.toString(n) + " " + Integer.toString(s1));

      // teine plokk: reaalarvude summa
      st = new StringTokenizer(sisf.readLine());
      n = Integer.parseInt(st.nextToken());
      double s2 = 0;
      for (i = 0; i < n; ++i) {
         s2 += Double.parseDouble(st.nextToken());
      }
      valf.println(String.format("%d %.3f", n, s2));

      // kolmas plokk: numbrite kuhjamine
      st = new StringTokenizer(sisf.readLine());
      n = Integer.parseInt(st.nextToken());
      for (i = 0; i < n; ++i) {
         valf.print(st.nextToken());
      }
      valf.println();

      // neljas plokk: antud pikkusega sõnad
      n = Integer.parseInt(sisf.readLine());
      for (i = 0; i < n; ++i) {
         st = new StringTokenizer(sisf.readLine());
         int x = Integer.parseInt(st.nextToken());
         boolean e = true;
         while (st.hasMoreTokens()) {
            String s = st.nextToken();
            if (s.length() == x) {
               if (!e) {
                  valf.print(",");
               }
               valf.print(s);
               e = false;
            }
         }
         valf.println();
      }

      // tühjendame väljundfaili puhvri
      valf.flush();
   }
}

Lahendus C#'s

using System;
using System.Globalization;
using System.IO;
using System.Linq;

namespace andmed
{
    class Andmed
    {
        static void Main()
        {
            // avame failid
            StreamReader reader = new StreamReader("andmed.sis");
            StreamWriter writer = new StreamWriter("andmed.val");

            // esimene plokk: täisarvude summa
            int n = int.Parse(reader.ReadLine());
            int sum1 = 0;
            for (int i = 0; i < n; i++)
            {
                sum1 += int.Parse(reader.ReadLine());
            }
            writer.WriteLine(n + " " + sum1);

            // teine plokk: reaalarvude summa
            string line = reader.ReadLine();

            // Linq on Lahe
            double sum = line.Split().Skip(1).Select(s => double.Parse(s, CultureInfo.InvariantCulture)).Sum(); 
            writer.WriteLine("{0:F3}", sum);   // F3 formaaditäpsustaja ütleb, et tuleb kirjutada 3 kohta pärast koma

            // kolmas plokk: numbrite kuhjamine
            line = reader.ReadLine();
            string res = string.Join("", line.Split().Skip(1).ToArray());
            writer.WriteLine(res);

            // neljas plokk: antud pikkusega sõnad
            n = int.Parse(reader.ReadLine());
            for (int i = 0; i < n; ++i)
            {
                string[] parts = reader.ReadLine().Split();
                int x = int.Parse(parts[0]);

                res = String.Join(",", parts.Skip(1).Where(s => s.Length == x).ToArray());
                writer.WriteLine(res);
            }

            // suleme sisendfaili ja tühjendame väljundfaili puhvri
            reader.Close();
            writer.Close();
        }
    }
}

Lahendus Python'is

# avame failid
sisf = open("andmed.sis", "r")
valf = open("andmed.val", "w")

# esimene plokk: täisarvude summa
n = int(sisf.readline())
s1 = 0
for i in range(n):
   s1 += int(sisf.readline())
valf.write("%d %dn" % (n, s1))

# teine plokk: reaalarvude summa
s = sisf.readline().split()
n = int(s[0])
s2 = 0
for i in range(n):
   s2 += float(s[i + 1])
valf.write("%d %.3fn" % (n, s2))

# kolmas plokk: numbrite kuhjamine
s = sisf.readline().split()
n = int(s[0])
for i in range(n):
   valf.write(s[i + 1])
valf.write("n")

# neljas plokk: antud pikkusega sõnad
n = int(sisf.readline())
for i in range(n):
   s = sisf.readline().split()
   n = int(s[0])
   e = 1
   for ss in s[1:]:
      if len(ss) == n:
         if e == 0:
            valf.write(",")
         valf.write(ss)
         e = 0
   valf.write("n")

# sulgeme failid
sisf.close()
valf.close()

Lahendus BASIC'us

DIM n AS INTEGER, i AS INTEGER
DIM x1 AS INTEGER, s1 AS INTEGER
DIM x2 AS DOUBLE, s2 AS DOUBLE
DIM x AS INTEGER
DIM s AS STRING
DIM i1 AS INTEGER, i2 AS INTEGER
DIM e AS INTEGER

' avame failid
OPEN "andmed.sis" FOR INPUT AS #1
OPEN "andmed.val" FOR OUTPUT AS #2

' esimene plokk: täisarvude summa
INPUT #1, n
s1 = 0
FOR i = 1 TO n
   INPUT #1, x1
   s1 = s1 + x1
NEXT i
PRINT #2, n; s1
' kui on hädasti vaja saada väljund ilma liigsete tühikuteta, võib kasutada
' PRINT #2, LTRIM$(STR$(n)); STR$(s1)

' teine plokk: reaalarvude summa
INPUT #1, n
s2 = 0
FOR i = 1 TO n
   INPUT #1, x2
   s2 = s2 + x2
NEXT i
PRINT #2, n;
PRINT #2, USING "#######.###"; s2

' kolmas plokk: numbrite kuhjamine
INPUT #1, n
FOR i = 1 TO n
   INPUT #1, x
   PRINT #2, USING "#"; x;
NEXT i
PRINT #2,

' neljas plokk: antud pikkusega sõnad
INPUT #1, n
FOR i = 1 TO n
   INPUT #1, x, s
   e = 1: i1 = 0: s = s + " "
   FOR i2 = 1 TO LEN(s)
      IF MID$(s, i2, 1) = " " THEN
         IF i2 - i1 = x + 1 THEN
            IF e = 0 THEN
               PRINT #2, ",";
            END IF
            PRINT #2, MID$(s, i1 + 1, i2 - i1 - 1);
            e = 0
         END IF
         i1 = i2
      END IF
   NEXT i2
   PRINT #2,
NEXT i

' sulgeme failid
CLOSE #1
CLOSE #2
SYSTEM
Lehekülg viimati muudetud October 27, 2014, at 08:22 PM