|
|
|
|
Strumenti |
13-08-2017, 10:23 | #1 |
Junior Member
Iscritto dal: Aug 2017
Messaggi: 20
|
Esprimere una funzione in codice
Ciao a tutti
spero che mi possiate essere di aiuto , io ho questa funzione espressa così: Codice:
s: stringa t: template n: length(s) d: dizionario for i in [0,n) if t[i] e' una lettera minuscola AND s[i] diverso da t[i] return falso else if t[i] non nel dizionario d d[t[i]] = s[i] else if s[i] diverso da d[t[i]] return falso endfor return vero Qualche suggerimento ? Saluti e grazie |
21-08-2017, 17:41 | #2 |
Senior Member
Iscritto dal: Jan 2008
Messaggi: 8406
|
Beh il suggerimento piu' ovvio e' quello di studiare Java e la sua standard library.
Li' c'e' praticamente scritto l'algoritmo in maniera dettagliatissima. Una conoscenza di base di Java e' quanto ti manca per realizzare il codice. |
21-08-2017, 21:33 | #3 |
Junior Member
Iscritto dal: Aug 2017
Messaggi: 20
|
Grazie per il suggerimento .... ma non è che mi sia molto utile .
Io sono ancora uno studente e non riesco proprio a capire e più o meno mi è chiaro cosa devo fare. L'unica cosa che non riesco a capire è questo passaggio : Codice:
d[t[i]] = s[i] |
22-08-2017, 08:18 | #4 | |
Senior Member
Iscritto dal: Aug 2017
Messaggi: 469
|
Quote:
Non so cosa sia il template ma da come lo usa sembra una sorta di stringa da usare come riferimento. Quindi usa quella lettera del template (t[i]) come indice per il nuovo elemento del dizionario (d[t[i]]), il dizionario potrebbe essere un semplice array. |
|
22-08-2017, 09:19 | #5 | |
Senior Member
Iscritto dal: Jan 2008
Messaggi: 8406
|
Quote:
E' pressoche' impossibile che tu possa implementare quello pseudo-codice in Java, se ti risultano sconosciute le strutture dati basilari. |
|
24-08-2017, 19:09 | #6 |
Junior Member
Iscritto dal: Aug 2017
Messaggi: 20
|
In effetti le sto studiando ora ti devo dire la verità ma già che mi avete detto che è un ash table posso usare la classe della libreria standard di java giusto ?
Forse ho capito come risolverlo ora Grazie mille ho altri dubbi posso contnuare a chiedere qui o apro un nuovo tread ? |
24-08-2017, 20:21 | #7 |
Junior Member
Iscritto dal: Aug 2017
Messaggi: 20
|
ho provato a scriverlo come mi sembra sia scritto ho usato un hashMap di caratteri ma dove sto sbagliando ?
Codice:
public boolean cercaParola(String schema){ lettera = parola.toCharArray(); lunghezza = parola.length(); char[] caratteriSchema= schema.toCharArray(); mSchema = new HashMap(); for (int i = 0 ; i < lunghezza ; i++){ mSchema.put(lettera[i], null); if(Character.isUpperCase(lettera[i])&& caratteriSchema[i]!= lettera[i]){ return false; }else if (!mSchema.containsKey(lettera[i])){ mSchema.put("",caratteriSchema[i]); }else if (caratteriSchema[i]!= mSchema.get(lettera[i])) return false; } return true; } |
25-08-2017, 14:08 | #8 | |
Senior Member
Iscritto dal: Oct 2005
Messaggi: 3305
|
Quote:
La risposta alla tua domanda dovrebbe essere evidente! Perchè aggiungi sempre al dizionario il carattere lettera[i]? E perchè utilizzi stringa vuota come chiave? Anche se quel pezzo di codice non verrà mai eseguito... Ultima modifica di tomminno : 25-08-2017 alle 14:12. |
|
26-08-2017, 16:10 | #9 |
Junior Member
Iscritto dal: Aug 2017
Messaggi: 20
|
La verità ? è che non so nemmeno quello che ho fatto....
la mia idea è quella di riempire la mappa solo con uno schema che viene letto dal metodo . Ma quello che dovrebbe fare il metodo sarebbe verificare se una lettera è una chiave o una lettera di una parola .... cioè se la lettera è maiuscola allora è una chiave e se la lettera è minuscola è la componente vera e propria della parola . In pratica attraverso questo metodo io dovrei verificare quali stringhe corrispondono allo schema dato. Come implemento la mappa per effettuare questa verifica ? cosa devo fare ? Ultima modifica di stev809 : 26-08-2017 alle 16:56. |
26-08-2017, 16:49 | #10 |
Senior Member
Iscritto dal: Jan 2008
Messaggi: 8406
|
Francamente a me pare assurdo pure lo pseudo-codice. Il primo if causa l'uscita della procedura ogni qualvolta t[i] sia minuscolo e diverso da s[i], cosa che dovrebbe accadere abbastanza spesso.
Poi non e' nemmeno chiaro che vada a fare quella procedura. Cioe' mentre si enumera su s[i] ( visto che si usa n ), in realta' si sta operando su t[i]. E length(t) = length(s) sempre? Credo sia irrealistico. Per cui l'intero for sarebbe sbagliato. L'implementazione pure e' sbagliata. Perche' mSchema.put(lettera[i], null)? Lo pseudo-codice dice che t[i] va inserito nel dizionario solo se manca, tu invece lo inserisci ad ogni iterazione e peggio ancora gli accoppi un valore null. Esattamente quello pseudo-codice da dove e' venuto fuori? |
26-08-2017, 23:26 | #11 | |
Junior Member
Iscritto dal: Aug 2017
Messaggi: 20
|
Quote:
Una parola è una sequenza finita di lettere minuscole Uno schema è una sequenza finita di caratteri appartenenti all alfabeto {a,b,c,.....z} U {A,B,C....Z}. Le lettere maiuscole rappresentano delle variabili su cui agisce la funzione di assegnamento. Un assegnamento è una funzione "SIGMA" da {A,B,C,...Z} a {a,b,c,....} (ossia, a ogni lettera maiuscola l' assegnamento associa una lettera maiuscola). Dato uno schema W = "alfa"1 ......"alfa"n e un assegnamento "SIGMA",indichiamo con "SIGMA"(W) la parola w= "BETA"1...."BETA"n tale che , per ogni 1<=i<=n, se "ALFA"i è una lettera minuscola allora "BETA"i = "SIGMA"("ALFA"i), se "ALFA"i è una lettera minuscola allora "BETA"i = "ALFA"i. Una parola w è un istanza di uno schema W se esiste un assegnamento "SIGMA" tale che w= "SIGMA"(W). |
|
27-08-2017, 09:40 | #12 |
Senior Member
Iscritto dal: Jan 2008
Messaggi: 8406
|
Gli Alfa e i Beta chi sarebbero? Caratteri ascii?
In sostanza il succo sarebbe: 1. parola = sequenza di lettere minuscole 2. schema = sequenza di lettere minuscole e maiuscole La chiarezza finisce qui pero'. Se SIGMA e' una funzione da {A,B,C,...Z} a {a,b,c,....}, significa che mappa caratteri maiuscoli in caratteri minuscoli, cioe' e' la funzione lowercase delle stringhe. La riga successiva dice che presa una stringa, la scorri carattere per carattere e vai a vedere se quel carattere e' maiuscolo nello schema. Se si lo trasformi in maiuscolo anche nella stringa, altrimenti lo trasformi in minuscolo tramite SIGMA. L'ultima riga genera ancora piu' confusione, perche' dicendo che w e' un membro di W, mi fa pensare che W sia un'insieme di stringhe e non una sorta di stringa. |
27-08-2017, 10:09 | #13 |
Junior Member
Iscritto dal: Aug 2017
Messaggi: 20
|
No guarda ...
le lettere maiuscole non le trasformi in minuscole ma le associ a minuscole ti faccio un esempio Se hai la parola "acca" lei è un istanza di: "aBBa" dove B corrisponde alla lettera "c" "aCBa" dove sia B che C corrispondono a "c" "XYZT" dove X e T corrispondono ad "a" e ,Y e Z corrispondono a "c" Lo svolgimento mi è chiaro quello che non mi è chiaro è come devo implementare la mappa . |
27-08-2017, 11:00 | #14 |
Senior Member
Iscritto dal: Jan 2008
Messaggi: 8406
|
Non vedo pero' da dove quelle associazioni vengano fuori. Sono memorizzate nel dizionario mi pare di capire, ma e' la procedura per generarle che e' alquanto nebulosa.
La HashMap comunque richiede solo l'uso di put(chiave, valore). Per verificare se una chiave e' gia' presente nella HashMap puoi usare containsKey(chiave), che restituisce true se gia' presente. Questo e' quello che si puo' dire guardando allo pseudocodice. L'unico punto in cui s'interagisce con la HashMap e' questo Codice:
if t[i] non nel dizionario d d[t[i]] = s[i] |
27-08-2017, 11:37 | #15 |
Junior Member
Iscritto dal: Aug 2017
Messaggi: 20
|
Ok col metodo put aggiungo alla mappa chiave e valore ....Ma la mia domanda è che chiavi e che valori devo aggiungere ?
Cioè ho le due stringhe da confrontare e le aggiungo lettere per lettera alla mappa una come chiave e una come valore ? E questo che mi manda in pappa il cervello e non riesco a capire . |
27-08-2017, 12:01 | #16 |
Junior Member
Iscritto dal: Aug 2017
Messaggi: 20
|
Secondo te così puo andare bene ?
Codice:
public boolean cercaParola(String schema){ char[] arrParola = parola.toCharArray(); lettera = schema.toCharArray(); //confronto se la lunghezza delle parole è uguale : if(arrParola.length!= lettera.length)return false; for(int i = 0; i < lettera.length; i++){ //verifico se le lettere minuscole corrispondono if(Character.isLowerCase(lettera[i])&& lettera[i]!= arrParola[i]){ return false; } //controllo che sia una chiave if(Character.isUpperCase(lettera[i])){ for(int j = i ;j< lettera.length; j++){ //Controllo che non vengano occoppiate 2 lettere alla stessa chiave; if(arrParola[i]!=arrParola[j] && lettera[i]==lettera[j]){ return false; } } // assegno allo schema la lettera corrispondente lettera[i]= arrParola[i]; } } return true; } Ultima modifica di stev809 : 27-08-2017 alle 12:55. |
27-08-2017, 16:24 | #17 | ||
Senior Member
Iscritto dal: Jan 2008
Messaggi: 8406
|
Quote:
Codice:
d[t[i]] = s[i] Quote:
1. t e s devono avere la stessa lunghezza 2. s[i] dev'essere una lettera maiuscola 3. vale solo una volta, cioe' se la lettera t[i] sta gia' nel dizionario, anche se t[k] = t[i] = s[k], comunque la coppia t[k],s[k] non viene aggiunta al dizionario |
||
27-08-2017, 19:16 | #18 |
Junior Member
Iscritto dal: Aug 2017
Messaggi: 20
|
che dici così puo andare ?
Codice:
public boolean cercaParola1(String schema){ char[] letteraParola =parola.toCharArray(); char[] letteraSchema =schema.toCharArray(); HashMap<Character,Character> mSchema = new HashMap<>(); // controllo lunghezza stringhe if(letteraParola.length!= letteraSchema.length) return false; for(int i= 0 ; i< letteraSchema.length; i++){ // confronto lettere tra schema e parola se la lettera dello schema è minuscola if(Character.isLowerCase(letteraSchema[i])&& letteraSchema[i]!= letteraParola[i]){ return false; }else //aggiunta di chiave e valore alla mappa se non presente if (!mSchema.containsKey(letteraSchema[i])){ mSchema.put(letteraSchema[i],letteraParola[i]); }else // se la chiave è presente nella mappa allora verifico se i valori corrispondono if(mSchema.get(letteraSchema[i])!=letteraParola[i] ){ return false; } } return true; } |
28-08-2017, 10:09 | #19 |
Senior Member
Iscritto dal: Jan 2008
Messaggi: 8406
|
Come traduzione di quello pseudo-codice si. Ma come logica no. Usare letteraSchema.length significa che la parola non puo' essere piu' corta, altrimenti letteraParola[i] si ha un errore out of range.
|
28-08-2017, 14:39 | #20 |
Junior Member
Iscritto dal: Aug 2017
Messaggi: 20
|
Ma il problema della lunghezza non sussiste ... Perchè viene verificato a priori , cioè le stringhe devono avere la stessa lunghezza se una è lo schema dell altra quindi non importa se il ciclo termina con la fine di una o dell altra perchè sono della stessa lunghezza
|
Strumenti | |
|
|
Tutti gli orari sono GMT +1. Ora sono le: 08:25.