Programmazione in Java

[Giovanni Tavella]

Originariamente inviato da fero86

usa il tag CODE e indentalo come si deve perché cosi é illeggibile.



esatto: tipico utente iscritto apposta per trovare una soluzione rapida, semplice e gratuita al suo personalissimo problema, che poi magari due giorni dopo se ne esce con: "RISOLTO, potete chiudere" perché ha trovato altrove un gonzo da cui copiare. e certo, i moderatori stanno al suo servizio e aspettano che lui, nella sua magnanimitá, gli dia il permesso di eliminare la spazzatura che ha creato, no? proporrei il ban dell'IP per questa gente.



quotone; per chi scrive in SMSese invece proporrei un ban semplice


PS: tornando al problema del topic, ancora non leggo da nessuna parte uno straccio di indicazione sul formato del file: binario? binario come?
testuale? testuale come? ASCII? ANSI? Unicode? UTF-8?

Sono iscritto da 5 mesi (è puoi controllarlo dalla data di iscrizione)e non ho mai fatto una sola domanda , questo dovrebbe dimostrarti che quello che hai scritto è una grandissima caxxaxa! Mi sono iscritto perchè mi piaceva il sito , e leggevo anche il forum, ora ho dei problemi ed ho chiesto un aiuto ,non riesco a capire cosa ci sia di sbagliato.

[PGI-Bis]

Originariamente inviato da Giovanni Tavella

Ho grandi dubbi, comunque credo si faccia cosi:...

L'aspetto forse più affascinante della programmazione (che spesso i corsi scolastici non rendono e la professione deprime) è la possibilità di fare quello che più ti aggrada.

Puoi cioè esprimere una soluzione di carattere generale e fare in modo che il programma "ti segua".

L'esercizio ha un limite che sembra proibire l'uso delle liste: non puoi caricare in memoria tutti numeri e poi ordinarli, devi leggere e scrivere tout-court.

Dai libero sfogo alla tua fantasia.

Hai N file che contengono ciascuno una sequenza di numeri in ordine crescente.

Devi scrivere in un file di destinazione l'unione di quelle sequenza, sempre in ordine crescente.

Sappiamo che se le sequenze nei file sono ordinate, trattando i file come se fossero delle pile di numeri, otteniamo il risultato voluto estraendo il minore tra i valori in testa a ciascun file e trasferendolo nella destinazione.

Ergo, in termini generali, la soluzione è piuttosto semplice:

finchè almeno uno dei file sorgente ha un valore in testa
    rimuovi dalla sua sorgente il minore tra quei quei valori e mettilo nella destinazione

Quindi abbiamo dei file che sono delle pile di numeri, un file che è una coda di numeri e un affascinante concetto di "numero che è consapevole della propria sorgente" (da cui deve essere rimosso).

Partiamo dalla soluzione:

import java.io.IOException;

public class Main {

    public static void main(String[] args) throws IOException {
	SorgenteEntità fileUno = new SorgenteEntità(args[0]);
	SorgenteEntità fileDue = new SorgenteEntità(args[1]);
	DestinazioneEntità fileTre = new DestinazioneEntità(args[2]);
	SequenzaUnioneSorgenti sequenzaUnioneSorgenti = new SequenzaUnioneSorgenti(fileUno, fileDue);
	while(sequenzaUnioneSorgenti.hasNext()) {
	    fileTre.enqueue(sequenzaUnioneSorgenti.next());
	}
    }
}

Che abbiamo? Abbiamo i nostri fileUno e fileDue. Abbiamo la destinazione, fileTre. Abbiamo l'unione ordinata di quei file. Finchè quell'unione ha un valore successivo, lo trasferiamo su fileTre. E il gioco è fatto.

Dov'è il trucco? Il trucco sta nel far si che il linguaggio ci segua cioè nell'andare a creare quelle definizioni particolareggiate che permettano a quelle sette righe di fare ciò che sembra che facciano.

Partiamo dalle sorgenti.

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class SorgenteEntità {
    private final Scanner scanner;
    private EntitàNumerica current;

    public SorgenteEntità(String filePath) throws IOException {
	scanner = new Scanner(new File(filePath)).useDelimiter("\\D+");
	current = new EntitàNumerica(this, scanner.nextInt());
    }

    public void remove(EntitàNumerica e) {
	if(e != current) {
	    throw new IllegalStateException(e + " != " + current);
	}
	if(hasNext() && scanner.hasNextInt()) {
	    current = new EntitàNumerica(this, scanner.nextInt());
	} else {
	    current = null;
	}
    }

    public boolean hasNext() {
	return current != null;
    }

    public EntitàNumerica peekMinimum(EntitàNumerica entità) {
	if(current == null) {
	    return entità;
	} else if(entità == null) {
	    return current;
	} else {
	    return current.getValore().doubleValue() < entità.getValore().doubleValue() ?
		current : entità;
	}
    }
}

E' una pseudo pila di entità numeriche il cui "peek" è condizionato al fatto che l'elemento effettivamente in testa sia minore di quello ricevuto come argomento dove il minore tra null e X è X, il minore tra null e null e null.

Il metodo remove estrae la testa e passa all'elemento successivo se la testa è l'elemento che si vuole rimuovere, altrimenti rilascia un'eccezione.

Tutta 'sta roba è lì perchè è il minimo necessario e sufficiente affinchè il nostro meccanismo possa funzionare: se ne avessimo ideato un altro avremmo scritto cose affatto diverse.

L'entità numerica è ciò di cui parlavamo prima: un numero che conosce la propria sorgente ed è in grado di rimuoversi da essa.

public class EntitàNumerica {
    private final Number VALORE;
    private final SorgenteEntità SORGENTE;

    public EntitàNumerica(SorgenteEntità sorgente, Number valore) {
	VALORE = valore;
	SORGENTE = sorgente;
    }

    public Number getValore() { 
	return VALORE;
    }

    public EntitàNumerica rimuoviDaSorgente() {
	SORGENTE.remove(this);
	return this;
    }
}

Qui EntitàNumerica sa chi sia la sua sorgente perchè essa è parte dei requisiti della sua inizializzazione. La rimozione è l'invocazione di remove che un'entità esegue usando sè stessa come argomento (anche qui si tratta solo di una possibile implementazione).

DestinazioneEntità è anche più stringata:

import java.io.IOException;
import java.io.PrintStream;

public class DestinazioneEntità {
    private final PrintStream OUTPUT;
    private boolean first = true;

    public DestinazioneEntità(String file) throws IOException {
	OUTPUT = new PrintStream(file);
    }

    public void enqueue(EntitàNumerica next) {
	if(first) {
	    first = false;
	    OUTPUT.print(next.getValore());
	} else {
	    OUTPUT.print(",");
	    OUTPUT.print(next.getValore());
	}
	OUTPUT.flush();
    }
}

enqueue stampa il valore dell'entità numerica ricevuta come argomento sul file di destinazione (passato come argomento dell'inizializzatore).

Il ghirigoro dell'if-else serve per produrre dei numeri separati da virgola, evitando di mettere virgole di troppo.

L'ultimo pezzo del puzzle è SequenzaUnioneSorgenti. Dal Main vediamo che ha tre caratteristiche:

1. richiede una successione di sorgenti per l'inizializzazione
2. ha un metodo hasNext() che presumibilmente restituisce true se l'unione ha un valore ulteriore, false altrimenti
3. ha un metodo next() che restituisce il valore successivo della sequenza.

Anche qui si tratta di una classe di poche righe:

public class SequenzaUnioneSorgenti {

    private final SorgenteEntità[] SORGENTI;

    public SequenzaUnioneSorgenti(SorgenteEntità... sorgenti) {
	SORGENTI = sorgenti;
    }

    public boolean hasNext() {
	for (int i = 0; i < SORGENTI.length; i++) {
	    if (SORGENTI[i].hasNext()) {
		return true;
	    }
	}
	return false;
    }

    public EntitàNumerica next() {
	EntitàNumerica entità = null;
	for (int i = 0; i < SORGENTI.length; i++) {
	    entità = SORGENTI[i].peekMinimum(entità);
	}
	return entità.rimuoviDaSorgente();
    }
}

hasNext() che fa? Dice: per ogni sorgente, se ce n'è almeno uno che ha ancora un valore da darmi, restituisci true. Altrimenti i giochi sono finiti.

next() opera in modo simile: deve restituire il minore tra i valori in testa ad ogni sorgente-pila. Usa un valore cache, inizialmente vuoto. Per ogni pila, la cache diventa il minimo tra la cache e il valore in testa alla pila attualmente esaminata. AL termine del ciclo è giocoforza che (se hasNext restituisce true) entità sia il minimo tra i valori in testa alle pile. Rimuove quindi quel valore dalla sua sorgente (l'entità sa chi sia) e lo restituisce.

Il formato dei file in input è specificato da SorgenteEntità.

new Scanner(new File(filePath)).useDelimiter("\\D+");

questo significa che lo scanner usa come delimitatore una qualsiasi successione di caratteri che non siano cifre. In soldoni, piglia solo numeri interi.

E questa è una soluzione. Come vedi è fatta di pochi piccoli pezzi dal significato peraltro indecifrabile a meno che non si conosca l'idea da cui si è partiti: con quell'idea le cose dovrebbeo assumere il loro senso.

L'ho scritta per darti un'idea del modus operandi: non limitarti a ciò che sai del linguaggio o a ciò che il linguaggio offre attraverso le sue librerie. Pensa a come risolveresti tu il problema da un punto di vista astratto, se potessi avere a disposizione tutti gli strumenti che preferisci, tutte le definizioni che puoi dare. A quel punto il programma, qualsiasi programma, non sarà altro che un mettere insieme definizione specifiche con quelle, più generali, offerte dalla piattaforma che decidi di usare.

[Giovanni Tavella]

grazie PGI-bis, ora studiero per bene quello che hai scritto...ti farò sapere se riusciro a capire questi "benedetti" file ... grazie

[Giovanni Tavella]

grazie PGI-bis, ora studiero per bene quello che hai scritto...ti farò sapere se riusciro a capire questi "benedetti" file ... grazie

[fero86]

Originariamente inviato da Giovanni Tavella

Sono iscritto da 5 mesi (è puoi controllarlo dalla data di iscrizione)e non ho mai fatto una sola domanda ,

puoi esserti iscritto anche due minuti fa, il regolamento lo devi leggere lo stesso, il non aver mai fatto domande non vedo come possa giustificarti alcunché.

questo dovrebbe dimostrarti che quello che hai scritto è una grandissima caxxaxa!

non leggo alcuna dimostrazione nel post che sto quotando, e una "caxxaxa" non so neanche cosa sia.

Mi sono iscritto perchè mi piaceva il sito , e leggevo anche il forum, ora ho dei problemi ed ho chiesto un aiuto ,non riesco a capire cosa ci sia di sbagliato.

1) titolo irregolare;
2) non hai usato il tag CODE;
3) di conseguenza non hai neanche potuto indentare il codice;
4) sarebbe gradito leggere italiano corretto a meno di (sporadiche) sviste ortografiche.

EDIT
5) contestualizza: oramai hai modificato il post iniziale, ma ti garantisco che non era molto lucido (non che adesso sia perfetto comunque).