Documentos de Académico
Documentos de Profesional
Documentos de Cultura
5 Strings PDF
5 Strings PDF
IIC1103 Introducci
on a la Programaci
on
Captulo 5: Strings
Resumen te
orico
Los Strings son una secuencia de caracteres, incluyendo letras (may usculas y min
usculas), signos, espacios,
caracteres especiales, etc. En palabras simples, los Strings sirven para guardar palabras, oraciones, etc. En
java los Strings son objetos, tipo String. Al momento de crearlos, la manera m as sencilla es:
Los Strings, al ser objetos, tambien pueden ser inicializados como tales, a traves del constructor:
String s = new String(); // String vacio
String s = new String("Hola"); // String "Hola"
M
etodos de la clase String
La clase String tiene una gran variedad de metodos u
tiles. La lista completa puede encontrarse en la documen-
tacion oficial (http://java.sun.com/j2se/1.4.2/docs/api/java/lang/String.html). A continuaci on explicamos
los metodos que m as se utilizan en este curso.
int length()
Sencillamente, retorna el largo (la cantidad de caracteres) de un String.
boolean startsWith(String s)
Devuelve true si el String comienza con el String s entregado como par ametro. La coincidencia debe ser
exacta (se distingue mayusculas de min
usculas, por ejemplo, y los caracteres con tilde no son iguales a los
que no lo llevan).
String texto = "Hola Juanito!";
boolean b1 = texto.startsWith(""); // true
boolean b2 = texto.startsWith("Hola ") // true
boolean b3 = texto.startsWith("hola Juanito!") // false
boolean b4 = texto.startsWith("Hola Juanito! ") // false
boolean b5 = texto.startsWith("Hola Juanito!") // true
int indexOf(char c)
Devuelve un entero que indica la posicion donde aparece por primera vez el caracter c. Si el caracter no
aparece en todo el String, devuelve -1.
String texto = "Hola Juanito!";
int n = texto.indexOf(o); // 2
int m = texto.indexOf( ); // 5
int p = texto.indexOf(); // 0
int q = texto.indexOf(z); // -1
int indexOf(String s)
Similar al anterior, s
olo que devuelve la posici
on donde aparece por primera vez un determinado String.
String texto = "En la arboleda un arbolito";
int n = texto.indexOf("arbol"); // 6
int m = texto.indexOf("
arbol"); // -1
int p = texto.indexOf("boli"); // 20
int q = texto.indexOf("bol"); // 8
int lastIndexOf(char c), int lastIndexOf(String s), int lastIndexOf(char c, int fromIndex), int
lastIndexOf(String s, int fromIndex)
Como indexOf(char c), pero en vez de buscar la primera aparici on del char c, busca la u
ltima. Retorna -1 si
no lo encuentra. Se definen de manera an
aloga a los anteriores:
boolean equals(String s)
Retorna true cuando ambos String son exactamente iguales. Esto quiere decir que el largo de ambos es el
mismo, y que en cada posici
on encontramos el mismo caracter.
boolean equalsIgnoreCase(String s)
Retorna true cuando ambos String son iguales, sin importar may
usculas y min
usculas.
int compareTo(String s)
Este metodo compara lexicogr aficamente dos String. Parte en el primer par de caracteres hasta encontrar
un par de char distintos. Si encuentra dos caracteres distintos, retorna la diferencia entre ellos (recuerde que
char funciona como un n umero entero). Si uno de los String comienza con el otro, retorna el n umero de
caracteres adicionales que tiene. Si ambos String son iguales, retorna 0.
Fuente de referencia:
http://users.physik.fu-berlin.de/~goerz/blog/wp-content/uploads/2008/09/ascii.gif
Descripci on Representaci
on
Barra invertida \\
Tabulacion horizontal \t
Salto de Lnea \n
Comillas simples \
Comillas dobles \"
Ocupe una palabra para crear un palndrome, por ejemplo auto queda autotua.
Busque una palabra dentro de un texto y la marque con un , por ejemplo auto en Habian muchos
autos queda Habian muchos autos.
Cuente la cantidad de ocurrencias de una palabra en un texto, por ejemplo hola en El gato decia
hola muchas veces al dia, hola, retorna 2.
Criterios de soluci
on
Para rotar la palabra basta con crear un nuevo String (nueva variable) e ir concaten andole las le-
tras de nuestro String original, pero recorriendo el original desde atr
as hacia adelante (for por su
largo/length).
Muy similar al anterior, se puede hacer de dos maneras. Se le puede concatenar el string obtenido con
el metodo anterior o se puede hacer de manera manual.
Para encontrar donde aparece la palabra es claro que hay que ocupar indexOf. Para agregar el la
mejor manera es guardar la posicion donde esta la palabra buscada y ocuparla para separar la oraci on
en dos substrings, uno con todos los caracteres a la izquierda de la posici
on y otro a la derecha. Luego
concatenamos el subtring de la izquierda con un y el substring de la derecha.
Para contar la cantidad de veces que aparece la palabra ocupamos indexOf para ver si est
a, si la posici
on
es distinta de -1 sumamos uno a la cantidad de veces que encontramos la palabra. Es importante cambiar
la posicion desde la que buscamos en nuestro String ya que, o si no, podemos contar infinitas veces la
misma palabra.
return p a l i n d r o m e; // retorno el p a l i n d r o m e
}
if ( pos != -1) {
// A g r e g a m o s " _ "
String t e x t o A M o s t r a r = t e x t o A U s a r. s u b s t r i n g(0 , pos ) + " _ "
+ t e x t o A U s a r. s u b s t r i n g( pos );
Usuario . m e n s a j e C o n s o l a( t e x t o A M o s t r a r);
return true ;
} else {
Usuario . m e n s a j e C o n s o l a( " No fue e n c o n t r a d o el string " + palabra
+ " en el texto " );
return false ;
}
}
Para poder arreglar este dilema, le piden a usted desarrollar los siguientes metodos (utilizando s
olo lo ya
construido):
String substring(int begin, int end) Retorna el substring que va desde la posici on begin
a la posici
on end, inclusive. Devuelve null si existe
alg
un problema con los ndices recibidos.
String toUpperCase() Retorna un string equivalente al actual, pero con
todas las letras convertidas a may usculas. Ignore
caracteres que no pertenezcan al alfabeto ingles.
static valueOf(int i) Retorna el string que representa al entero i.
int indexOf(String str, int from) Retorna el ndice en que se encuentra el string str
en el string actual, o -1 si es que no se encuentra
(o cualquier otro problema). S olo encuentra str a
a partir del ndice from.
Criterios de soluci
on
Metodo substring: Lo primero que debemos hacer es revisar que los par ametros recibidos correspondan
a ndices validos seg
un el largo del String. Si el inicio es menor que cero y el fin mayor que el largo del
String -1 entonces retornamos false. Si no, para obtener un substring, debemos implementar un ciclo
(f or por ejemplo) que recorra el String completo, desde el inicio hasta el fin recibidos como par ametros,
y vaya obteniendo cada char con el metodo charAt y lo vaya concatenando, formando as el substring
a retornar.
Metodo toUpperCase: Para cambiar las letras a may uscula debemos implementar un ciclo que recorra
todo el String obteniendo cada uno de sus caracteres con el metodo charAt. Luego revisamos cada
caracter si es que est
a en minuscula, para esto basta con comparar si se encuentra en el rango de a
a z (recordando que los caracteres estan ordenados en la tabla ASCII). Si est a en min uscula lo que
tenemos que hacer es al inicio de las may usculas A sumarle la distancia del caracter en minuscula al
inicio de las min
usculas a. As, tendremos el mismo caracter pero ahora en may uscula.
Metodo valueOf: Para pasar el valor entero a String tenemos que revisar primero si el n umero es
negativo o positivo. Si el n
umero es negativo tenemos que agregar un gui on - al String resultante.
Luego recorremos el n umero y vamos obteniendo cada uno de sus dgitos (dividiendo el n umero por
10 y obteniendo el resto) y para cada dgito obtenemos el char que corresponde y lo concatenamos al
String que representa el resultado de pasar el n
umero a String.
Metodo indexOf: En este metodo lo que tenemos que hacer es recorrer todo el String, partiendo desde
el inicio ingresado por el usuario. Dentro del ciclo debemos revisar el String ingresado como par
ametro
(el buscado) para revisar cada uno de sus caracteres y compararlos con el String original. As si todos
los caracteres coinciden devolvemos la posici on donde encontramos el primer caracter que fue igual.
/* *
* Retorna un string e q u i v a l e n t e al actual , pero con todas las letras
* c o n v e r t i d a s a m a y u s c u l a. Ignora c a r a c t e r e s que no p e r t e n e z c a n al alfabeto
* ingles
*/
public String t o U p p e r C a s e() {
String res = " " ;
for ( int i = 0; i < length (); i ++) {
char aux = charAt ( i );
if ( a <= aux && aux <= z )
res += ( char ) ( aux + A - a );
else
res += aux ;
}
return res ;
}
/* *
* Retorna el string que r e p r e s e n t a al entero i .
*/
public static String valueOf ( int i ) {
if ( i == 0)
return " 0 " ;
boolean negative = false ;
if ( i < 0) {
negative = true ;
i = -i ;
}
String res = " " ;
while ( i > 0) {
res = " " + ( char ) ( i % 10 + 0 ) + res ;
i /= 10;
}
if ( negative )
res = " -" + res ;
return res ;
}
/* *
* Retorna el indice en que se e n c u e n t r a el string str en el string actual ,
* o -1 si es que no se e n c u e n t r a ( o c u a l q u i e r otro problema ). Solo
* e n c u e n t r a str a a partir del indice from .
*/
public int indexOf ( String str , int from ) {
for ( int i = from ; i < length (); i ++) {
for ( int j = 0; ( i + j < length ())
&& charAt ( i + j ) == str . charAt ( j ); j ++) {
if ( j == str . length () - 1)
return i ;
}
}
return -1;
}
MULTI;Marcos-Karen-Marcelo-Rosa
PC;Marcos
Para el primer texto su programa debiera iniciarse en modo Multi usuario para cuatro jugadores, con los
nombres ah descritos.
En caso de ingresarse el segundo texto, su programa debiera inicializarse en modo versus PC, con un u
nico
usuario llamado Marcos.
Criterios de soluci
on
Se nos pide reconocer un texto ingresado por el usuario. Como datos nos dan que los separadores son ;
y -, para ello nuestro programa tiene que ser capaz de buscar el car
acter ; (charAt()), en una primera
instancia para poder realizar la separaci
on. Luego se nos pide verificar que la primera parte corresponda
a MULTI, PC o DEMO (validaci on con equals). Con la segunda parte de esta divisi on hacemos lo
mismo que al principio y separamos por -, verificando que la cantidad de jugadores ingresados corresponda
a la se
nalada segun el enunciado.
Posible soluci
on
import i i c 1 1 0 3 P a c k a g e .*;
public class P r i n c i p a l {
Criterios de soluci
on
Observamos que esta es una validacion simple, s
olo debemos verificar que los caracteres sean n
umeros, signo
negativo, o separadores validos, adem
as de que solo exista un separador.
Adicionalmente podemos hacer el metodo que transforme las comas en puntos, para que Java pueda manejar
el n
umero.
Posible soluci
on
import i i c 1 1 0 3 P a c k a g e .*;
public class P r i n c i p a l {
public static void main ( String [] args ) {
while ( true ) {
String x = Usuario . texto ( " Ingrese el decimal a validar " );
if ( esDouble ( x )) {
x = r e m p l a z a r( x );
double numero = Double . p a r s e D o u b l e( x );
Usuario . mensaje ( " El numero i n g r e s a d o es : " + numero );
break ;
}
}
}
charAt, length
Criterios de soluci
on
Lo primero que debemos hacer es identificar cu al es la operaci
on que se encuentra en el String. Para esto
utilizamos un ciclo (un f or por ejemplo), para recorrer todo el String e ir obteniendo cada uno de los
caracteres con el metodo charAt. Cada caracter lo comparamos con una de las posibles operaciones. Al
encontrar la operaci
on guardamos el caracter y tambien la posicion donde la encontramos para luego obtener
los numeros que vienen en el String.
Para recuperar los n
umeros del String, como solo podemos utilizar el metodo charAt, lo que hacemos son dos
ciclos, uno que recorra la primera parte del string obteniendo cada uno de los caracteres y concaten andolos
en un nuevo String que represente el primer n umero, y el segundo ciclo que haga lo mismo pero con la
segunda parte del String.
Luego transformamos los Strings que representan a los n umeros en variables de tipo double y revisando la
operacion encontrada retornamos el resultado de la operaci on.
Posible soluci
on
public double O p e r a c i o n( String op ) {
// Debemos i d e n t i f i c a r cual es la o p e r a c i o n que se e n c u e n t r a en el String
char opDada = 0;
int posOp = 0;
for ( int i = 0; i < op . length (); i ++) {
if ( op . charAt ( i ) == + || op . charAt ( i ) == -
|| op . charAt ( i ) == * || op . charAt ( i ) == / ) {
opDada = op . charAt ( i );
posOp = i ;
break ;
}
}
if ( opDada == + ) {
return valor1 + valor2 ;
} else if ( opDada == - ) {
return valor1 - valor2 ;
} else if ( opDada == * ) {
return valor1 * valor2 ;
} else {
return valor1 / valor2 ;
}
}
Escriba un metodo que permita determinar si una palabra es abecedaria. El metodo debe recibir un string
como parametro y retornar verdadero en caso que la palabra sea abecedaria, y falso en caso contrario. Para
esto puede ocupar s
olo los siguientes metodos de la clase String:
Criterios de soluci
on
Para revisar si la palabra es abecedaria tenemos que ir revisando cada uno de los caracteres y ver que ninguno
sea mayor (lexicogr aficamente) que el siguiente. Para eso lo mejor es utilizar un ciclo, un f or por ejemplo,
para recorrer la palabra entera, caracter por caracter. Utilizando el metodo charAt obtenemos el caracter
actual y el siguiente y comparamos si el actual es mayor que el siguiente. Si esto ocurre retornamos false, de
lo contrario seguimos revisando el resto de la palabra.
Adem as de esto tenemos que considerar que pueden haber caracteres en may uscula, los cuales para que lo
anterior funcione debemos pasarlos a min uscula. Para esto simplemente le restamos el inicio de las letras
may usculas (A) y le sumamos el inicio de las letras min
usculas (a).
Posible soluci
on
public class Palabra {
if ( p r i m e r a L e t r a > s e g u n d a L e t r a)
return false ;
}
return true ;
}
}
Criterios de soluci
on
Lo primero que debemos hacer es declarar la clase Combinacion con dos atributos de tipo String. Luego
debemos crear el constructor, el cual reciba dos Strings como par
ametros y los asigne a los atributos
correspondientes.
Para el metodo encargado de contar las apariciones de un char entregado como par ametro, lo que
tenemos que hacer es un ciclo (f or por ejemplo) que recorra ambos Strings y vaya comparando cada
uno de sus caracteres, utilizando el metodo charAt e ir contando en una variable cuantas veces el
caracter es igual al recibido como par
ametro.
Para el metodo que intercale ambos Strings lo que tenemos que hacer es nuevamente implementar un
ciclo que vaya recorriendo cada String y obteniendo uno a uno sus caracteres con el metodo charAt.
As se concatena un caracter del primer String seguido de un caracter del segundo. En este metodo
tenemos que revisar siempre que el String aun no se acabe ya que puede ocurrir que uno sea mas largo
que el otro, en tal caso simplemente intercalamos hasta que se termine el menor y luego concatenamos
el resto del mayor.
Para el metodo que compara dos substrings de los textos debemos primero obtener los substrings seg
un
los datos de inicio y fin recibidos como parametros. Para esto implementamos ciclos que recorran los
strings desde el inicio hasta el fin recibidos como parametros y vayan formando los dos substrings,
concatenando los caracteres que se obtienen utilizando el metodo charAt. Luego utilizando el metodo
equals o compareT o, revisamos si son iguales, y retornamos true o false seg
un corresponda.
Para el metodo que reemplace un char por otro lo que podemos hacer es implementar un ciclo que
recorra ambos textos y que vaya obteniendo, con el metodo charAt, cada uno de los caracteres. Revi-
samos el caracter comparando si es igual al que se quiere reemplazar. Si es as, concatenamos el nuevo
char, si no lo es, concatenamos el char original, formando as el texto con los caracteres reemplazados.
Criterios de soluci
on
Segun el enunciado, primero debemos pedir al usuario el mensaje a codificar y un numero (lo llamaremos base
del codigo). Dados estos n
umeros debemos obtener el valor de cada letra (s olo las letras) en la tabla ASCII,
y sumarle la base. Luego imprimiremos el mensaje, para mostrar el mensaje codificado. Para decodificar el
mensaje el procedimiento es inverso, debemos restar la base, pero considerando que cambiaron los extremos
en que los caracteres corresponden a letras (se suma la base a cada extremo). Adem as debemos decodificar
el mensaje con una base distinta, para mostrar que se requiere de esta para poder realizar la operaci on.
Posible soluci
on
import i i c 1 1 0 3 P a c k a g e .*;
public class P r i n c i p a l {
_o_a ____o .
Por simplicidad puede suponer que tanto el mensaje secreto, como las letras ingresadas por el usuario, son
en minuscula.
Criterios de soluci
on
El enunciado nos da pocas restricciones, salvo el mensaje y la cantidad de intentos. Pero sabemos que
debemos validar que el usuario ingrese s olo una letra, comparar si corresponde a alguna(s) de la palabra
secreta, y de ser as cambiarla. Repetir esto mientras no haya ganado (descifrado la palabra completa) o
perdido (alcanzado el m aximo de errores permitidos).
Posible soluci
on
import i i c 1 1 0 3 P a c k a g e .*;
public class P r i n c i p a l A h o r c a d o {
/* * * Programa para jugar el juego del Ahorcado */
public static void main ( String [] args ) {
String p a l a b r a C l a v e = " hola mundo " ; // palabra clave e s t a b l e c i d a
int intentos = 3; // cantidad de intentos e s t a b l e c i d o s
// creamos un objetos de la clase Ahorcado
Ahorcado a1 = new Ahorcado ( palabraClave , intentos );
// m o s t r a m o s el mensaje inicial
Usuario . mensaje ( " B i e n v e n i d o! "
+ " \ nIntente adivinar la palabra secreta . Tiene " + intentos
+ " intentos " );
// ciclo del juego ( mientras pueda seguir jugando )
while ( a1 . s e g u i r J u g a n d o ()) {
// mostrar lo que lleva
Usuario . mensaje ( " Hasta ahora lleva : " + a1 . g e t P a l a b r a A c t u a l ());
// g u a r d a r e m o s la letra que ingrese el usuario
String palabra = " " ;
// v e r i f i c a m o s que sea solo una letra
while ( palabra . length () != 1) {
palabra = Usuario . texto ( " Ingrese la letra que quiere d e s c u b r i r: " );
}
// tomamos el primer caracter del string
char c = palabra . charAt (0);
// p r e g u n t a r si esta en la palabra secreta
a1 . p r e g u n t a r L e t r a( c );
}
// fuera del while ( se acabo el juego )
// vemos si gano
if ( a1 . gano ()) {
// m o s t r a m o s el mensaje de f e l i c i t a c i o n
Usuario . mensaje ( " F e l i c i t a c i o n e s! Ha d e s c u b i e r t o la palabra secreta " );
} else {
// perdio , m o s t r a m o s el mensaje avisando
Usuario . mensaje ( " Ha perdido . " + " \ n La palabra era : "
+ a1 . g e t P a l a b r a C l a v e());
}
}
}
// Otros ...
// metodo que d e t e r m i n a si la letra esta en la palabra clave
public void p r e g u n t a r L e t r a( char c ) {
if ( this . p a l a b r a C l a v e. contains ( c + " " )) {
d e s c u b r i r L e t r a( c );
} else {
this . i n t e n t o s F a l l i d o s ++;
}
}
// d e t e r m i n a si gano
public boolean gano () {
return this . p a l a b r a C l a v e. equals ( this . p a l a b r a A c t u a l);
}
}
Criterios de soluci
on
Es realmente facil. Debemos revisar cada letra: si es una vocal se repite como dice el enunciado, y cualquier
otro caracter se deja igual, salvo la y que se considerar a como vocal, siempre y cuando lo que siga no
sea una vocal (en este caso, hay que cuidar que no pasemos el largo del string).
2 http://es.wikipedia.org/wiki/Jerigonza
3 la letra y tambi
en ser
a considerada como vocal cuando corresponda, esto es, cuando no anteceda a alguna vocal
public class J e r i g o n z a {
/* *
* Programa que escribe el texto i n g r e s a d o por el usuario como J e r i g o n z a.
* ( se asume que no ingresa ningun tipo de tilde )
*/
public static void main ( String [] args ) {
String texto = Usuario . texto ( " Ingrese el texto a J e r i g o n z a r" );
String cambiado = cambiar ( texto );
Usuario . mensaje ( cambiado );
}
Criterios de soluci
on
Primero debemos tener en cuenta que este mecanismo s olo toma en consideracion las 26 letras del abecedario,
sin considerar la n. Luego, debemos sumar 13 posiciones a cada car acter; si se pasade la z, volvemos a la
a. Como sabemos que lo char se pueden operar como si fueran enteros, basta con sumar 13 a cada char del
String.
Un punto muy importante es darse cuenta de que el mecanismo para descifrar es exactamente el mismo que
para cifrar, por lo tanto no hace falta replicar el c
odigo sino que simplemente el metodo descifrar(..) hara un
llamado al metodo cifrar(..).
// Declaro un metodo con nombre " cifrar "; retorna una variable de tipo
// String y recibe como a r g u m e n t o otro String .
public static String cifrar ( String msg ) {
// Agrego x al r e s u l t a d o.
msgRot13 += x ;
}
// Retorno el String cifrado .
return msgRot13 ;
}
Su clase debe proveer de un metodo constructor que reciba como parametro la cantidad que se debe
sumar o restar a cada una de letras para codificar o decodificar un mensaje. El constructor debe verificar
que el valor recibido sea un entero mayor o igual que 0, y menor o igual que 26. El constructor adem as
debe ser capaz de establecer si fue creado en forma exitosa para que cuando el objeto sea utilizado
para codificar o decodificar, se pueda determinar si la operaci on se puede ejecutar o no.
Escriba un metodo que permita codificar y decodificar un mensaje. El metodo recibe como parametro
el mensaje y un boolean que indica si se desea codificar (true) o decodificar (false). El metodo retorna
un String con el mensaje codificado o decodificado seg un sea el caso. En caso que el objeto codificador
no haya sido inicializado en forma exitosa retorna el mensaje #ERROR#.
Criterios de soluci
on
Lo primero que debemos hacer, como nos indica el enunciado, es implementar el constructor de la clase. Este
debe recibir el numero que se sumar a y restar
a para encriptar y desencriptar y guardarlo como atributo.
Adem as, como debemos mostrar si el objeto pudo ser creado con exito, y el constructor no puede retornar
nada, agregamos otro atributo a la clase que indique si el objeto se cre
o bien o no.
Para el metodo encriptar lo que primero tenemos que hacer es revisar si el objeto se cre o con exito. Si
no fue as retornamos el mensaje de error. Luego tenemos que determinar si el usuario desea encriptar o
desencriptar, para saber si sumar o restar a cada caracter. A continuaci
on, debemos sumar (o restar) tantas
posiciones como valor determinado por el usuario en el constructor, a cada caracter; si se pasade la z,
volvemos a la a. Como sabemos que los char se pueden operar como si fueran enteros, basta con sumar (o
restar) la cantidad adecuada a cada char del String.
int l l a v e A c t u a l = millave ;
if (! e n c r i p t a r)
l l a v e A c t u a l *= -1;
if ( h a b i l i t a d o)
return e n c r i p t a d o;
Aqu se encuentra la clase principal Encriptador que hace uso de la clase Cypher. Ud. deber
a implementar
todos los metodos de la clase Cypher que son invocados por el Encriptador:
import i i c 1 1 0 3 P a c k a g e .*;
public class E n c r i p t a d o r {
public static void main ( String [] args ) {
Cypher c = new Cypher ();
String msg = Usuario . texto ( " Ingrese el mensaje a e n c r i p t a r" );
// A l g o r i t m o de e n c r i p t a c i o n
String msg2 = c . E n c r i p t a r( msg , n r o _ f i l a s);
Usuario . mensaje ( msg2 );
}
}
Criterios de soluci
on
Metodo QuitarEspacios: En este metodo tenemos que recorrer el String e ir obteniendo cada caracter
con el metodo charAt y revisar si es igual al caracter que representa el espacio. Si no es igual lo
concatenamos al String final. As el String que retornamos no contiene ning
un espacio.
Metodo CuadradoPerfecto: En este metodo tenemos que determinar el n umero de filas (igual al
n
umero de columnas). Para esto utilizamos el metodo Math.sqrt con el largo del String, considerando
que si la raiz no es exacta tenemos que sumar uno al resultado para poder considerar todas las letras
del mensaje.
Metodo Encriptar: Lo primero que tenemos que hacer es revisar si el mensaje ocupa todas las posi-
ciones del cuadrado. De no ser as debemos rellenar los caracteres que faltan con @.
Despues para encriptar lo importante es recorrer bien el String. As, partimos desde el comienzo y con
un ciclo vamos recorriendo todo el String. Dentro de este ciclo implementamos otro, el cual vaya ob-
teniendo los caracteres para concatenar en la respuesta final. Para obtener los caracteres tenemos que
avanzar tantas posiciones como el n umero de columnas tenga el cuadrado, as estaremos recorriendo el
cuadrado leyendo por columna.
// aniadir c a r a c t e r e s extra
while ( s . length () < ( total * total ))
s = s + "@";
// llenar el cuadrado
for ( int i = 0; i < total ; i ++) {
for ( int j = i ; j < s . length (); j = j + total )
r e s p u e s t a = r e s p u e s t a + s . charAt ( j );
}
return r e s p u e s t a;
}
Criterios de soluci
on
Atributos: Lo primero que tenemos que hacer es declarar los atributos de la clase como nos indican
el enunciado. Para esto utilizamos 3 Strings para guardar el nombre de usuario inicial, el nombre real
y el nombre de usuario final. Adem as podemos guardar los nombres y apellidos del usuario en otros
Strings.
Posible soluci
on
import i i c 1 1 0 3 P a c k a g e .*;
public class N o m b r e d e U s u a r i o {
private String n o m b r e R e a l;
private String n o m U s u I n i;
private String n o m b r e U s u a r i o;
private String nombre1 , nombre2 , apellido1 , a p e l l i d o 2;
if ( nom2 . length () == 0) {
n o m b r e R e a l = nombre1 + " " + a p e l l i d o 1 + " " + a p e l l i d o 2;
} else {
n o m b r e R e a l = nombre1 + " " + nombre2 + " " + a p e l l i d o 1 + " "
+ a p e l l i d o 2;
}
}
if ( a p e l l i d o 1. length () >= 6) {
n o m U s u I n i = n o m U s u I n i + a p e l l i d o 1. s u b s t r i n g(0 , 6);
} else {
int k = 6 - a p e l l i d o 1. length ();
n o m U s u I n i = n o m U s u I n i + a p e l l i d o 1 + a p e l l i d o 2. s u b s t r i n g(0 , k );
}
}
En concreto, se le solicita que escriba una clase Decifrador con un constructor que reciba el texto a descifrar
y un metodo descubrirMensaje que entregue como resultado el mensaje descifrado a partir del texto (sin
perjuicio de que adem as agregue todos los atributos y metodos que estime necesarios). De esta manera, su
clase debera poder ser usada de la siguiente forma:
Usuario.mensaje(decifrador.descubrirMensaje());
Criterios de soluci
on
Constructor: Simplemente recibimos como par
ametro un String que represente el mensaje y lo asigna-
mos al atributo de la clase.
Metodo descubrirMensaje: En este metodo recorremos el String buscando el caracter de fin de lnea
(obtenemos cada caracter con el metodo charAt()). Cuando encontramos el salto de lnea obtenemos
el caracter que esta a la izquierda (que sera el u ltimo caracter de la lnea) y el que est
a a la derecha
(que sera el primer caracter de la siguiente lnea). Revisamos si se trata de un caracter especial (como
Posible soluci
on
public class D e s c i f r a d o r {
private String texto ;
Las letras de una palabra tambien van separadas entre s por 1 espacio, al final de la serie de puntos no debe
ir un espacio. Otras consideraciones: la letra K se considera que es una C, la letra N se considera como si
fuera N, se ignora todo otro smbolo fuera de la matriz de claves.
Se pide que implemente el metodo aTap de la clase Cipher que recibe dos Strings, uno contiene el mensaje
original, y el otro un String con los caracteres de la matriz, ambos Strings en may usculas. El metodo aTap
devuelve un String conteniendo la serie de puntos equivalentes en el Tap Code. Note que si recibe como
mensaje un String vaco o nulo, debe retornar el mismo mensaje original sin ning un cambio.
import i i c 1 1 0 3 P a c k a g e .*;
public class P r i n c i p a l {
public static void main ( String [] args ) {
String matriz = " A B C D E F G H I J L M N O P Q R S T U V W X Y Z" ;
Cypher c = new Cypher ();
String mensaje = Usuario . texto ( " Mensaje ? " );
// C o n v i e r t e el mensaje a m a y u s c u l a s
mensaje = mensaje . t o U p p e r C a s e();
Usuario . mensaje ( c . aTap ( mensaje , matriz ));
}
}
Criterios de soluci
on
Lo primero que tenemos que hacer en el metodo aTap es revisar que el String original recibido como par
ametro
no sea vaco. Si es as, simplemente retornamos el mismo String.
Posible soluci
on
public String aTap ( String original , String matriz ) {
if (( original == null ) || original . equals ( " " )) {
return original ;
}
String puntos = " " ;
for ( int i = 0; i < original . length (); i ++) {
String letra = " " + original . charAt ( i );
if ( letra . equals ( " K " )) {
letra = " C " ;
} else if ( letra . equals (" N " )) {
letra = " N " ;
}
int n = -1 , m = -1;
if ( matriz . indexOf ( letra ) >= 0) {
n = matriz . indexOf ( letra ) / 5;
m = matriz . indexOf ( letra ) - n * 5;
}
if ( n >= 0 && n >= 0) {
for ( int j = 0; j <= n ; j ++) {
puntos = puntos + " . " ;
}
puntos = puntos + " " ;
for ( int j = 0; j <= m ; j ++) {
puntos = puntos + " . " ;
}
}
puntos = puntos + " " ;
}
// NO DEBE INCLUIR UN ESPACIO AL FINAL
if ( puntos . length () > 0) {
puntos = puntos . s u b s t r i n g(0 , puntos . length () - 1);
}
return puntos ;
}
Incremento 1
En este primer incremento deber a definir lo b
asico de las clases Familia y Persona, de modo de poder
crearlas. Una Persona esta caracterizada por su nombre, su edad y su genero, el cual se representa con un
0 si es hombre o un 1 en caso que sea mujer. Adem as cada persona tiene sus pasatiempos, los cuales se
representan con un string en el cual se van concatenando los pasatiempos que se van agregando. Su clase
Persona debe cumplir con los usos dados en el main dado, el cual usted no puede modificar.
Por su parte Familia esta caracterizado por los apellidos de la familia y por hasta 5 personas que son los
integrantes de la familia. Al igual que Persona, Familia debe poder ser utilizada con el main predefinido,
por lo que debe coincidir los nombres de los metodos que ah se encuentran as como los par
ametros de cada
uno.
Incremento 2
Ahora que ya est
an creadas las familias, debe agregar los metodos necesarios a sus clases para que sea posible
mostrar en consola cada familia. Una familia se muestra indicando sus apellidos y el nombre, edad y g enero
de cada uno de sus integrantes. Este es un ejemplo de como se muestra una familia en consola:
***************************************************
Familia : Palma S e p u l v e d a
Juan (25 - Hombre )
Maria (43 - Mujer )
Pedro (12 - Hombre )
Pablo (48 - Hombre )
***************************************************
Ademas cada familia debe ser capaz de retorna el promedio de edad de la familia, para que as el main pueda
mostrarlos.
Incremento 3
Por u
ltimo debe ser posible buscar el n
umero de integrantes que tiene un cierto pasatiempo en cada familia.
Pudiendo tambien realizar esta b
usqueda en un genero en particular. Nuevamente debe cumplir con lo defi-
nido en el main.
import i i c 1 1 0 3 P a c k a g e .*;
public class P r i n c i p a l {
public static void main ( String [] args ) {
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Iteracion 1
*/
// Creamos todas las familias con sus r e s p e c t i v a s personas y p a s a t i e m p o s
Familia f1 = new Familia ( " Palma S e p u l v e d a" );
Persona p11 = new Persona (" Juan " , 25 , 0);
p11 . a g r e g a r P a s a t i e m p o( " Futbol " );
p11 . a g r e g a r P a s a t i e m p o( " Piano " );
Persona p12 = new Persona (" Maria " , 43 , 1);
p12 . a g r e g a r P a s a t i e m p o( " Leer " );
Persona p13 = new Persona (" Pedro " , 12 , 0);
p13 . a g r e g a r P a s a t i e m p o( " TV " );
p13 . a g r e g a r P a s a t i e m p o( " Futbol " );
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Iteracion 2
*/
// M o s t r a m o s cada familia
f1 . m o s t r a r F a m i l i a ();
f2 . m o s t r a r F a m i l i a ();
f3 . m o s t r a r F a m i l i a ();
f4 . m o s t r a r F a m i l i a ();
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Iteracion 3
*/
// Buscamos la cantidad de personas con p a s a t i e m p o Futbol en cada
// familia
Usuario . m e n s a j e C o n s o l a( " Personas que les gusta el futbol Familia : "
+ f1 . g e t A p e l l i d o s() + " - "
+ f1 . i n t e g r a n t e s C o n P a s a t i e m p o( " Futbol " ));
Usuario . m e n s a j e C o n s o l a( " Personas que les gusta el futbol Familia : "
+ f2 . g e t A p e l l i d o s() + " - "
+ f2 . i n t e g r a n t e s C o n P a s a t i e m p o( " Futbol " ));
Usuario . m e n s a j e C o n s o l a( " Personas que les gusta el futbol Familia : "
+ f3 . g e t A p e l l i d o s() + " - "
+ f3 . i n t e g r a n t e s C o n P a s a t i e m p o( " Futbol " ));
Usuario . m e n s a j e C o n s o l a( " Personas que les gusta el futbol Familia : "
+ f4 . g e t A p e l l i d o s() + " - "
+ f4 . i n t e g r a n t e s C o n P a s a t i e m p o( " Futbol " ));
// Ahora m o s t r a m o s la cantidad de mujeres que les gusta leer por cada
// familia
Usuario . m e n s a j e C o n s o l a( " Mujeres que les gusta leer Familia : "
+ f1 . g e t A p e l l i d o s() + " - "
+ f1 . i n t e g r a n t e s C o n P a s a t i e m p o P o r G e n e r o( " Leer " , 1));
Usuario . m e n s a j e C o n s o l a( " Mujeres que les gusta leer Familia : "
+ f2 . g e t A p e l l i d o s() + " - "
+ f2 . i n t e g r a n t e s C o n P a s a t i e m p o P o r G e n e r o( " Leer " , 1));
Usuario . m e n s a j e C o n s o l a( " Mujeres que les gusta leer Familia : "
+ f3 . g e t A p e l l i d o s() + " - "
+ f3 . i n t e g r a n t e s C o n P a s a t i e m p o P o r G e n e r o( " Leer " , 1));
Usuario . m e n s a j e C o n s o l a( " Mujeres que les gusta leer Familia : "
+ f4 . g e t A p e l l i d o s() + " - "
+ f4 . i n t e g r a n t e s C o n P a s a t i e m p o P o r G e n e r o( " Leer " , 1));
}
}
Criterios de soluci
on
Clase Persona
Atributos: Declaramos los atributos necesarios seg un nos indican en el enunciado: dos String, uno
para el nombre y otro para los pasatiempos y dos enteros, uno para representar la edad y otro
para representar el genero.
Constructor: Lo declaramos seg un el uso mostrado en la clase Principal. Recibe como par ametros
el nombre, la edad y el genero y los asigna a los atributos correspondientes.
Metodo agragarPasatiempo: Lo declaramos seg un el uso mostrado en la clase Principal. Recibe
como parametro un String con el hobbie a agregar y tenemos que concatenarlo al String que
almacena los pasatiempos.
Getters: Segun el uso dado en la clase Principal necesitamos 3 metodos get para obtener el nombre,
la edad y el genero.
Metodo tienePasatiempo: Este metodo sirve para revisar si la persona tiene un determinado
pasatiempo (para cumplir con lo pedido en el incremento 3), puede hacerse tambien solo en la
clase Familia. Lo que hacemos es buscar el pasatiempo generando todos los substrings desde la
lista de pasatiempos que tengan el mismo largo que el pasatiempo recibido y comparar hasta
encontrar alguna coincidencia.
Metodo mostrar: Revisamos el genero de la persona y seg un eso mostramos en Consola su edad
seguida de Hombre o Mujer seg un corresponda.
Posible soluci
on
import i i c 1 1 0 3 P a c k a g e .*;
public double p r o m e d i o E d a d () {
// D e c l a r a m o s una variable donde a c u m u l a r e m o s
double promedio = 0;
int count = 0;
// R e c o r r e m o s todas las personas
for ( int i = 0; i < 5; i ++) {
Persona p = o b t e n e r P e r s o n a( i );
if ( p != null ) {
// En caso de estar la persona a c u m u l a m o s su edad
promedio += p . getEdad ();
count ++;
}
}
return promedio / count ;
}
public void m o s t r a r F a m i l i a () {
// M o s t r a m o s los a p e l l i d o s y luego a cada una de las personas
Usuario . m e n s a j e C o n s o l a( " * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * " );
Usuario . m e n s a j e C o n s o l a( " Familia : " + a p e l l i d o s);
for ( int i = 0; i < 5; i ++) {
Persona p = o b t e n e r P e r s o n a( i );
if ( p != null ) {
p . mostrar ();
}
}
Usuario . m e n s a j e C o n s o l a( " * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * " );
}
public String g e t A p e l l i d o s () {
return a p e l l i d o s;
}
}
import i i c 1 1 0 3 P a c k a g e .*;
Incremento 1
En este primer incremento deber a definir lo b
asico de las clases Marca y Modelo, para poder crearlas. Un
Modelo esta caracterizado por el nombre del modelo, el a no en que salio al mercado, y el tipo de vehculo
que es, el cual se representa con un 0 si corresponde a un modelo sed an, un 1 si se trata de un station wagon,
y un 2 en caso que sea una camioneta. Adem as cada modelo tiene sus propias caractersticas, las cuales se
representan con un string en el cual se van concatenando las caractersticas que se van agregando al modelo.
Su clase Modelo debe cumplir con los usos dados en el main provisto, el cual usted no puede modificar.
Por su parte, una Marca esta caracterizada por los modelos que componen su lnea de producci on, pudiendo
ser hasta cuatro como m aximo. Al igual que Modelo, la clase Marca debe poder ser utilizada con el main
predefinido, por lo que en su implementaci on deben coincidir los nombres y par ametros de los metodos que
ah se encuentran.
Incremento 2
Ahora que ya estan creadas las marcas y sus modelos, debe agregar los metodos necesarios a sus clases para
que sea posible mostrar en consola el catalogo de cada marca. Para una marca, este cat alogo se muestra
indicando su nombre y, para cada uno de sus modelos, la informaci
on correspondiente al nombre del modelo,
su a
no y su tipo. Por ejemplo, para una de las marcas el mensaje debe mostrarse como el siguiente:
***************************************************
Marca: Hyundai
Accent, 2008, Sedan
Sonata, 2007, Sedan
H-1, 2005, Station Wagon
***************************************************
Adem as, cada marca debe ser capaz de retornar la cantidad de modelos del ano 2008 que posee en su
catalogo, para que as el main pueda mostrar los mensajes correspondientes.
Incremento 3
Por u ltimo, debe complementar sus clases de modo que sea posible imprimir el catalogo de cada marca
solo con los modelos correspondientes a un ano especfico, como tambien buscar el n
umero de modelos que
presenten una cierta caracterstica en cada marca, permitiendo adicionalmente realizar esta busqueda para
un tipo de vehculo en particular. Nuevamente debe cumplir con lo ya definido en el metodo main que se le
entrega al comenzar su trabajo.
public class P r i n c i p a l {
public static void main ( String [] args ) {
/* * I n c r e m e n t o 1 */
// Creamos marcas y a g r e g a m o s modelos con d i s t i n t a s c a r a c t e r i s t i c a s
Marca marca1 = new Marca ( " Hyundai " );
Modelo modelo11 = new Modelo ( " Accent " , 2008 , 0);
modelo11 . a g r e g a r C a r a c t e r i s t i c a( " Llantas " );
modelo11 . a g r e g a r C a r a c t e r i s t i c a( " A l z a v i d r i o s E l e c t r i c o s" );
modelo11 . a g r e g a r C a r a c t e r i s t i c a( " Radio CD " );
modelo11 . a g r e g a r C a r a c t e r i s t i c a( " Mecanico " );
modelo11 . a g r e g a r C a r a c t e r i s t i c a( " Aire A c o n d i c i o n a d o" );
Modelo modelo21 = new Modelo ( " Sonata " , 2007 , 0);
modelo21 . a g r e g a r C a r a c t e r i s t i c a( " Aire A c o n d i c i o n a d o" );
modelo21 . a g r e g a r C a r a c t e r i s t i c a( " A u t o m a t i c o" );
modelo21 . a g r e g a r C a r a c t e r i s t i c a( " N e b l i n e r o s" );
modelo21 . a g r e g a r C a r a c t e r i s t i c a( " A l z a v i d r i o s E l e c t r i c o s" );
modelo21 . a g r e g a r C a r a c t e r i s t i c a( " Radio CD " );
modelo21 . a g r e g a r C a r a c t e r i s t i c a( " Alarma " );
modelo21 . a g r e g a r C a r a c t e r i s t i c a( " Tapiz de cuero " );
modelo21 . a g r e g a r C a r a c t e r i s t i c a( " Air Bag " );
modelo21 . a g r e g a r C a r a c t e r i s t i c a( " D i r e c c i o n Asistida " );
Modelo modelo31 = new Modelo ( "H -1 " , 2005 , 1);
modelo31 . a g r e g a r C a r a c t e r i s t i c a( " Alarma " );
modelo31 . a g r e g a r C a r a c t e r i s t i c a( " Mecanico " );
modelo31 . a g r e g a r C a r a c t e r i s t i c a( " Radio CD " );
modelo31 . a g r e g a r C a r a c t e r i s t i c a( " D i r e c c i o n Asistida " );
marca1 . a g r e g a r M o d e l o( modelo11 );
marca1 . a g r e g a r M o d e l o( modelo21 );
marca1 . a g r e g a r M o d e l o( modelo31 );
/* * I n c r e m e n t o 2 */
// M o s t r a m o s el catalogo completo de cada marca
marca1 . i m p r i m i r C a t a l o g o (0);
marca2 . i m p r i m i r C a t a l o g o (0);
marca3 . i m p r i m i r C a t a l o g o (0);
Usuario . m e n s a j e C o n s o l a( " " );
/* * I n c r e m e n t o 3 */
// M o s t r a m o s el catalogo de cada marca solo con los modelos del anio
// p r e f e r i d o
int anio = Usuario . entero (" Ingrese el anio para el que desea revisar los modelos : " );
marca1 . i m p r i m i r C a t a l o g o( anio );
marca2 . i m p r i m i r C a t a l o g o( anio );
marca3 . i m p r i m i r C a t a l o g o( anio );
Usuario . m e n s a j e C o n s o l a( " " );
Criterios de soluci
on
Clase Modelo
Atributos: Declaramos los atributos necesarios segun nos indican en el enunciado: dos String, uno
para el nombre y otro para las caractersticas y dos enteros, uno para representar el a
no y otro
para representar el tipo (camioneta, sed
an, etc)
Constructor: Lo declaramos seg un el uso mostrado en la clase Principal. Recibe como par
ametros
el nombre, el a
no y el tipo y los asigna a los atributos correspondientes.
Metodo agragarCaracteristica: Lo declaramos seg un el uso mostrado en la clase Principal.
Recibe como par ametro un String con la caracterstica a agregar y tenemos que concatenarlo al
String que almacena las caractersticas.
Getters: Seg
un el uso dado en la clase Principal necesitamos 3 metodos get para obtener el nombre
del modelo, el a
no y el tipo.
Metodo tieneCaracteristica: Este metodo sirve para revisar si el modelo tiene una determinada
caracterstica (para cumplir con lo pedido en el incremento 3), puede hacerse tambien solo en la
clase Marca. Lo que hacemos es buscar la caracterstica generando todos los substrings desde la
lista de caractersticas que tengan el mismo largo que la caracterstica recibida y comparar hasta
encontrar alguna coincidencia.
Metodo mostrar: Revisamos el tipo y seg un eso mostramos en Consola el nombre del modelo, su
ano seguido de Sed an, Station Wagon o Camioneta, seg
un corresponda.
Clase Marca:
Atributos: Declaramos los atributos necesarios segun lo que se nos indica en el enunciado: un
String para guardar el nombre y cuatro objetos de la clase Modelo que representen a los modelos
de auto que tiene la Marca.
Constructor: Lo declaramos seg un el uso mostrado en la clase Principal. Recibe como par ametro
un String con el nombre de la marca y lo asigna al atributo correspondiente.
Metodo agregarModelo: Lo declaramos seg un el uso mostrado en la clase Principal. Recibe como
parametro un objeto de la clase Modelo. Tenemos que revisar a que objeto, de los 4 que tenemos
como atributos, debemos asignarlo, revisando cu al de ellos es todava null. Retornamos true o
false seg
un se pudo o no asignar el modelo.
Metodo getNombre: Retorna el nombre de la marca.
Metodo autosDelAnio: Recorremos todos los modelos y obtenemos su a no (cuidando que el objeto
no sea null) y lo comparamos con el a
no recibido como par
ametro. Retornamos el n
umero de veces
que la comparaci on fue exitosa.
Metodo imprimirCatalogo: Mostramos en la consola el nombre de la marca y el n umero de autos
del a
no (seg
un el par
ametro recibido) llamando al metodo autosDelAnio. Luego, por cada Modelo
llamamos al metodo que muestra su nombre y su tipo.
Metodo modelosConCaracteristica: Para no implementar un metodo dos veces simplemente
llamamos al metodo modelosConCaracteristicaPorTipo definiendo un valor inv
alido para el
tipo.
Posible soluci
on
import i i c 1 1 0 3 P a c k a g e .*;
import i i c 1 1 0 3 P a c k a g e .*;
Incremento 1
En este primer incremento deber a definir lo b
asico de las clases Restaurant y Plato, para poder crearlas.
Un Plato esta caracterizado por su nombre, su precio y su tipo, el cual se representa con un 0 si corresponde
a un plato fro o con un 1 si se trata de un plato caliente. Adem as cada plato tiene sus ingredientes esenciales,
los cuales se representan con un string en el cual se van concatenando los ingredientes que se van agregando
al plato. Su clase Plato debe cumplir con los usos dados en el main provisto, el cual usted no puede
modificar.
Por su parte, un Restaurant esta caracterizado por los platos que componen su men u, pudiendo ser hasta
cinco como m aximo. Al igual que Plato, la clase Restaurant debe poder ser utilizada con el main predefinido,
por lo que su implementaci on debe coincidir con los nombres y par ametros de los metodos que ah se
encuentran.
Incremento 2
Ahora que ya estan creados los restaurantes y sus platos, debe agregar los metodos necesarios a sus clases
para que sea posible mostrar en consola el men u de cada restaurant. El men u de un restaurant se muestra
indicando el nombre de este, el precio promedio de los platos que ofrece y, para cada uno de sus platos, la
informaci
on correspondiente al nombre del plato, su precio y su tipo. Por ejemplo, para uno de los restaurantes
el mensaje debe mostrarse como el siguiente:
***************************************************
Restaurant: Dona Juanita
Precio Promedio de sus platos: $3083.0
Pastel de Choclo, $3500, Caliente
Cazuela de Vacuno, $4550, Caliente
Mote con huesillos, $1200, Frio
***************************************************
Adem as, cada restaurant debe ser capaz de retornar la cantidad de platos en su men
u cuyo precio sea igual
o inferior a $4500, para que as el main pueda mostrar los mensajes correspondientes.
Incremento 3
Por u ltimo, debe complementar sus clases de modo que sea posible imprimir el men u de cada restaurant
solo con los platos cuyo precio no supere un precio determinado (especificado por el usuario), como tambien
buscar el n umero de platos en el menu que presenten un determinado ingrediente en cada restaurant, permi-
tiendo adicionalmente realizar esta busqueda para un tipo de plato en particular. Nuevamente debe cumplir
con lo ya definido en el metodo main que se le entrega.
public class P r i n c i p a l {
public static void main ( String [] args ) {
/* * I n c r e m e n t o 1 */
// Creamos los r e s t a u r a n t e s y a g r e g a m o s platos con d i s t i n t o s
// i n g r e d i e n t e s
R e s t a u r a n t r1 = new R e s t a u r a n t( " Italia Nostra " );
Plato plato11 = new Plato (" E s p a g u e t i a la c a r b o n a r a" , 3890 , 1);
plato11 . a g r e g a r I n g r e d i e n t e( " e s p a g u e t i" );
plato11 . a g r e g a r I n g r e d i e n t e( " tocino " );
plato11 . a g r e g a r I n g r e d i e n t e( " aceite de oliva " );
plato11 . a g r e g a r I n g r e d i e n t e( " huevo " );
plato11 . a g r e g a r I n g r e d i e n t e( " queso p a r m e s a n o" );
plato11 . a g r e g a r I n g r e d i e n t e( " ajo " );
Plato plato21 = new Plato (" Ravioli " , 4980 , 1);
plato21 . a g r e g a r I n g r e d i e n t e( " raviolis " );
plato21 . a g r e g a r I n g r e d i e n t e( " queso ricotta " );
plato21 . a g r e g a r I n g r e d i e n t e( " perejil fresco " );
plato21 . a g r e g a r I n g r e d i e n t e( " huevo " );
Plato plato31 = new Plato (" M a c a r o n e s con jamon " , 4550 , 1);
plato31 . a g r e g a r I n g r e d i e n t e( " m a c a r o n e s" );
plato31 . a g r e g a r I n g r e d i e n t e( " crema " );
plato31 . a g r e g a r I n g r e d i e n t e( " jamon cocido " );
plato31 . a g r e g a r I n g r e d i e n t e( " queso p a r m e s a n o" );
Plato plato41 = new Plato (" Gnoquis con Salsa B o l o n i e s a" , 3200 , 1);
plato41 . a g r e g a r I n g r e d i e n t e( " carne " );
plato41 . a g r e g a r I n g r e d i e n t e( " Gnoquis " );
plato41 . a g r e g a r I n g r e d i e n t e( " z a n a h o r i a" );
plato41 . a g r e g a r I n g r e d i e n t e( " tomate " );
plato41 . a g r e g a r I n g r e d i e n t e( " aceite de oliva " );
Plato plato51 = new Plato (" C i a l d e l l a pullese " , 2950 , 0);
plato51 . a g r e g a r I n g r e d i e n t e( " tomate " );
plato51 . a g r e g a r I n g r e d i e n t e( " aceite de oliva " );
plato51 . a g r e g a r I n g r e d i e n t e( " tostadas i n t e g r a l e s" );
r1 . a g r e g a r P l a t o( plato11 );
r1 . a g r e g a r P l a t o( plato21 );
r1 . a g r e g a r P l a t o( plato31 );
r1 . a g r e g a r P l a t o( plato41 );
r1 . a g r e g a r P l a t o( plato51 );
/* * I n c r e m e n t o 2 */
// M o s t r a m o s el menu completo de cada r e s t a u r a n t
r1 . i m p r i m i r M e n u (0);
r2 . i m p r i m i r M e n u (0);
r3 . i m p r i m i r M e n u (0);
r4 . i m p r i m i r M e n u (0);
Usuario . m e n s a j e C o n s o l a( " " );
Criterios de soluci
on
Clase Plato
Atributos: Declaramos los atributos necesarios seg un nos indican en el enunciado: dos String, uno
para el nombre y otro para los ingredientes y dos enteros, uno para representar el precio y otro
para representar el tipo.
Constructor: Lo declaramos seg un el uso mostrado en la clase Principal. Recibe como par ametros
el nombre, el precio y el tipo y los asigna a los atributos correspondientes.
Metodo agragarIngrediente: Lo declaramos seg un el uso mostrado en la clase Principal. Recibe
como parametro un String con el ingrediente a agregar y tenemos que concatenarlo al String que
almacena todos los ingredientes.
Getters: Segun el uso dado en la clase Principal necesitamos 3 metodos get para obtener el nombre,
el precio y el tipo.
Metodo tieneIngrediente: Este metodo sirve para revisar si el plato tiene un determinado
ingrediente (para cumplir con lo pedido en el incremento 3), puede hacerse tambien solo en la
clase Restaurant. Lo que hacemos es buscar el ingrediente generando todos los substrings desde
la lista de ingredientes que tengan el mismo largo que el ingrediente recibido y comparar hasta
encontrar alguna coincidencia.
Metodo mostrar: Revisamos el tipo del plato y seg un eso mostramos en Consola su nombre y
precio seguido de Fro o Cliente, seg
un corresponda.
Posible soluci
on
import i i c 1 1 0 3 P a c k a g e .*;
public class R e s t a u r a n t {
// D e f i n i m o s los a t r i b u t o s n e c e s a r i o s
private String nombre ;
// D e f i n i m o s los platos que integran el menu del R e s t a u r a n t
private Plato plato0 ;
private Plato plato1 ;
private Plato plato2 ;
private Plato plato3 ;
private Plato plato4 ;