Eesti Informaatikaolümpiaad
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:
- sisendfaili esimesel real on täisarv K ja järgmisel K real igaühel üks täisarv; väljastada väljundfaili esimesele reale arv K ja nende K arvu summa;
- sisendfaili järgmisel real on täisarv L ja selle järel L tühikutega eraldatud reaalarvu; väljastada väljundfaili teisele reale arv L ja nende L arvu summa täpsusega 3 kohta pärast koma;
- sisendfaili järgmisel real on täisarv M ja selle järel M tühikutega eraldatud numbrit; väljastada väljundfaili kolmandale reale need M numbrit vahetult üksteise kõrvale;
- sisendfaili järgmisel real on täisarv N ja selle järel N rida kujul
<kbd>X sõna1 sõna2 sõna3 ...</kbd>,
kus X on täisarv ja iga sõna ees on täpselt üks tühik; väljastada väljundfaili järgmisele reale komadega eraldatult need sõnad, mille pikkus on X (esimese sõna ees ja viimase järel koma olla ei tohi).
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 06:22 PM