Newsgroup: it.comp.lang.pascal
Titolo: File di testo e carattere '^'

Ieri prova scritta di programmazione, oggi cerco di riguardare gli esercizi 
del compito e mi accorgo che ho sbagliato da cima a fondo l'ultimo 
esercizio...ci sto sbattendo la testa su ormai da 5 ore e non ne vengo a 
capo...è evidente che dopo 4 mesi che studio programmazione non c'ho capito 
un accidenti e quindi mi rivolgo a voi esperti ed 'anime pie' ^___^ se non 
altro per cercare di capire qualcosina....:/
****Il testo dell'esercizio è questo:****
Un file di testo 'nomi.txt' contiene, per ogni riga, una serie di nomi, 
alcuni dei quali sono preceduti e seguiti dal carattere '^'. Scrivere un 
algoritmo per costruire un nuovo file in cui siano presenti uno per riga 
solo i nomi compresi tra due '^'.
Esempio:
nomi.txt=
Antonio Guido ^Carlo^ Germano ^Giuseppe^
Dino Romolo ^Davide^ ^Gemma^
Il nuovo file sarà
Carlo
Giuseppe
Davide
Gemma
******************************************
Voi come l'avreste risolto??
Quello che ho scritto nel compito non funziona per niente, da stamattina 
invece sono riuscita a fargli scrivere solo Carlo e Davide con questo codice
che mi pare ovvio ha qualcosa che non va...
*********************************************
PROGRAM ScriviFile (primofile,secondofile);
 VAR
  primofile,secondofile: text;
  ch,ch2: char;
  nomevalido: STRING[30];
 BEGIN
  assign(primofile,'nomi.dat');
  assign(secondofile,'nomi2.dat');
  reset(primofile);
  rewrite(secondofile);
  WHILE NOT eof(primofile) DO
   BEGIN
    WHILE NOT eoln(primofile) DO
     BEGIN
      nomevalido:='';
      read(primofile,ch);
      IF ch='^' THEN
       WHILE (ch2<>'^') AND (ch2<>' ') DO
        BEGIN
         read(primofile,ch2);
         IF (ch2<>'^') AND (ch2<>' ') THEN
          nomevalido:=nomevalido+ch2
         ELSE IF ch2='^' THEN
          writeln(secondofile,nomevalido);
        END;
      readln(primofile);
     END;
   END;
 END.
***********************************************
TIA
-- 
#___o(^.-)o____Valefatina©___________________________________________#
  [cit] Ama il tuo prossimo, non questo, il prossimo! [/cit]
 
  # Per rispondere in mail leva una 'b' a caso dall'indirizzo.
  # ICQ: 105400693
  # INVIAMI UN SMS [e già che ci sei firmati :)]
  # 
http://www.smsatme.com/sma/sms.php?auth=:A6:19:E6:DE:A0:87:EB:1E
#____________________________________________________________________#

 ha scritto nel messaggio
news:Xns91BB9490F7749...@193.70.192.102...


 P.p.s. Gli altri esercizi ti sono riusciti???
Il terzo non l'ho proprio fatto e gli altri li ho provati oggi a casa e il 
primo è l'unico che funziona....nel secondo ho fatto un errore di 
distrazione e nel quarto ho piazzato un FOR assurdo al posto di un 
while...mi mangerei le mani!!! :/ Cmq mi sa che non l'ho passata...a te come 
è andata?


 è andata?
Non ne parliamo ke è meglio!!! Io sicuro non sono passato...la ragione?!?
Sono un caxxone! :)
Mi posti gli esercizi ke hai fatto?
Tnx By Gianni

 Mi posti gli esercizi ke hai fatto?
Mi vuoi far fare brutte figure?? Ma si va...tanto peggio di così non può 
andare....
Esercizio 1 (questo pare funzionare ma chissà il prof come la prenderà..)
Assign(unfile,'dati.txt')
Reset(unfile)
WHILE NOT eof(unfile)
 i <-- i+1
 WHILE ch<>'^'
  read(unfile,ch)
  IF ch<>'^' THEN
   nomi[i] <-- nomi[i]+ch
 read(unfile,ch)
 WHILE NOT eoln(unfile)
  read(unfile,ch)
  citta[i] <-- citta[i]+ch
 readln(unfile)
 WHILE ch<>'^'
  read(unfile,ch)
  IF ch<>'^' THEN
   indirizzi[i] <-- indirizzi[i]+ch
 read(unfile,ch)
 readln(unfile,numerorighe)
 FOR j:=1 TO numerorighe
  readln(unfile)
Close(unfile)
write('Inserisci la città secondo la quale effettuare la ricerca: ')
readln(ricerca)
FOR j:=1 TO i
 IF ricerca=citta[j] THEN
  writeln(nomi[j])
  writeln(indirizzi[j])
Esercizio 2
FOR j:=1 TO N
 FOR i:=1 TO M
  IF A[i,j]>0 THEN
   B[j,1]:=B[j,1]+1;
FOR i:=1 TO M
 FOr j:=1 TO N
  IF A[i,j]>B[j,2] THEN
   B[j,2]:=A[i,j]
Esercizio 4
FOR i:=1 TO N3        <---- Da notare l'orrore...ci voleva WHILE succ<N3 
 succ <-- A3+2*A2+A1
 IF (N1<=succ) AND (N2>=succ) THEN
  conta1 <-- conta1+1
 IF (N2<=succ) AND (N3>=succ) THEN
  conta2 <-- conta2+1
 A1 <-- A2
 A2 <-- A3
 A3 <-- succ
Esercizio 5....e qua non sapremo mai se ridere o piangere...ecco quello che 
ho scritto sul foglio:
Assign(primofile,'nomi.txt')
Assign(secondofile,'nomi2.txt')
Reset(primofile)
Rewrite(secondofile)
WHILE NOT eof(primofile)
 WHILE NOT eoln(primofile)
  nomevalido:=''
  read(primofile,'ch')
  IF ch='^' THEN
   WHILE (ch2<>'^') OR (ch2<>' ')
    read(primofile,ch2)
    IF (ch2<>'^') OR (ch2<>' ') THEN
     nomevalido:=nomevalido+ch2
   writeln(secondofile,nomevalido)
Una cosa che mi resterà per sempre oscura... ^____-


Personalmente il vostro problema l'ho risolto nel modo seguente, che mi
sembra, nonostante di solito sbagli questo tipo di previsioni, il più
immediato:
(**********************************)
program ricerca(nomi,Out);
var nomi,nuovo:text;
    testo,nome:string;
    j,m:integer;
begin
assign(nomi,'nomi.txt');
assign(nuovo,'nuovo.txt');
reset(nomi);
rewrite(nuovo);
append(nuovo);
while not eof(nomi) do
begin
readln(nomi,testo);
while pos('^',testo)<>0 do begin
j:=pos('^',testo);
inc(j);
m:=j;
while testo[m]<>'^' do begin
inc(m);
end;
dec(m);
nome:=copy(testo,j,(m-j+1));
delete(testo,(j-1),((m+2)-(j-1)));
writeln(nuovo,nome);
end;
end;
close(nomi);
close(nuovo);
end.
(**********************************)

 sembra, nonostante di solito sbagli questo tipo di previsioni, il piů


 Const Max=25;
[cut]
Calma e sangue freddo....perchè mi entra in loop?? O__o


 ha scritto nel messaggio
news:Xns91BECEE675D81...@193.70.192.102...


 spazio. 
Ma questa dove stava scritta?? Sul foglio del compito?? O__o


 ha scritto nel messaggio
news:Xns91BF8F661CF5E...@193.70.192.103...


 Ringrazio, Cooper.
http://groups.google.com/groups?as_umsgid=6BPc8.502%246F1.6101
@
twister2.libero.it
&hl=it
(metti il link su una sola riga)


 ha scritto nel messaggio
news:Xns91BB9490F7749...@193.70.192.102...



No sugli appunti di programmazione! E poi scusami se insisto ma il programma
a me gira benissimo! Prova a fare quello ke ti ho detto (dare uno spazio
prima del ritorno a capo) e vedrai ke il programma ti funziona! Altrimenti
revisiona il Turbo Pascal :D

 funziona! Altrimenti revisiona il Turbo Pascal :D
No aspè adesso comincio davvero ad incasinarmi più di quanto non lo sia già 
di mio....Cioè io ho fatto tutta una serie di esercizio sui file di testo 
perchè effettivamente è stata una delle cose per me più complicata da capire  
e *tutti* i file che io ho usato erano del tipo
primariga<eoln>
secondariga<eoln>
terzariga<eoln>
......
<eof>
Senza nessuno spazio tra l'ultimo carattere della riga e l'eoln....vuol dire 
che ho sbagliato tutto?? O___o e allora perchè gli esercizi giravano?? O__o


 ha scritto nel messaggio
news:Xns91C09AFA92D2D...@193.70.192.102...


 perderei di casa :-) hehehe :-)
Il prof di laboratorio di programmazione....si sembri proprio lui ^___^
Cmq il metodo a cui fai riferimento l'ho sempre usato, fin dal principio, la 
mia difficoltà sta cmq proprio nel non riuscire a capire come manipolare 
caratteri, stringhe e file di testo malgrado abbia provato a documentarmi su 
più di un libro....ufff... Mi sento così scemina :/


 Cordialmente, Cooper.
Si ma nel testo dell'esercizio non c'era nessuno spazio da mettere a fine 
riga quindi io non l'ho proooooprio considerato.... :/
-- 
#___o(^.-)o____Valefatina©___________________________________________#
  [cit] Ama il tuo prossimo, non questo, il prossimo! [/cit]
 
  # Per rispondere in mail leva una 'b' a caso dall'indirizzo.
  # ICQ: 105400693
  # INVIAMI UN SMS [e gią che ci sei firmati :)]


 completamente fuori tema. :((  Ti spiego come andava risolto il problema.
senti Cooper, questo e' un compitino di 1° anno univ., la soluzione
data da Fatina era in tema, il fatto di decomporlo in sottoproblemi non
cambia la "correttezza" ma e' soltanto una questione di "stile"
Un programma come il tuo e' tre volte piu' lungo e 2 volte piu' gravoso
secondo me e' "pessimo" ma anche qua e' questione di "stile" :-)
La soluzione piu' comoda secondo me e' molto vicina a quella di fatina,
sebbene leggere carattere per carattere voglia dire essere masochisti
e sperare in casi particolari che creino problemi :-)
Ecco un comodo algo (equiv ad un automa a due stati), fatto con quelli
che penso siano i comandi che hanno gia' studiato.
var
 n: byte;
 in_nome : boolean;
 riga, nome : string;
 text_in, text_out: text;
begin
 Assign(text_in,'infile.txt');
 Reset(text_in);
 Assign(text_out,'outfile.txt');
 Rewrite(text_out);
 while not eof(text_in) do
  begin
   readln (text_in, riga);
   in_nome := false;
   nome := '';
   for n := 1 to length(riga) do
    if riga[n] <> ' ' then {spazio}
     if riga[n] = '^' then
      begin
       if in_nome then
        begin
         writeln(text_out, nome);
         writeln(nome); {debug}
         nome := '';
        end;
        in_nome := not in_nome;
      end
     else if in_nome then nome := nome + riga[n];
  end;
  Close(text_in);
  Close(text_out);
 end.
20 righe +/-, senza tanti problemi ne funzioni astruse :-)
--
Dreadnaut
(Life would be easier if I had the source code)

Interessante,
e come ti comporti se il file contiene nomi del tipo:
^pippo^^
^pip^ppo^^pppo^^^
^^pippo^
ecc ecc ? Ci hai pensato? E comunque la soluzione fornita da me è piuttosto
semplice io per completezza ho voluto anche codificarlo tutto quanto in modo
che lei potesse verificarlo col pascal direttamente.
Te leggi carattere per carattere... quindi hai bisogno di una sentinella per
evitare che cerchi di accedere al carattere successivo all' EOL o EOF che
sia...  e per di più sei costretto a usare un codice di controllo nel tuo
caso ^ cosi da mandare in crash tutto quanto non appena si presentano casi
come riportati sopra... quindi in sostanza il tuo algoritmo non va...
Il mio al contrario del tuo, legge una riga per volta dal file...
Individua le singole parole (non necessariamente nomi) che sono separati
ovviamente da spazi (e questo vale sempre e non dipende dalle parole in se e
per se).
Dopo che ha individuato tali parole, le ricopia in un vettore temporaneo e
da questo vettore, trasferisce nel file di destinazione soltanto quelle
parole che hanno agli estremi gli ^ (apici) escludendo questi ultimi come
parte integrante del nome... in sostanza....
SORGENTE  ===> DESTINAZIONE
    ^Pippo^  ====> Pippo
    ^pippo   =====> (Non viene trasferito)
    Pippo^  =====> (Non viene trasferito)
    Pippo  ======> (Non viene trasferito)
    ^^Pippo^ ====> ^Pippo
    ^^Pippo^^ ====> ^Pippo^
    ^Pi^p^po^  ===> Pi^p^po
    ^^Pippo ====> (Non viene trasferito)
    Pippo^^ ===> (Non viene trasferito)
Ecco il tutto.
Il fatto che sia del primo anno di università o dell'ultimo è irrilevante,
ciò che è invece rilevante è che abbia una certa abilita nel ragionamento e
soprattutto nella intuizione... a fatina non serve a niente saper
programmare in pascal se non sa come arrivare alla soluzione...
Ragion per cui, non serve a nulla che fornisci il codice bello pronto e
fatto senza darne alcuna spiegazione in merito e soprattutto senza spiegare
il motivo per cui risolvi il problema in quel modo... ovvero senza spiegare
come sei pervenuto a quella soluzione e la logica da te seguita con i pro e
contro.
Osserva quanto ho fatto io nel post precedente e noti la differenza...
Io mi sono premurato prima di tutto a far capire come andava risolto il
problema e quindi "come optional" per venirle incontro ho riportato anche il
codice completo che comunque come ho espressamente scritto era LA MIA
SOLUZIONE, vale a dire che ce ne possono essere altre, non che è l'unica.
A me personalmente interessa che Fatina comprenda l'errore e capisca dove ha
sbagliato cosi da acquisire esperienza e sapere come fare per la prossima
volta... non mi interessa che capisca il codice della soluzione che ho dato
ma piuttosto la logica che io ho seguito.
Il codice è relativo, specialmente se si considera in un ambiente
didattico... il codice non serve a nulla se non si capisce la logica con cui
è stato generato.
Ciò premesso,  cordiali saluti :-)
Cooper.
"Dreadnaut" <Drea...@liberoDALLASPAM.it> ha scritto nel messaggio
news:NaAe8.25988$v7.10...@twister1.libero.it...


a meno che non sei proprio terra terra ma lo escludo :-)
...e fatina rimane a bocca asciutta, perche' lei ha sbagliato giusto
due if, e si e' dimenticata un read... era questo che cercavo di spiegarti
anche se boh per mail non si riesce mai... boh se ancora non ci
sono riuscito, o tu non sei riuscito a capirmi, magari ci becchiamo
in chat una sera o l'altra...
riepilogando: semplicita', risposta alla domanda
[ e magari quoting decente :-) ]
tu sei un analista e analizzi... ma la soluzione di un problema si trova
con analisi E sintesi... :-)


  END.
e questo readln e' un blocco piu' esterno, cioe' un "end" piu'
sotto: devo leggere la fine della riga se ho trovato l'eoln,
quindi all'uscita del ciclo "while not eoln".. probabilmente
ci avevi pensato perche' il prmo ciclo ha il begin/end che
altrimenti sarebbe inutile per una sola istruzione (cioe' il
2° while)... non e' perfetto ma funziona :-)


No comment,
lascio ogni eventuale giudizio al suo prof di università... fra la soluzione
da me presentata e la tua... sarà lui stesso a valutare quale fra le due è
la migliore.
Il fatto che il tuo programma sia più corto del mio non significa che sia
più semplice del mio...  sul piano algoritmico intendiamoci :-)
Il testo dice di ricopiare su un file di destinazione soltanto i nomi che
contengono gli apici ai loro estremi senza quest'ultimi... ma non fa alcun
riferimento alla tipologia di questi nomi... quindi nel caso peggiore nulla
esclude che possano essere del tipo ^maria^anna^.
Sottovaluti appunto che ci sono anche i nomi composti da più parole e non
solo quelli da una sola parola, e nessuno (almeno non è scritto nel testo)
proibisce l'uso del ^ (apice) per separare due nomi.... composti.
Cordialmente, Cooper.
PS: Un programma senza logica non è un algoritmo :-)

 PS: Un programma senza logica non è un algoritmo :-)
un algoritmo senza logica funziona sempre :-)


Ovvio Dread, concordo anche io... ma rimane il fatto che essendo a scopo
didattico, il docente vuole verificare la capacità risolutiva e analitica
del problema... del candidato e non vedere che sa fare il programmino...
quindi gli interessa soprattutto il grado di intuizione....  che il
candidato ha nel prevenire tutti i possibili effetti collaterali :-)
Cordialmente, Cooper.
PS: Un algoritmo senza logica... beh non è un algoritmo :) Per definizione
un algoritmo è una sequenza logica e ordinata di passi..... atti alla
risoluzione di un determinato problema.
Nota... dico passi e non istruzioni... perchè una istruzione implica una
struttura dati... un'algoritmo prescinde da ciò. :-P
"Dreadnaut" <Drea...@liberoDALLASPAM.it> ha scritto nel messaggio
news:_JTe8.32765$fa5.1...@twister2.libero.it...


 [ triste contrasto con la realta'... sigh... ]
ehehehhe e ce credo si.... :-))

roba da te :-)
c'e' cmq differenza fra software "corretto" e software "a prova di scemo"
il secondo sara' perfetto, ma pesante nel funzionamento e nell'utilizzo
il primo sara' scontroso, ma "sufficiente" :-)


 ... non e' perfetto ma funziona :-)
 
Ehmmm...credevo di aver capiro ma evidentemente stringhe caratteri e file 
non fanno per me...
E' così che deve venir fuori il tutto??
(***BEGIN PROGRAM***)
PROGRAM ScriviFile (primofile,secondofile);
 VAR
  primofile,secondofile: text;
  ch,ch2: char;
  nomevalido: STRING[30];
 BEGIN
  assign(primofile,'nomi.txt');
  assign(secondofile,'nomi2.txt');
  reset(primofile);
  rewrite(secondofile);
  WHILE NOT eof(primofile) DO
    WHILE NOT eoln(primofile) DO
     BEGIN
      nomevalido:='';
      read(primofile,ch);
      IF ch='^' THEN
       read(primofile,ch2);
       IF (ch2<>'^') AND (ch2<>' ') THEN
        nomevalido:=nomevalido+ch2
       ELSE IF ch2='^' THEN
        writeln(secondofile,nomevalido);
     END;
    readln(primofile);
   END;
  Close(primofile);
  Close(secondofile);
 END.
(***END PROGRAM***)
Non mi scrive niente nel secondo file... :/
Lo so che sono rompiOO ma anche se ormai l'esame non l'ho passato almeno 
vorrei capire....diecimila libri e ancora non ho capito come diavolo 
funziona con questi maledetti caratteri... 
Se mi 'illumini' pizza e birra aggratis! ^___^
-- 
#___o(^.-)o____Valefatina©___________________________________________#
  [cit] Ama il tuo prossimo, non questo, il prossimo! [/cit]
 
  # Per rispondere in mail leva una 'b' a caso dall'indirizzo.
  # ICQ: 105400693
  # INVIAMI UN SMS [e già che ci sei firmati :)]


 Se mi 'illumini' pizza e birra aggratis! ^___^
eheheh mandale per mai :-)


Non condivido ma accetto il tuo punto di vista. Io personalmente rimango del
parere sempre e comunque che quello che si studia o che si fa... non si fa
per il prof o per l'università ma per se stessi... per cultura personale...
per crescere... per maturare... soprattutto per acquisire esperierienza.
Per questo ho scritto prima che il fatto che Fatina, sia al primo anno o
all'ultimo è irrilevante... ma che è rilevante il fatto che acquisisca
esperienza e abilità risolutiva... più si va avanti infatti... più le cose
diventano complesse... e se non si impara adesso... poi rimarranno buchi da
colmare in futuro... ne vale la pena allora mi chiedo? Mah....
Cordialmente, Cooper. :-)

 il primo sara' scontroso, ma "sufficiente" :-)
Questa teoria ce la spieghi.  Come si chiama ? Teorema di Dreadnaut ?
Il software "a prova di scemo" e' per sua natura corretto, proprio
perche' "a prova di scemo".  Generalmente questa caratteristica e'
difficile da raggiungere, presuppone che il programmatore abbia 
sufficiente esperienza per capire quali sono le cose che e' meglio
non lasciar compiere all'utente, capire quali sono i controlli che
deve implementare, ecc... ecc... Ne deriva che un software scritto
con questi criteri lavora sicuramente in modo corretto.
Ben altra cosa e' l'eventuale presenza di bug.
Che intendi poi per "scontroso e sufficiente" riguardo il software
corretto e "perfetto e pesante" in quello "a prova di scemo" ??
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 ha scritto nel messaggio
news:3bedfb8d5ba17e14d72...@mygate.mailgate.org...


 [ triste contrasto con la realta'... sigh... ]
Io lo ridefinirei:
"Primo Teorema della Programmazione Alla Carlona".


 PS: Io tifo per il "software a prova di scemo" :P hihi :-)
Anch'io.
Sara' che e' quello che mi e' stato sempre richiesto :)


ok lo avrei dovuto chiamare "solo corretto"... intendo che esiste
software "bare" o "grezzo" che va senza tanti complimenti ma
bisogna dargli in pasto solo roba corretta, e software di livello
piu' alto che effettua controlli su tutto quello che gli viene dato
in input... se poi notavi c'era la faccina ad indicare lo scherzo...


penso di aver ripetuto in ogni messaggio che quello che ho
detto vale perche' questo era il testo di un esamino che chiedeva
un algoritmo, che non "voleva" controlli finissimi sull'input, ma
doveva brutalmente svolgere il lavoro richiesto...
Inutile appesantire il codice con controlli inutili e cercare di
spiegare la scansione di un file introducendo concett piu' complessi
Se si parla di "lavoro serio" e' un altro paio di maniche...
ma la gente non legge...


 software "bare" o "grezzo" che va senza tanti complimenti ma
Uhm... "bare" sta per barese? hehe... oppure intendevi di base? :PPPPPP
Scherzooooooooooo ehheheheeh :-)
Cooper

"bare" dall'inglese :-)
sul monolingue: "without the usual covering or protections"


 ha scritto nel messaggio
news:132765231ed19c878b0...@mygate.mailgate.org...


 settore: informatico/elettronico/tecnologico ecc ecc...
Sulla distinzione siamo d'accordo.
Il problema e' quanto questa figura "distinta" risponda al vero.
Per quello che ho potuto vedere non e' cosi' frequente che l'analista
faccia l'analista e il programmatore il programmatore.


 se poi notavi c'era la faccina ad indicare lo scherzo...
Quindi sono tutte fesserie ?


 ma la gente non legge...
Diciamo che la gente scrive coi piedi ed esprime concetti un po'
troppo lontani dalla realta'.  Gli esami universitari non si fanno
tanto per farli.  Servono a dimostrare che cosa hai capito e se
hai capito che il software si scrive senza controlli, vuol dire
che non hai capito.


asp... ora rispiego con calma quello che "credevo" fosse il thread
cosi' almeno sono sicuro :-)
di solito io tendo a fare questa principale differenza fra 'Software' e
algortimo:
un 'Software' e' una cosa complessa, che magari prevede un'interazione con
l'utente, che cmq prende un input, lo verifica, ci fa' sopra un lavoro e poi
fornisce un risultato.
Un algoritmo e' invece uno spezzone di codice che prende un input,
che per ipotesi e' corretto, e fornisce l'output corrispondente.
E' "bare" in questo senso: non ha alcuna protezione da un input scorretto
pero' _se_ l'input e' corretto svolge il suo lavoro.  Il 'Software' e' un
programma
che cresce attorno ad uno o piu' algoritmi, circondandoli di controlli,
opzioni,
interfacce e tutto quello che si vuole aggiungere.
Se non si vuole aggiungere niente beh si puo'... ma questo e' un programma
"bare", se invece si aggiunge cosi' tanta roba che _qualsiasi_ input dato
il programma non ha problemi a gestirlo (sia correttamente che avvisando
l'utente) beh questo e' un programma "a prova di scemo".
Certo non si puo' immettere sul mercato un programma spoglio di qualsiasi
controllo, ma se fai un programmino _per te_ che sai come usarlo, lo
riempirai
di controlli sull'input ?
Io nel primo messaggio del thread ho letto "Scrivere un algoritmo" e quindi
ho pensato alla procedura piu' semplice, spoglia e funzionale che mi venisse
in mente (seguendo la soluzione che non funzionava di Fatina) e non a
progettare un software da proporre al pubblico :-)
Quindi l'ho fatto a cuor leggero, perche' mi divertiva l'idea di risolvere
il
problema, ed e' questo che intendo per programmazione spensierata, quella
dove non c'e' un committente e non c'e' un destinatario, quella fine a se
stessa.
Ed e' forse il motivo perche' continuo a frequentare questo ng: perche' mi
diverto a programmare, come molti altri qua.
e se voi lo fate per lavoro, beh... non fatemene una colpa ;-)


Tranquillo :-)
Il punto cmq non credo sia questo... mettendo le cose come intendi tu,
infatti io condivido appieno quanto dici... ma c'è da dire che il caso che
prendi in esame tu è quello di una persona che a titolo esclusivamente
personale, vuole verifcare se un algoritmo che ha scritto funzioni
correttamente.
Vale a dire, mi viene l'idea, trovo la soluzione a un problema e sviluppo
l'algoritmo, lo codifico in un linguaggio di programmazione esempio in
pascal e lo verifico... verifico insomma se funziona bene...
Ma questo solo per uso esclusivamente personale.
Il nostro caso è ben lontano da questo, nel senso che... intanto è a scopo
didattico e poi come ha detto bene anche il nostro amico in un altro post,
quello che si studia all'università, gli esami etc etc hanno lo scopo di
verificare che quanto abbiamo appreso sia stato appreso bene e
correttamente...
Ciò significa che in questo caso, il lavoro svolto da noi non è fine solo  a
noi stessi ma soprattutto ad altri.... quando un domani appunto dovremmo
svolgere un lavoro per conto di terzi.
Per questi motivi... e soprattutto per il fatto che si tratta di un esame a
titolo didattico... è pressochè evidente e innegabile che una analisi
dettagliata e come dici tu lo sviluppo di un programma o codice che dir si
voglia.... "a prova di scemo" è inevitabile.
Perchè in questo caso, il docente come ho più volte detto, ha lo scopo di
prendere atto della tua capacità risolutiva del problema... e non del fatto
che sai fare o meno il programmino.
Tutto qui :-)
Cordialmente, Cooper.
"Dreadnaut" <Drea...@liberoDALLASPAM.it> ha scritto nel messaggio
news:uqtf8.41241$v7.15...@twister1.libero.it...


Ecco, mi ero riproposto di non intromettermi in questo thread che
forse sarebbe piu' adatto per it.comp.programmazione o qualcosa del
genere. Comunque visto che Dreadnaut e' in inferiorita' numerica devo
scendere in campo, ovviamente sono d'accordo con lui sia nel caso
specifico che come filosofia di programmazione in generale.
Caso specifico (o casus bellis): il corso del compito  di Fatina non
ha come scopo quello di preparare a costruire software "blindato" per
una centrale nucleare o per il sistema di controllo del razzo Ariane
(citazione non casuale) -  bensi' di avvicinare per la prima volta
persone che magari non sapevano nulla di stringhe e file ad usare i
primi elementi di un linguaggio. Prima i metodi *poi* i controlli che
verranno insegnati in un momento successivo, per imparare si comincia
con le cose semplici e se voi invece avete succhiato intelligenza
assieme al latte della mamma siete un caso a parte... (scherzo of
course).
Filosofia di programmazione (a beneficio dei posteri): una volta posto
un obiettivo si cerca di raggiungerlo col minor impegno possibile di
risorse, l'eleganza e' una qualita' utile solo se migliora
l'efficienza, altrimenti e' superflua se non fuorviante. Detta
all'osteria, i controlli "anti-stupido" sono necessari solo se
sbagliando rischio di causare qualche disastro o mandare in fumo
montagne di quattrini, altrimenti se cerco di calcolare l'energia HF
di un protone tuttalpiu' mi becco solo gli sberleffi di qualche
collega (battuta da chimico, tanto per far capire da dove nasce
l'approccio di cui sopra).
Omega e' omega e basta.
PS: Leggero' le vostre risposte ma non rispondero' piu' perche' credo
che ormai posizioni e argomenti siano gia' stati sviscerati.

 e se voi lo fate per lavoro, beh... non fatemene una colpa ;-)
Il problema e' che quando sei in un ng devi essere formale.
Non sai se i tuoi suggerimenti andranno ad incidere in un ambito
professionale o meno e quindi devi seguire una strada rigorosa.
Il problema della produzione del software, almeno in Italia,
e' che molte persone che la pensano come te non riescono a
staccarsi da questo modo di fare anche quando programmano a 
livello professionale, con il risultato che il software che
va in mano ai clienti non e' usabile, manca dei controlli giusti,
ecc... ecc... E' necessario, anche per i progetti giocattolo,
abituarsi a seguire la via corretta.
