1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#define ZACETNA_VELIKOST 128
int slint_array_print (signed long int * b, size_t a, FILE * f) {
fprintf(f, "{ ");
for (size_t j = 0; j < a; j++) // ob !zadnjem natisnemo še ", ".
fprintf(f, "%ld%s", b[j], (j == a-1) ? "" : ", ");
fprintf(f, " }");
return 0;
}
int main (int argc, char ** argv) {
if (argc != 1+1) {
fprintf(stderr, "uporaba: %s <stevilo po vrsti>\nprimer: %s 4 < stevilka.txt\nprogram v stdin pričakuje ASCII številke, ločene z LF po vrsticah in s presledkom po stolpcih. naj se stdin konča z LF! če številke pišete na roke, začnete računanje s Ctrl+D.\n", argv[0], argv[0]);
return 1;
}
unsigned long int n = strtoll(argv[1], NULL, 10); // Number in a row
char c = fgetc(stdin); // Current buffer Character
if (c == EOF) {
fprintf(stderr, "napaka! pred EOF ni bilo v stdin podatkov!\n");
return 2;
}
long int zmnozek = 1; // ko množimo, uporabimo to za buffer
long long int nz = 0;
size_t i = 0; // Index za loope
size_t j = 0; // index za globlJe loope
size_t k = 0; // še ena spremenljivKa
size_t z = 0; // Zapisano VRSTIC!
size_t r = 0; // zapisano številk pri trenutni vRstici!
short int t = 0; // zapisano pri Trenutni številki, da lahko delamo strtoll
size_t velikost_1 = ZACETNA_VELIKOST; // velikost ene vrstice
size_t * dolzina_vrstice = malloc(sizeof(size_t)*(n+2)); // dodamo za maxInMin
long int ** v = malloc(sizeof(long int *)*n); // zadnjih n vrstic (za (-) |/\)
for (i = 0; i < n; i++) // lahko bi samo za [0], itak je realloc po vsakem \n
v[i] = malloc(sizeof(long int)*velikost_1);
size_t vel_ts = ZACETNA_VELIKOST;
char * trenutna_stevilka = malloc(sizeof(char) * vel_ts);
trenutna_stevilka[0] = '\0';
while (c != EOF) { // paziti moramo na big endian zapis številk
if ((c - '0' >= 0 && c - '0' <= 9)) { // c je številka
if (vel_ts-3 <= t+3) {
vel_ts = 2*vel_ts;
trenutna_stevilka = realloc(trenutna_stevilka, vel_ts*sizeof(char));
}
trenutna_stevilka[t] = c;
trenutna_stevilka[++t] = '\0';
}
if (c == ' ' || c == '\n') { // ločilo
if (velikost_1-3 <= r+3) { // off by one (:
velikost_1 = velikost_1 * 2;
v[z % n] = realloc(v[z], velikost_1 * sizeof(long int));
}
v[z % n][r] = strtol(trenutna_stevilka, NULL, 10);
trenutna_stevilka[0] = '\0';
r++;
if (r >= n) { // preskusimo za vodoravne faktorje
zmnozek = 1; // na prvem runnu za npr. n=4 bomo torej brali [0][1][2][3]
for (i = 0; i < n; i++) // na drugem pa bo r-1 = 1, zato [1][2][3][4]
zmnozek = zmnozek*(v[z % n][((r-1)-(n-1))+i]); // r-1 smo pravkar zapisali
if (zmnozek > nz) {
nz = zmnozek;
slint_array_print(v[z % n]+((r-1)-(n-1)), n, stdout);
fprintf(stdout, ": nove vodoravne z največjim zmnožkom %lld.\n", nz);
}
}
t = 0;
}
if (c == '\n') { // c je ločilo
dolzina_vrstice[z % n] = r;
velikost_1 = ZACETNA_VELIKOST;
z++;
v[z % n] = realloc(v[z % n], velikost_1 * sizeof(long int));
if (z >= n) { // če smo že zapisali n vrstic, lahko iščemo |\/
dolzina_vrstice[n] = 0; // max
dolzina_vrstice[n+1] = 69694201337; // min
for (i = 0; i < n ; i++) // najprej dobimo max in min dolzino_vrstice.
if (dolzina_vrstice[i] > dolzina_vrstice[n])
dolzina_vrstice[n] = dolzina_vrstice[i];
if (dolzina_vrstice[i] < dolzina_vrstice[n+1])
dolzina_vrstice[n+1] = dolzina_vrstice[i];
zmnozek = 1;
for (i = 0; i < dolzina_vrstice[n+1]; i++) { // i-stolpec - preskušamo|
zmnozek = 1;
for (j = 0; j < n; j++) // j je vrstica
zmnozek = zmnozek*(v[j][i]); // iščemo po stolpcih
if (zmnozek > nz) {
nz = zmnozek;
slint_array_print(v[z % n]+((r-1)-(n-1)), n, stdout);
fprintf(stdout, ": nova navpična z največjim zmnožkom %lld.\n", nz);
}
}
i = 0; // stolpec
j = 0; // vrstica
k = 0; // orientacija: 0: \, 1: /
for (k = 0; k <= 1; k++) {
for (i = k ? n - 1 : 0; i < dolzina_vrstice[0]; i++) {
zmnozek = 1;
for (j = 0; j < n; j++) {
if (i >= dolzina_vrstice[j])
goto continue_nov_stolpec_diagonala;
if (k)
zmnozek = zmnozek * v[j][i-j];
else
zmnozek = zmnozek * v[j][i+j];
}
if (zmnozek > nz) {
nz = zmnozek;
slint_array_print(v[z % n]+((r-1)-(n-1)), n, stdout);
fprintf(stdout, ": nove diagonale z največjim zmnožk. %lld.\n", nz);
}
continue_nov_stolpec_diagonala:
;
}
}
}
r = 0;
}
c = fgetc(stdin);
}
// sedaj samo preverimo, če se pravilno preberejo številke #DEBUG
// for (i = 0; i < n; i++) {
// slint_array_print(v[i], dolzina_vrstice[i], stderr);
// fprintf(stderr, "\n");
// }
return 0;
}
|
