Mostrando entradas con la etiqueta source code. Mostrar todas las entradas
Mostrando entradas con la etiqueta source code. Mostrar todas las entradas

domingo, 2 de febrero de 2014

Cuenta regresiva de minutos y segundos con c++ – Auto – Register – Record



La función de éste programa de consola es permitirnos realizar una cuenta regresiva desde la cantidad de minutos que queramos.
Solo ingresamos la cantidad de minutos que queremos y la cuenta regresiva iniciará, además con cada segundo transcurrido el programa realizará un sonido de alerta (beep).

Codigo fuente:
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include iostream
#include windows.h

using namespace std;

int main(){
int minutos, ii;
cout "Minutos?" endl;
cin minutos;

for(int j=minutos-1 ; j= 0; j--){
ii = 59;
for(int i = ii; i = 0; i--){
system("cls");
cout j ":" i endl;
cout "\a";
Sleep(1000);
}
}
}

Declaramos una variable llamada minutos la cual almacenará la cantidad de minutos que tendrá nuestra cuenta regresiva.
El ciclo for externo se iniciará enminutos - 1 es decir, si ingresamos 1 minuto el for iniciará en 0 y para que éste se ejecute colocaremos j= 0. El ciclo for interno empezará en 59, la cantidad de segundos que tiene un minuto (60) menos 1.
System("cls"); se encargará de limpiar la pantalla con cada segundo transcurrido, y la secuencia de escape \a emitirá un sonido de alerta con cada segundo transcurrido.
Es muy importante la funciónSleep(milisegundos) debido a que ésta determinará el intervalo de tiempo de cada ejecución del for interno, en éste casomil milisegundos = 1 segundo.

La ejecución sería de la siguiente manera:



sábado, 18 de enero de 2014

Aplicación Android Tabla de multiplicar [Código Fuente/Source Code] – Miami – Curso – Credit



En una entrada escribí sobre laAplicación Android Tabla de multiplicar + apk, en ésta ocasión colocaré el código fuente de ésta aplicación, pueden revisarlo para ver como funciona, también modificarlo.

MainActivity.java
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.view.View;
import android.widget.EditText;

public class MainActivity extends Activity {
private EditText et1;
private EditText et2;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

et1=(EditText)findViewById(R.id.et1);
et2=(EditText)findViewById(R.id.et2);
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.main, menu);
return true;
}

public void ImpTabla(View v){
String numero1 = et1.getText().toString();
int numero2 = Integer.parseInt(numero1);
String result2 = "";
for(int i = 1; i = 12; i++){
int result1 = i * numero2;
result2 += i+ " x " + numero1 + " = " + String.valueOf(result1) + '\n';
}
et2.setText(result2);
}

}

Inicialmenteasociamos nuestras variables et1 y et2 del tipo EditText a los controles EditText creados en el xml.


et1=(EditText)findViewById(R.id.et1);


et2=(EditText)findViewById(R.id.et2);


Luego el métodoImpTabla se encargará de realizar las operaciones necesarias e imprimir la salida en elcontrol EditText.

Se debe recordar que cuando tomamos un dato que hemos escrito en un control EditText éste dato es del tipo String, por ello debemos almacenarlo en una variable de éste mismo tipo de dato y luego convertirla en un entero.


String numero1= et1.getText().toString();


int numero2= Integer.parseInt(numero1);


Las 2 lineas anteriores muestran lo antes mencionado. Se almacena el dato en la variable numero 1 que es de tipo string y luego es transformada en tipo entero y almacenada en la variable numero2.

El ciclo for empezará desde 1 debido a que la tabla de multiplicar irá desde 1 hasta 12.

int result1 = i * numero2;

La variable result1 almacena las operaciones para luego imprimir el resultado es decir: 1 * 5 = 5, 2 * 5 = 10 ... 12 * 5 = 60.

Y finalmente

result2 += i+ " x " + numero1 + " = " + String.valueOf(result1) + '\n';

Almacena todos los resultados en la variable result 2concatenandolos con el operador+= y'\n'se encargará de separar las operaciones y los resultados con un salto de linea.

activity_main.xml
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context=".MainActivity"

TextView
android:id="@+id/tv1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentLeft="true"
android:layout_alignParentTop="true"
android:text="¿Que tabla de multiplicar deseas saber?" /

EditText
android:id="@+id/et1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentLeft="true"
android:layout_below="@+id/tv1"
android:layout_marginTop="22dp"
android:ems="10"

requestFocus /
/EditText

Button
android:id="@+id/button1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentLeft="true"
android:layout_below="@+id/et1"
android:onClick="ImpTabla"
android:text="Aceptar" /

EditText
android:id="@+id/et2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentLeft="true"
android:layout_below="@+id/button1"
android:layout_marginTop="21dp"
android:ems="10"
android:inputType="textMultiLine" /

/RelativeLayout

En el control Button esimportante definir lapropiedadonclick del botón, ésta se encargará de activar el métodoImpTablacuando pulsemos el botón mientras nuestra aplicación se esté ejecutando.

android:onClick="ImpTabla"

Entre comillas debe ir el nombre del método que deseamos activar al pulsar el botón.

viernes, 3 de enero de 2014

[Ejercicio resuelto Java] Sumar dos matrices de orden 2x2 – Texas – Platform


Anteriormente escribí una entrada en el blog en la cual hablo un poco de algunas formas de manejar lasmatrices en java. En esta entrada veremos como sumar los elementos de dos matrices de orden 2x2 (2 filas, 2 columnas).

Enunciado:
"Realizar un programa en java el cual sume dos matrices de orden 2x2".

SumMatrices.java
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
import java.util.Scanner;

public class SumMatrices {
private Scanner tec;
private int[][] matrizA;
private int[][] matrizB;
private int[][] matrizC;


public void CargarElementos(){
tec = new Scanner(System.in);
matrizA = new int[2][2];
matrizB = new int[2][2];
System.out.println("Ingrese los elementos de la matriz A: \n");
System.out.println("Ingrese el elemento a11 de la matriz");
matrizA[0][0] = tec.nextInt();
System.out.println("Ingrese el elemento a12 de la matriz");
matrizA[0][1] = tec.nextInt();
System.out.println("Ingrese el elemento a21 de la matriz");
matrizA[1][0] = tec.nextInt();
System.out.println("Ingrese el elemento a22 de la matriz");
matrizA[1][1] = tec.nextInt();
//Matriz A:
System.out.println("A= " + matrizA[0][0] + " " + matrizA[0][1]);
System.out.println(" " + matrizA[1][0] + " " + matrizA[1][1]);
//----------------------------------------------------------------
System.out.println("\nIngrese los elementos de la matriz B: \n");
System.out.println("Ingrese el elemento b11 de la matriz");
matrizB[0][0] = tec.nextInt();
System.out.println("Ingrese el elemento b12 de la matriz");
matrizB[0][1] = tec.nextInt();
System.out.println("Ingrese el elemento b21 de la matriz");
matrizB[1][0] = tec.nextInt();
System.out.println("Ingrese el elemento b22 de la matriz");
matrizB[1][1] = tec.nextInt();
//Matriz B:
System.out.println("B= " + matrizB[0][0] + " " + matrizB[0][1]);
System.out.println(" " + matrizB[1][0] + " " + matrizB[1][1]);
//-----------------------------------------------------------------
}

public void Suma(){
matrizC = new int[2][2];
matrizC[0][0] = matrizA[0][0] + matrizB[0][0];
matrizC[0][1] = matrizA[0][1] + matrizB[0][1];
matrizC[1][0] = matrizA[1][0] + matrizB[1][0];
matrizC[1][1] = matrizA[1][1] + matrizB[1][1];
}

public void Imprimir(){
System.out.println("La Suma de ambas matrices es: \n");
//Matriz C:
System.out.println("C= " + matrizC[0][0] + " " + matrizC[0][1]);
System.out.println(" " + matrizC[1][0] + " " + matrizC[1][1]);
//-----------------------------------------------------------------
System.out.println("\n Elementos de la matriz C: \n");
System.out.println("Elemento c11: " + matrizC[0][0]);
System.out.println("Elemento c12: " + matrizC[0][1]);
System.out.println("Elemento c21: " + matrizC[1][0]);
System.out.println("Elemento c22: " + matrizC[1][1]);
}

public static void main(String[] ar){
SumMatrices sm = new SumMatrices();
sm.CargarElementos();
sm.Suma();
sm.Imprimir();
}
}

Explicación:
Declaramos tres matrices del tipo entero:
private int[][] matrizA;
private int[][] matrizB;
private int[][] matrizC;

Sí lo desean los elementos pueden ser también número reales, es decir, del tipo float.

Definimos el tamaño de nuestras matrices:
matrizA = new int[2][2];
matrizB = new int[2][2];

Luego, empezamos a cargar los elementos de ambas matrices, al finalizar la carga de los elementos de cada matriz, estos serán mostrados en pantalla para su comprobación.

El método Suma() será el encargado de sumar los elementos de ambas matrices y el resultado almacenarlo en una nueva matriz llamadamatrizC.

public void Suma(){
matrizC = new int[2][2];
matrizC[0][0] = matrizA[0][0] + matrizB[0][0];
matrizC[0][1] = matrizA[0][1] + matrizB[0][1];
matrizC[1][0] = matrizA[1][0] + matrizB[1][0];
matrizC[1][1] = matrizA[1][1] + matrizB[1][1];
}

Finalmente imprimimos los resultados en pantalla con el métodoImprimir().

Salida:

miércoles, 11 de diciembre de 2013

Borrar varios campos de texto con un boton en java – Platform – Miami – Colleges – Email


Imaginemos que tenemos un programa en cual ingresamos una cierta cantidad de datos de personas (nombre, cédula, edad, dirección,...), cada dato en un correspondiente campo de texto. Entonces, podría ser útil un botón con el cual con tan solo hacer clic sobre éste, podamos "limpiar" oborrar todos los campos de texto del programa.

 1
2
3
4
5
6
7
8
9
10
11
12
13
final JButton btnBorrarTodo = new JButton("Borrar todo");
btnBorrarTodo.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
if(arg0.getSource() == btnBorrarTodo){
textField.setText("");
textField_1.setText("");
textField_2.setText("");
textField_3.setText("");
}
}
});
btnBorrarTodo.setBounds(242, 133, 89, 23);
frame.getContentPane().add(btnBorrarTodo);

Cuando se pulse el botón se activará el métodoactionPerformed()el cual colocará todos los campos de texto en blanco con el métodosetText("").

Funcionaría de la siguiente manera:




sábado, 7 de diciembre de 2013

Mini Calculadora en Java [Swing Biblioteca Gráfica] – cancer – Credit – Miami

En Java existe una biblioteca gráfica (Componentes Swing) la cual incluye widgets para la interfaz gráfica de usuario (cajas de texto, botones, menús entre muchos otros...).

Haciendo uso de ésta biblioteca vamos a crear una "MiniCalculadora" con las operaciones básicas como lo son: suma, resta, multiplicación y división.

Para ésta "MiniCalculadora" haremos uso de 3JTextField (campos de texto) dos para los operando y uno para mostrar el resultado , 5JButtons (botones) 4 para las operaciones 1 para salir de la aplicación y 1 para mostrar el about, a su vez 4JLabels para mostrar ciertos textos en la ventana.

Operar.java //Calculadora
  1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
import javax.swing.*;

import java.awt.event.*; // agregamos esto tambien para el boton.

public class Operar extends JFrame implements ActionListener {
private JTextField operando1, operando2, resultado;
private JButton restar, sumar, multiplicar, dividir, cerrar, acerca;
private JLabel titulo, texto1, texto2, result;
public Operar(){
setLayout(null);
//text fields
operando1 = new JTextField();
operando1.setBounds(100, 100, 100, 20);
add(operando1);
operando2 = new JTextField();
operando2.setBounds(100, 130, 100, 20);
add(operando2);
resultado = new JTextField();
resultado.setBounds(100, 160, 100, 20);
add(resultado);
//buttons
restar = new JButton("Restar");
restar.setBounds(220, 100, 100, 50);
add(restar);
restar.addActionListener(this);

sumar = new JButton("Sumar");
sumar.setBounds(220, 160, 100, 50);
add(sumar);
sumar.addActionListener(this);

multiplicar = new JButton("Multiplicar");
multiplicar.setBounds(220, 220, 100, 50);
add(multiplicar);
multiplicar.addActionListener(this);

dividir = new JButton("Dividir");
dividir.setBounds(220, 280, 100, 50);
add(dividir);
dividir.addActionListener(this);

cerrar = new JButton("Salir");
cerrar.setBounds(100, 200, 100, 50);
add(cerrar);
cerrar.addActionListener(this);

acerca = new JButton("About");
acerca.setBounds(100, 260, 100, 50);
add(acerca);
acerca.addActionListener(this);
//labels
titulo = new JLabel("Calculadora francves v1.0");
titulo.setBounds(130, 40, 200, 30);
add(titulo);

texto1 = new JLabel("Primer Valor: ");
texto1.setBounds(10, 95, 200, 30);
add(texto1);

texto2 = new JLabel("Segundo Valor: ");
texto2.setBounds(10, 125, 200, 30);
add(texto2);

result = new JLabel("Resultado: ");
result.setBounds(10, 155, 200, 30);
add(result);
}



public void actionPerformed(ActionEvent e) {
if(e.getSource() == restar){
String oper1=operando1.getText();
String oper2=operando2.getText();
int num1=Integer.parseInt(oper1);
int num2=Integer.parseInt(oper2);
int resul=num1-num2;
String total=String.valueOf(resul);
resultado.setText(total);
}
if(e.getSource() == sumar){
String oper1=operando1.getText();
String oper2=operando2.getText();
int num1=Integer.parseInt(oper1);
int num2=Integer.parseInt(oper2);
int resul=num1+num2;
String total=String.valueOf(resul);
resultado.setText(total);
}
if(e.getSource() == multiplicar){
String oper1=operando1.getText();
String oper2=operando2.getText();
int num1=Integer.parseInt(oper1);
int num2=Integer.parseInt(oper2);
int resul=num1*num2;
String total=String.valueOf(resul);
resultado.setText(total);
}
if(e.getSource() == dividir){
String oper1=operando1.getText();
String oper2=operando2.getText();
int num1=Integer.parseInt(oper1);
int num2=Integer.parseInt(oper2);
int resul=num1/num2;
String total=String.valueOf(resul);
resultado.setText(total);
}

if(e.getSource() == cerrar){
System.exit(0);
}

if(e.getSource() == acerca){
JOptionPane.showMessageDialog(null, "Calculadora francves v1.0 \n Sigueme en twitter @francves");
}
}

public static void main(String[] ar){
Operar ope = new Operar();
ope.setBounds(10, 10, 400, 400);
ope.setResizable(false);
ope.setVisible(true);
}
}

Explicación:


importjavax.swing.*;


importjava.awt.event.*;


Debemos importar esos paquetes para poder manejar las componentes Swing que vamos a utilizar en la calculadora.

Declaramos cada componente y luego le empezamos a dar ciertas características como lo son el tamaño y la posición en la pantalla.

restar.setBounds(220, 100, 100, 50);

La linea anterior le está dando ciertas características al botón "restar.setBounds(x, y, width, height);" con el parámetro "X" indicamos que tan a la izquierda o derecha se encuentra el boton, con el parámetro "Y" indicamos que tan arriba o abajo está el botón. En el tercer parámetro "width" como allí lo indica en lo ancho del botón y "Height" lo alto del botón.

Luego, debemos definir la acción que ejecutará cada botón al hacer clic sobre el. Seguimos con el ejemplo del botón "restar".


if(e.getSource()== restar){


Stringoper1=operando1.getText();


String oper2=operando2.getText();


int num1=Integer.parseInt(oper1);


int num2=Integer.parseInt(oper2);


int resul=num1-num2;


String total=String.valueOf(resul);


resultado.setText(total);


}


Con el método .getText() obtenemos el valor ingresado dentro de los campos de texto. Luego, estos valores ingresan como un tipo de datoSTRING por ello hay que convertirlos a un tipo de dato con el cual podamos realizar operaciones matemáticas, en este caso lo convertimos a int(entero). Esa conversión de tipo de dato la realizamos con el métodoInteger.parseInt() pasándole como parámetro la variable que ha guardado el valor ingresado, en nuestro caso sería la variable oper1.
Después de realizar esa conversión, el dato lo debemos guardar en una nueva variable de tipo entero.
Realizamos las operaciones respectivas y al tener un resultado, ese valor lo debemos convertir en un dato STRINGpara luego mostrarlo en el campo de texto correspondiente al resultado. Esto lo hacemos con el métodoString.valueOf(resul)pasándole como parámetro la variable que almacena el resultado. Por último Asignamos el valor de la nueva variable de tipo string que contiene el resultado al campo de texto que lo mostrará en pantalla.


1 ope.setBounds(10,10,400,400);


2 ope.setResizable(false);


3 ope.setVisible(true);


Si desean cambiar el tamaño de la ventana modifiquen el valor 400 al que ustedes deseen. Recordar que el métodosetBounds(10, 10, 400, 400);definen la posición en pantalla (en éste caso de la ventana) y el tamaño de la misma. Si desean modificar el tamaño de la pantalla a su gusto en el momento que están ejecutando el programa camabien el parámetro del metodoope.setResizable(false); de false a true.
Por último el método setVisible(true); si cambiamos el parámetro de true a false haremos invisible la ventana.

ScreenShot del programa:


Consideraciones:
La calculadora realiza operaciones con datos enteros, si desean hacerlo con datos reales (float) deben hacer uso del métodoFloat.parseFloat(Variable que deseo convertir su valor en numero real); y luego de realizar las operaciones convierte el resultado a String de la misma manera como lo hicimos previamente.