Hogyan kéne ezt megírni? (C nyelv)

Régen C-ztem, és most lusta vagyok belerágni magam újra, szóval nem konkrét kódot fogsz kapni, csak iránymutatást.

Természetesen ez csak egy lehetséges megoldás, a programozás egyik fő jellemzője az, hogy egy feladatot rendszerint több módon is meg kéne oldani.

Én bevezetnék egy logikai szerepű változót (nyilván int, mivel a C-ben nincs logikai adattípus), és ezt igazra állítanám (1-re), tehát abból indulunk ki, hogy jó a rendszám. Majd sorban ellenőrizném a karaktereit, és ha valamelyik nem stimmel, akkor ezt a logikai változót hamisra (0) állítanám. Ha jó az adott karakter, akkor nem bánatnám. Első körben ellenőrizném a hosszát, ha az nem 7, akkor hibás. Majd végiglépkednék a karakterein. (A string ugyebár egy karaktertömb. Minden nyelvben lényegében az, de a C konkrétan annak is kezeli.) Az első háromnál azt viszgálnám, hogy betű-e, a negyediknél konkrétan azt, hogy kötőjel-e, majd pedig hogy számok-e. Ezekre a vizsgálatokra vannak beépített függvények, például: [link]

Nem biztos ,de talán ez segíthet valamennyit.

[link]

A kettes iránymuatása a legjobb számodra.

Azt kell első körben megálapítani a beolvasott karakterről, hogy az miféle.

Három lehetőség van,

szám, betű vagy egyéb. Ennek csekkolása mellett a karakterpozícióra kell még tekintettel lenni.

Az első három lehet a latin ABC valamely betűje. A második három pedig numerikus karakter.

Ennyi az egész. Egy nagyon egyszerű parser.

A betűket mondjuk érdemes nagybetűsíteni.

Kéd dolog jut eszembe(amik valójában ekvivalensek egymással, de ezt most hagyjuk):

Megpróbálkozhatsz reguláris kifejezéssel. Talán ez a legegyszerübb:

[A-Z]{3}-[0-9]{3}. Ha még nem hallottál a reguláris kifejezésekröl, a wikipédián olvashatsz róla: [link]

A másik, ami eszembe jutott, építhetsz egy véges állapotú gépet hozzá(finite state machine: [link]

Az állapothalmaz: betu_1, betu_2, betu_3, kotojel, szam_1, szam_2, szam_3, ok, hiba

Az ABC az lehet mondjuk A-tól Z-ig, 0-tól 9-ig meg a kötöjel.

A kezdö állapot a betu_1

Az elfogadó állapot pedig az ok.

Az állapot átmeneti szabályokat így fogalmaznám meg:

betu_1 X [A, B, ..., Z] -> betu_2

betu_1 X [0, 1, ..., 9, - ] -> hiba

betu_2 X [A, B, ..., Z] -> betu_3

betu_2 X [0, 1, ..., 9, - ] -> hiba

betu_3 X [A, B, ..., Z] -> kotojel

betu_3 X [0, 1, ..., 9, - ] -> hiba

kotojel X [-] -> szam_1

kotojel X [A, B, ..., Z, 0, ..., 9] -> hiba

szam_1 X [0, ..., 9] -> szam_2

szam_1 X [A, B, ..., Z, -] -> hiba

szam_2 X [0, ..., 9] -> szam_3

szam_2 X [A, B, ..., Z, -] -> hiba

szam_3 X [0, ..., 9] -> ok

szam_3 X [A, B, ..., Z, -] -> hiba

hiba X [bármi] -> hiba

ok X [bármi] -> hiba

Itt találsz többféle implementációt ilyen automatákra: [link]

Persze lehet mondani, hogy ez a két módszer túlzás ilyen egyszerü feladathoz, de szerintem sokat lehet belöle tanulni. Persze a következö algoritmus is müködik:

int is_valid(char * rendszam)

{

if(strlen(rendszam) != 7) return 0;

bool result = isalpha(rendszam[0]) && isalpha(rendszam[1]) && isalpha(rendszam[2]);

result = result && (rendszam[3] == '-');

result = is_valid && isdigit(rendszam[4]) && isdigit(rendszam[5]) && isdigit(rendszam[6]);

}

#7: a függvény végéröl lemaradt a return result, meg az utolso elötti sorban a result = is_valid &&... helyett result = result && ... kell:

int is_valid(char * rendszam)

{

if(strlen(rendszam) != 7) return 0;

int result = isalpha(rendszam[0]) && isalpha(rendszam[1]) && isalpha(rendszam[2]);

result = result && (rendszam[3] == '-');

result = result && isdigit(rendszam[4]) && isdigit(rendszam[5]) && isdigit(rendszam[6]);

return result

}