La clase QuadCurve2D "Curva de Bezier"

La clase QuadCurve2D de Java2D nos permite dibujar una curva basado en ecuaciones matematicas, esta curva tambien se la conoce con el nombre de Curva Cuadratica de Bezier.

Esta curva funciona de la siguiente manera: Se establecen dos puntos (P1 y P2) que establecen los extremos de un segmento curvo, y tambien se define un tercer punto (Punto de Control) el cual nos permite DEFORMAR la curva

La ecuacion con la cual se generan los diferentes puntos que forman la curva es:
 

 El valor de (t) va de 0 hasta 1, donde para un valor de 0 corresponde a las coordenadas de P1 y para un valor de 1, equivale a P2

Proyecto:

Porque se aprende mejor haciendo, dejo la teoria de las matematicas para su propia investigacion, lo que ahora haremos en este tutorial, sera construir una aplicacion en netbeans donde dibujaremos la curva QuadCurve2D, de dos maneras, una de ellas utilizando la clase propia de Java2D y la segunda donde haremos uso de la formula escrita mas arriba, asi podremos apreciar como java2d construye esta figura. Manos a la obra.

1. Crea un nuevo proyecto en Netbeans, Añade un nuevo JFrame: Interfaz y una clase nueva , llamala "miPaint.java", al JFrame interfaz, añadele los siguiente objetos, no te olvides de cambiarle los nombres como en la imagen:

2. A la clase miPaint.java añade el codigo:

01 import java.awt.BasicStroke;
02 import java.awt.Color;
03 import java.awt.Dimension;
04 import java.awt.Font;
05 import java.awt.Graphics;
06 import java.awt.Graphics2D;
07 import java.awt.geom.Line2D;
08 import java.awt.geom.Point2D;
09 import java.awt.geom.QuadCurve2D;
10 import java.text.NumberFormat;
11 import javax.swing.JOptionPane;
12 import javax.swing.JPanel;
13 /**
14  * @web http://jc-mouse.blogspot.com/
15  * @author Mouse
16  */
17 public class miPaint extends JPanel {
18     private Point2D Punto1;
19     private Point2D Punto2;
20     private Point2D Punto3;    
21     private Point2D Punto;
22     private boolean band=true;
23     float rango=0.01f;
24     
25     public miPaint(Dimension d){
26       this.setPreferredSize(d);
27       this.setSize(d);
28       this.setVisible(true);
29       this.repaint();      
30       //se crean las coordenas al azar
31       this.Punto1 = new Point2D.Double(getCoordenada(),getCoordenada());            
32       this.Punto2 = new Point2D.Double(getCoordenada(),getCoordenada());            
33       this.Punto3 = new Point2D.Double(getCoordenada(),getCoordenada()); 
34     }
35     //actualiza nuevas coordenadas a los Puntos
36     public void setPoint2D(String x1,String y1,String x2,String y2,String x3,String y3, boolean b){
37         this.Punto1 = new Point2D.Float(Float.valueOf(x1),Float.valueOf(y1));            
38         this.Punto2 = new Point2D.Float(Float.valueOf(x3),Float.valueOf(y3));            
39         this.Punto3 = new Point2D.Float(Float.valueOf(x2),Float.valueOf(y2));            
40         this.band=b;
41     }
42     
43   @Override                   
44   public void paintComponent(Graphics g){
45         super.paintComponent(g);      
46         Graphics2D g2 = (Graphics2D)g;    
47         //grosor de pincel
48         g2.setStroke(new BasicStroke(2.0f));   
49         //color de pincel
50         g2.setColor(new Color(0,0,200));
51         if(band){
52             Dibujar_QuadCurve2D(g2);
53         }else{
54             Dibujar_Bezier(g2);
55         }         
56         this.repaint();
57         Mostrar_Datos(g2);
58    }
59   
60   //dibuja la curva con la funcion de java2d QuadCurve2D
61   public void Dibujar_QuadCurve2D(Graphics2D g2){    
62     g2.draw(new QuadCurve2D.Double(Punto1.getX(), Punto1.getY(), Punto2.getX(), Punto2.getY(), 
63             Punto3.getX(), Punto3.getY()));                           
64   }
65   
66   //dibuja la curva con la funcion de la curva cuadratica de Bezier
67   //(1-t)^2*p1 + 2t(1-t)p2 + t^2*p3
68   public void Dibujar_Bezier(Graphics2D g2){
69         float f1;
70         float f2;        
71         float t=0;          
72         while (t<=1.0){  
73             //obtiene las coordenadas
74             f1 = (float) (((1-t)*(1-t) * Punto1.getX()) + 2 * t * (1 - t) * Punto2.getX() + (t * t) 
75                  * Punto3.getX()); 
76             f2 = (float) (((1-t)*(1-t) * Punto1.getY()) + 2 * t * (1 - t) * Punto2.getY() + (t * t) 
77                  * Punto3.getY());            
78             //crea un punto con esas coordenadas
79             Punto = new Point2D.Float(f1,f2);   
80             //dibuja el punto
81             g2.draw(new Line2D.Double(Punto.getX(),Punto.getY(),Punto.getX(),Punto.getY()));      
82             t = (float) (t + rango);    
83         }      
84         
85   }
86   
87   //
88   public void setRango(String x){
89       if((Float.valueOf(x)<=1)&&(Float.valueOf(x)>0.001)){
90          this.rango=Float.valueOf(x);  
91       }else{
92         JOptionPane.showMessageDialog(this,"Solo valores entre [0.001 y 1.0]");            
93       }
94     
95   }
96   /* metodos auxiliares */
97   
98   //muestra lascoordenas de los puntos P1,P2 Y P3
99   //dibuja las lineas que estos forman
100   private void Mostrar_Datos(Graphics2D g2){
101         g2.setStroke(new BasicStroke(1.0f));
102         g2.setColor(new Color(0,0,0));
103         g2.draw(new Line2D.Double(Punto1.getX(), Punto1.getY(), Punto2.getX(), Punto2.getY()));      
104         g2.draw(new Line2D.Double(Punto3.getX(), Punto3.getY(), Punto2.getX(), Punto2.getY()));      
105         dibuja_coordenada(g2,Punto1.getX(), Punto1.getY(),"Punto 1");
106         dibuja_coordenada(g2,Punto2.getX(), Punto2.getY(),"Punto de Control");
107         dibuja_coordenada(g2,Punto3.getX(), Punto3.getY(),"Punto 2");        
108   }
109   
110    //dibuja las coordenas dadas  un punto P1,P2   
111 private void dibuja_coordenada(Graphics2D g2,double x, double y,String t){       
112     NumberFormat mf = NumberFormat.getInstance(); 
113     mf.setMaximumFractionDigits(2); 
114     g2.setColor(new Color(255,0,0)); 
115     g2.setFont(new Font("Arial", Font.BOLD, 11));
116     g2.drawString(t + " ("+mf.format(x)+","+mf.format(y)+")",(float) (x+4),(float)  (y-10));       
117     g2.setStroke(new BasicStroke(4.5f));   
118     g2.draw(new Line2D.Double(x,y,x,y));      
119    } 
120 
121 //genera un valor al azar
122 private double getCoordenada(){ 
123     return ((Math.random()*350)+50);
124 }
125 
126      
127 }

Esta clase implementamos un nuevo JPanel al cual se le modificar su metodo paintComponent para que pueda dibujar las figuras con Java2D, asi tambien, solo para motivos ilustrativos, tambien se dibujaran las lineas entre P1-P3 y P2-P3 para que se pueda ver las lineas que estas forman  al trazar la curva bezier.

3. Para implementar esta clase en la interfaz, debemos hacer los siiguientes cambios:

01 public class interfaz extends javax.swing.JFrame {
02     miPaint paint;
03     /** Creates new form interfaz */
04     public interfaz() {
05         initComponents();
06         this.setTitle("JAVA2D - QuadCurve2D - [by Mouse]");
07         this.setLocationRelativeTo(null);  
08         paint = new miPaint(jPanel1.getSize());
09         jPanel1.add(paint);        
10     }
11 
12     private void bt_1ActionPerformed(java.awt.event.ActionEvent evt) {                                     
13         paint.setPoint2D(p1x.getText(), p1y.getText(), p2x.getText(), p2y.getText(), pcx.getText(), pcy.getText(),true);
14     }                                    
15 
16     private void bt_2ActionPerformed(java.awt.event.ActionEvent evt) {                                     
17         paint.setPoint2D(p1x.getText(), p1y.getText(), p2x.getText(), p2y.getText(), pcx.getText(), pcy.getText(),false);
18     }                                    
19 
20     private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {                                         
21             paint.setRango(f.getText());
22     }           

OJO: No copies y pegues, chekea donde va cada linea de codigo.

Con esto nuestra pequeña aplicacion estara lista para funcionar


Aqui dejo el codigo fuente en netbeans 6.0

continue reading

Introducción a Java2D

La API Java2D  nos permite tratar figuras, imagenes y texto en dos dimensiones, las posibilidades son casi ilimitadas, desde dibujar figuras basicas (cuadrados, lineas, texto), manipulacion de imagenes e incluso crear animaciones o presentaciones multimedia.

java.awt.Graphics2D: API de java que se extiene de AWT.Graphics

Comenzaremos con una aplicacion sencilla, para esto creamos un nuevo proyecto en Netbeans, "Java2d_Rectangulo" o el nombre que desees, despues añade un JFrame y para poder trabajar con java2d lo primero que debemos hacer es sobreescribir el metodo PAINT, el codigo que debes añadir al Jframe es:

01  @Override
02     public void paint (Graphics g) {
03         //creamos el objeto a dibujar
04         Rectangle2D rectangulo;
05         //pasamos el objeto Graphics a Graphics2D (upcasting)
06         Graphics2D g2 = (Graphics2D)g;
07         
08         /* Rectangulo simple con valores default de java2d */
09         rectangulo = new Rectangle2D.Float(50, 50, 300, 25);
10         g2.draw(rectangulo);
11         
12         /* Rectangulo con borde a color */
13         g2.setColor(Color.GREEN);
14         rectangulo = new Rectangle2D.Float(50, 100, 300, 25);
15         g2.draw(rectangulo);
16         
17         /* Rectangulo con borde a color y tipo de linea mas gruesa */
18         g2.setColor(Color.RED);
19         rectangulo = new Rectangle2D.Float(50, 150, 300, 25);       
20         Stroke pincel = new BasicStroke(5.0f, BasicStroke.CAP_ROUND,
21                             BasicStroke.JOIN_MITER);
22         g2.setStroke(pincel);        
23         g2.draw(rectangulo);
24         
25         /* Rectangulo con relleno  */        
26         g2.setColor(Color.DARK_GRAY);
27         rectangulo = new Rectangle2D.Float(50, 200, 300, 25);        
28         g2.fill(rectangulo);
29                 
30         /* Rectangulo con canal alfa */
31         // dibujamos un rectangulo de color amarillo y encima otro de color rojo
32         // sin transparencia        
33         g2.setColor(Color.YELLOW);
34         rectangulo = new Rectangle2D.Float(150, 240, 100, 50);       
35         g2.fill(rectangulo);
36         g2.setColor(Color.BLACK);
37         rectangulo = new Rectangle2D.Float(150, 240, 100, 50);       
38         g2.draw(rectangulo);
39         g2.setColor(Color.RED);
40         rectangulo = new Rectangle2D.Float(50, 250, 300, 25);                               
41         g2.fill(rectangulo);
42         
43         //aplicando transparencia
44         g2.setColor(Color.YELLOW);
45         rectangulo = new Rectangle2D.Float(150, 310, 100, 50);       
46         g2.fill(rectangulo);
47         g2.setColor(Color.BLACK);
48         rectangulo = new Rectangle2D.Float(150, 310, 100, 50);       
49         g2.draw(rectangulo);        
50         g2.setColor(Color.RED);
51         rectangulo = new Rectangle2D.Float(50, 320, 300, 25);                       
52         AlphaComposite ac = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.5f);                     
53         g2.setComposite(ac);
54         g2.fill(rectangulo);
55         
56         /* por ultimo dibujamos un texto */
57         g2.setColor(Color.GREEN);
58         g2.setFont(new Font("Arial", Font.ITALIC, 24));
59         g2.drawString("Java2D by Mouse", 50, 440);
60 }

Las librerias que hacemos uso son:

01 import java.awt.*;
02 import java.awt.geom.*;
03 import java.awt.image.*;

Como se observa en el codigo, sobreescribimos el metodo PAINT con la instruccion @Override, despues pasamos el objeto Graphics a Graphics2d, y ya podemos comenzar a dibujar los objetos que deseemos.

La imagen de arriba, nos muestra el resultado que obtendremos, para esto hicimos uso del objeto Rectangle2D que nos permite dibujar rectangulos.

Parametros del objeto Rectangle2D(x1,y1,x2,y2)

x1,y1 : especifican la posicion de la esquina Sup. Izq.
x2,y2 : representan el ancho y largo


Tambien haremos uso de los metodos:

draw(): metodo que pinta la figura que se le pasa como parametro
fill(): metod igual al amterior, pero este pinta el relleno
setColor(): nos permite colocar un color a los graficoscon
Stroke : Estable un pincel con el cual pintaremos el contorno de los objetos.
AlphaComposite: Gestiona las transparencias en figuras, texto e imagenes.

drawString(): nos permite dibujar letras

estos objetos y metodos y muchos mas, los veremos en proximos tutoriales.

[actualizado]

Me olvide el codigo fuente ;)

aqui esta

continue reading

Colorear codigo en Blogger + programa portable

Despues de buscar y probar muchas opciones para colorear codigo fuente en blogger sin tener que modificar la plantilla o arriesgarse a que post anteriores que tienen codigo con las etiquetas PRE Y CODE se alteren y queden ilegibles, encontre una alternativa que parece bastante sencilla de usar, es  

Highlight, este es un programa que convierte el codigo fuente en texto con formato, soporta varios lenguajes, esta disponible para windows como linux y lo mejor, es gratis. SI quieres saber mas, visita su web http://www.andre-simon.de

¿COMO USARLO EN BLOGGER?

Paso 1: bajate el programa e instalalo o si prefieres más abajo te dejo un portable que hice.

Paso 2: Con la aplicacion abierta, en la parte superior izquierda, tienes dos pestañas FILE y CLIPBOARD.

File: Esta opcion te permite cargar un archivo que tengas en tu pc, el programa detecta automaticamente el lenguaje.

Clipboard: esta opcion te permite realizar un copy/paste directamente de tu aplicacion IDE.

Configuraciones: esta opcion se encuentra en la parte inferior izquierda

En la pestaña GENERAL, habilita las opciones Add Line Numbers (agrega numeracion a las lineas de codigo), Pad with zeroes (coloca ceros en los numeros), validate input data (valida datos de entrada).
En OUTPUT FORMAT (formato de salida) escoge HTML.

En la pestaña OUTPUT SPECIFIC busca la opcion STYLESHEETS y habilita las opciones EMBED STYLE (CSS) e Inline CSS.

Por ultimo en la pestaña FORMATTING, puedes escoger el color del theme que utilizaras, eso ya depende de los gustos de cada quien, yo me quedo con el formato de visual studio 2008.

Tambien tiene otras opciones interesantes, TAB WIDTH te permite especificar que tamaño en caracteres tendra la tecla TAB, la opcion LINE WRAPPING  especifica el numero de columnas y tambien puedes modificar el tamaño de la fuene y el tipo.

Continuemos, cuando ya tengas el codigo cargado (paso 2), con la opcion FILE, presiona COPY FILE TO CLIPBOARD, si utilizaste la opcion CLIPBOARD, presiona COPY PREVIEW TO CLIPBOARD, abre el notepad y pega ese codigo, no lo pegues directamente en blogger.

Como se ve en la imagen, el programa crea todo el codigo fuente ya formateado, solo nos interesa lo que este entre las etiquetas PRE, borra el resto.

para personalizar un poco mas nuestro codigo, añade este contendor DIV, antes y despues de las etiquetas PRE,  dependiendo de la extension de tu codigo, puedes editar el tamaño HEIGHT de acuerdo a tus necesidades.

01 <div style="overflow: auto; height: 400px; background: none repeat scroll 0% 0% rgb(255, 255, 255);">
02 aqui el codigo
03 </div>

debes tener algo como:

Ahora si, ya puedes pegar este codigo en el editor de blogger

Ejemplos
PHP

01 <?php
02 echo "Hola Mundo";
03 ?>

C#

01 namespace HelloNameSpace
02 {
03       public class HelloWorld
04       {
05             static void Main(string[] args)
06             {
07                   Console.WriteLine("Hola Mundo!");
08 
09             }
10       }
11 }

Java

01 public class HolaMundo
02 {
03     public static void main (String [ ] args)
04     {
05         System.out.println ("Hola mundo");
06      }
07 }

¿Facil no?

La web del program es http://www.andre-simon.de/index.html

También te dejo el portable por si no quieres instalar nada en tu pc, no pesa nada

EXE Portable

Enlace actualizado 18 de enero de 2013

continue reading

Tablas con iText

La API de itext vista en un post anterior que nos permite crear archivos PDF desde java, cuenta con muchas otras opciones para crear estos archivos y darles formato, una de ellas, son las tablas.

Con itex podemos crear tablas sencillas y tambien tablas complejas, estas ultimas necesitas de un planeamiento previo, para que las tablas salgan como nosotros queremos y tenemos pensado.

El objeto para crear una tabla es PdfPTable, al cual podemos especificarle la cantidad de columnas que queremos. para rellenar la tabla, podemos utilizar:
mitabla.addCell("Contenido");

o para mayor control, podemos utilizarla de esta forma:

PdfPCell celda =new PdfPCell (new Paragraph("Historial de Observaciones",
                FontFactory.getFont("arial",   // fuente
                22,                            // tamaño
                Font.BOLD,                   // estilo
                BaseColor.RED)));             // color
mitabla.addCell(celda);

Itext va rellenando la tabla, celda por celda, de izquierda a derecha y de abajo a arriba, de forma secuencial. Aqui puedes encontrar mayor informacion de la API de Itext.

El Codigo:
Esta clase que se llama tablaspdf.java, contiene dos metodos, para crear archivos pdf con tablas, simples y complejas.

01 import com.itextpdf.text.BaseColor;
02 import com.itextpdf.text.Document;
03 import com.itextpdf.text.DocumentException;
04 import com.itextpdf.text.Element;
05 import com.itextpdf.text.Font;
06 import com.itextpdf.text.FontFactory;
07 import com.itextpdf.text.Paragraph;
08 import com.itextpdf.text.pdf.PdfPCell;
09 import com.itextpdf.text.pdf.PdfPTable;
10 import com.itextpdf.text.pdf.PdfWriter;
11 import java.io.File;
12 import java.io.FileNotFoundException;
13 import java.io.FileOutputStream;
14 /**
15  * @web http://jc-mouse.blogspot.com/
16  * @author Mouse
17  */
18 public class tablaspdf {
19     
20     public void tablaspdf() throws DocumentException, FileNotFoundException{         
21         // se crea instancia del documento
22         Document mipdf = new Document();
23         // se establece una instancia a un documento pdf
24         PdfWriter.getInstance(mipdf, new FileOutputStream(new File("e:/pdf/tablas.pdf")));
25         mipdf.open(); // se abre el documento
26             
27         mipdf.addTitle("Tablas con itext"); // se añade el titulo
28         mipdf.addAuthor("jc mouse"); // se añade el autor del documento
29         mipdf.addSubject("ocio"); //se añade el asunto del documento
30         mipdf.addKeywords("jc mouse"); //Se agregan palabras claves                            
31             
32         /* ahora si tablas */           
33         //mipdf.add(Tabla_Simple());
34         mipdf.add(Tabla_compleja());
35         mipdf.close(); //se cierra el PDF               
36         System.out.println("documento pdf creado");
37     }
38     
39     public PdfPTable Tabla_Simple(){    
40         //creamos la tabla con 3 columnas
41         PdfPTable mitablasimple=new PdfPTable(3);
42         //añadimos contenido a las celdas
43         mitablasimple.addCell("Enero");
44         mitablasimple.addCell("Febrero");
45         mitablasimple.addCell("Marzo");
46         mitablasimple.addCell("Abril");
47         mitablasimple.addCell("Mayo");
48         mitablasimple.addCell("Junio");
49         mitablasimple.addCell("Julio");
50         mitablasimple.addCell("Agosto");
51         mitablasimple.addCell("Septiembre");
52         mitablasimple.addCell("Octubre");
53         //retornamos la tabla
54         return mitablasimple;        
55     }
56     
57     public PdfPTable Tabla_compleja(){ 
58         //creamos una tabla con 3 columnas
59         PdfPTable mitablacompleja=new PdfPTable(3);
60         //añadimos texto con formato a la primera celda
61         PdfPCell celda =new PdfPCell (new Paragraph("Historial de Observaciones",
62                 FontFactory.getFont("arial",   // fuente
63                 22,                            // tamaño
64                 Font.BOLD,                   // estilo
65                 BaseColor.RED)));             // color
66         //unimos esta celda con otras 2
67         celda.setColspan(3);
68         //alineamos el contenido al centro
69         celda.setHorizontalAlignment(Element.ALIGN_CENTER);
70         // añadimos un espaciado
71         celda.setPadding (12.0f);
72         //colocamos un color de fondo
73         celda.setBackgroundColor(BaseColor.GRAY);
74         //se añade a la tabla
75         mitablacompleja.addCell(celda);
76         
77         //fila 2
78         celda = new PdfPCell(new Paragraph ("AUDITORIA DE SISTEMAS"));
79         celda.setColspan(2);
80         celda.setBackgroundColor(BaseColor.GREEN);
81         mitablacompleja.addCell(celda);        
82         celda = new PdfPCell(new Paragraph ("Aprobado"));        
83         celda.setBackgroundColor(BaseColor.LIGHT_GRAY);
84         mitablacompleja.addCell(celda);
85         //fila 3        
86         celda = new PdfPCell(new Paragraph ("COMPILADORES"));
87         celda.setColspan(2);
88         celda.setBackgroundColor(BaseColor.YELLOW);
89         mitablacompleja.addCell(celda);        
90         celda = new PdfPCell(new Paragraph ("Reprobado"));        
91         celda.setBackgroundColor(BaseColor.LIGHT_GRAY);
92         mitablacompleja.addCell(celda);
93         //fila 4        
94         celda = new PdfPCell(new Paragraph ("Prog. Bajo Nivel"));
95         celda.setColspan(2);
96         celda.setBackgroundColor(BaseColor.CYAN);
97         mitablacompleja.addCell(celda);        
98         celda = new PdfPCell(new Paragraph ("Eximido"));        
99         celda.setBackgroundColor(BaseColor.LIGHT_GRAY);
100         mitablacompleja.addCell(celda);
101         //fila 5
102         mitablacompleja.addCell("Conclusion");
103         celda = new PdfPCell(new Paragraph ("¡¡¡GET A LIFE!!!"));
104         celda.setHorizontalAlignment(Element.ALIGN_RIGHT);
105         celda.setColspan(2);
106         celda.setBackgroundColor(BaseColor.ORANGE);
107         mitablacompleja.addCell(celda);
108         // se retorna la tabla
109         return mitablacompleja;    
110     }
111 }

El resultado es:

Tabla Simple

Tabla con formato

continue reading

Problema resuelto ACM: 3n+1

El problema dice asi:
PROBLEMA

Considerando el siguiente algoritmo

input n
print n
if n = 1 then STOP
if n is odd then  n <- 3n + 1
else n <- n/2
GOTO 2

Teniendo la entrada 22, la siguiente secuencia de números se imprimirán 22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1

El ciclo termina cuando se imprime 1.

Dado un numero "n" de entrada, es posible determinar el número de números impresos (incluyendo el 1). Para un "n" dado esto se llama el ciclo de longitud de "n". En el ejemplo anterior, la duración del ciclo de 22 es 16.

Para cualquier par de números de i y j que son determinar la duración del ciclo máximo entre estos rangos.

ENTRADA

La entrada consistirá en una serie de pares de números enteros i y j, un par de enteros por línea. Todos los números enteros será inferior a 1.000.000 y mayor que 0.

Usted debe procesar todos los pares de números enteros y para cada par determinar la duración del ciclo máximo sobre todos los enteros incluyendo i y j.

Usted puede asumir que ninguna operación se desborda un entero de 32 bits.

SALIDA

Para cada par de enteros i y j debe imprimir como salida i, j, y la duración del ciclo máximo de enteros entre e incluyendo i y j. Estos tres números deben ser separados por al menos un espacio con los tres números en una línea y con una línea de salida para cada línea de entrada. Los enteros i y j deben aparecer en la salida en el mismo orden en que aparecieron en la entrada y debe ser seguido por la duración del ciclo máximo (en la misma línea).

Ejemplo:

entrada
1 10
100 200
201 210
900 1000

Salida
1 10 20
100 200 125
201 210 89
900 1000 174

[Traducido por San Google] :)

SOLUCION:

public class solucion {
    
   int mayor=1;

   public solucion(int numero1, int numero2){
    //capturamos el valor original de entrada   
    int n1=numero1;
    int n2=numero2;       
    // si n1 > n2 se invierten los valores   
    if(numero1>numero2){int tmp=numero1; numero1=numero2; numero2=tmp;}
        // los numeros deben estar entre 0 y 1000000   
        if (((numero1<=1000000) && (numero1>0))&& ((numero2<=1000000)&& (numero2>0))){
            //comienza el ciclo entre n1 y n2
            for(int i=numero1; i<=numero2;i++){
                //obtenemos el numero total de ciclos para i
                int j = ciclo(i);
                //establecemos el mayor ciclo
                if(j>mayor){
                    mayor=j;
                }
            }
            //muestra la solucion en consola
            System.out.println("Solucion " + n1 + " " + n2 + " " + mayor);
        } 
        else{
            System.out.println("EL rango de datos no es valido");
        }
   }
   
   //metodo que evalua la expresion y retorna el total del ciclo
   private int ciclo(int n){
       //establecemos un contador e 1
        int count = 1;
        //System.out.print("Para [" +n+"] Serie= ");//opcional
        //comenzamos el ciclo
        while(true){            
            //System.out.print(n+" ");//opcional
            //cuando se llegue a 1 se rompe el ciclo
            if(n==1){break;}
            if(!espar(n)){
                n = (3 * n) + 1;
            }
            else{
                n = n / 2;
            }
            count++;
        }        
        //System.out.println(" ciclos: "+ count +" ");//opcional
        return count;
    }
   
    private boolean espar(int n){
        return ((n % 2) == 0);
    }
}

Implementando la clase en el main:

public class Main {
    public static void main(String[] args) {
        new solucion(1,10);
        new solucion(100,200);
        new solucion(201,210);
        new solucion(900,1000);
        
    }
}

Nota: en la clase Solucion.java, tenemos lineas de codigo marcadas como "opcional", estas lineas de codigo solo sirven para ver con mas detalle la solucion del problema, por ejemplo con esas lineas habilitadas para entrada (1,10), tenemos:

Más vale post publicado que cientos preparados.

continue reading