Mensajes

primero incluye la libreria math

import java.math;

y con la funcion de math.pow() para elevar a n potencia cualquier numero y su sintaxis es asi

math.pow(numeroAElevar,potenciaAelevar), si quiero elevar 3 al cuadrado lo aria asi

math.pow(3,2);

o

import java.math;
import java.Scanner;

Scanner leer=new Scanner(System.in);

system,.out.println("Digite el numero a elevar a n potencia");

int numero=leer.nextInt();

system.out.println("Digite la potenia");

int potencia=leer.nextInt();

int total=math.pow(numero,potencia);

System.out.println("El numero: "+numero+" elevado a la potencia: "+potencia+" es: "+total+);

nota si escribes math en minuscula el editor despues del punto te pondra en mayuscula la primera letra math=Math

ya lo resolviii gracias

jajajaj le cayo rebien el titulo a tu problema

pa empezar en donde obtienes la edad y luego lo comparas en el SWITCH nunca va entrar a menos que pongas edades entre 1 y 3 años ya que son tus case

y en dado caso de que entrara en case 1

en el while voto>max se que dara ciclado porq max vale 0 por primera vez y si tu pones cualquier numero diferente de 0 este que dara ciclado ya que cualquier numero diferente de cero es mayor y lo mismo pasa con el while de voto < min ya que para que saliera de ese while tendria que ser un numero mayor al que le pusiste al min esas son algunas observaciones a in el if donde preguntas si es M o m puedes transformar la letra a minuscula o mayuscula para no preguntar por M o m.

te recominedo poner mas atencion en las clases porque al parecer ya no estas en programacion 1

seria mas omenos asi

import java.awt.*;
import java.swing.*;

class Menu extends JFrame
{

    public JTextField campoA=new JTectField(10);
    public JButton aceptar=new JButton("Aceptar");
    .
    .
    .
    .

     Menu()
    {
       setTitle("Menu");
       setLocation(250,250);//En que cordenadas del monitor se dibujara la pantalla
       setSize(500,500);   
       setResizable(false) //Que la ventana no se pueda maximizar
       setDefaultCloseOpearation(JFrame.EXIT_ON_CLOSE);//Para finalizar la aplicacion cuando se cierre la ventana ya que si no se coloca cuando la aplicacion se cierre
                                                                                            //esta seguira consumiendo recursos aunque ya nop este dibujada en pantalla

       aceptar.addActionListener
                   (new ActionListener()
                    {
                         public void actionPerformed(ActionEvent evento)
                         {
                                  ventanaDepositar depositar=new VentanaDepositar();
                                  depositar.setVisible(true);//Mostramos la ventana
                                  this.setVisible(false);//Ocultamos esta ventana (Menu)
                          }
                   });
     }

}

luego creas tu otra clase donde tengas la ventana de depositar que yamara la ventana Menu

y por ultimo llamas a la clase principal


public class CorrerAplicacion{

   /**
    * @param args
    */
   public static void main(String[] args) {
      
                     Menu ventana=new Menu();
                    ventana.setVisible(true);
   }

}

algo asi seria espero haberte ayudado

ese es el script de la carta trampa llamada  Limet Reverse

tambien puedes empezar creando videojuegos de 8 bits con SimpleJ

yo utilizo tambien a Python para crear videojuegos (aunque apenas stoy aprendiendo)
y tambien pra videojuegos de 8 bits utilizo el SimpleJ
y c++ para hacer programas pequeños
Java para hacer aplicaciones con GUI
javascript , PHP, Jquery para paginas web

Pero el que mas domino es JAVA

a lo que entendi que lo tube que leer dos veces jajaja quieres hacer algo asi

9 8 7
6 5 4
3 2 1 
enviar

se me ocurre que aca boton le coloques un id a tus botones y la funcion de onClick para llamar a una funcion que crearas en otro
arrchivo

<input type ="button" name="boton7" value=  " 7 " id="boton7" onClick="guardarNumero(7)">

en otro archivo js

se aria esto

var numero="";
function guardarNumero(numeroBoton)//Aqui se concatenara el valor del boton casa vez que se presione alguno
{
    numero+=numeroBoton;
}

y si presionas los botones 1 9 y 6 en la variable numero se guardara 196 y ya faltaria compara que si este texto 196 es igual
al texto que ocupas para ingresar o
tambien lo puedes guardar como un numero y no como una cadena con la diferencia que tendrias que hacer
que por ejemplo la clave para ingresar es 10 entonces se tendria que presionar los botones 1 y 9 para que sumado sean 10

ahora se hace otra funcion  en el mismo archivo js

function validarPass()
{
   if (numero == "196")
  {
      alert("entrastes");
  }
else
{
    alert("Clave rechazada");
  }
}

y al boton de confirmar le colocas la funcion de onClick
y creo que el form quedaria asi
<form>
            //aqui van tus demas botones
           <input type ="button" name="confirmar" size = "20" onClick="validarPass()" value= "Confirmar " >
</form>

a y en el head colocas el archivo js que se creo
<head>
<title>Password</TITLE>
<script src="archivoValidar.js"></script>
</head>
algo asi podria ser


te recomiendo que si no sabes acceder a otras archivos que se encunetren dentro de otra carpeta de tus proyectos que hagas
colocalo al mismo nivel de tu pagina principal y asi cuando lo llames solo coloques el nombre y la extension del archivo a y si njo sabes java script lee un poco hay much informacion

Mypagina(CarpetaProyecto)
   PAginaprincipal.html
   Archivo validar.js

espero haberte ayudado o a darte una idea este codigo que escribe no lo he probado pero halgo asi es la idea jajaj

empiesa con la libreria de Pygame que es para Python muy facil y hay mucha documentacion

La siguiente duda es la siguiente

El programa trata de que dado un archivo con (n) lineas debe de ser leido y escrito en otro archivo acomodandolo de menor a mayor.

Tengo un archivo con extension h (extension de c o c++) este archivo contiene 131 lineas y su contenido esta dividido en 4 columnas.
El cual contiene numero y letras.

myArchivo.h
01254152634152   2312    085465200012   FDDG4152
05432105454321   15513  084527203321   NBN1321N
46543131215465   12        094552254515   GFDG121F
46546532154514    01       184543254855   DFG223D2
.
.
.
.
asi hasta 131 lineas
ETC.

El contenido de este archivo esta desordenado y para ordenarlo se toma encuenta la 3 columna ya que si se fijan el 7 carcter siempre es un 2 y la tercer columna empieza desde la columna 25 contando los espacios enblanco (entodas las filas) y desde la columna 25 hasta la columna 31 de la misma fila se obtiene un numero.
Por ejemplo de la linea 1 obtenemos el numero (columna 25)084526(columna 31)
y nos sobran estos caracteres 200012 (este numero no importa) y asi es con la fila 2 085465 y la fila 3  094552 y asi hasta la 131.
y con esos numero se puede saber que linea es mas menor a aquien. Este pedazo ya lo tengo

aqui codigo lo pondre con la etiqueta de py porq no hay para java

Código (python) [Seleccionar] Expandir


import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeMap;

import org.omg.CORBA.TRANSACTION_REQUIRED;

public class ordenarConSort {
public static void main(String[] args) {

String ArchivoAnomalias = "C:/refo/Anomalias.D"; // se le asigna el nombre al archivo
String ArchivoRefoleo = "C:/refo/Refoleo.D";

FileWriter fw1 = null; // la extension al archivo
FileWriter fw3 = null; // la extension al archivo
BufferedReader leer = null;
BufferedReader leer2 = null;

try {

FileReader entrada = null;
FileReader entrada2 = null;

entrada = new FileReader("C:/refo/1333206.D"); //Obtenemos el archivo a leer
int c;
int columna = 1;
int renglon = 1;
int indice = 0;

int arreglo[] = new int[131]; arreglo donde aguardaremos los 131 numero ya que es un numero por fila del archivo
String numero = ""; //Aqui se guardara caracter por caracter hasta formar el numero que se ocupa

while ((c = entrada.read()) != -1) { //Para saber si no se ha llegado a fin del archivo

if (((char) c) == 10) { //Para saber si no se a llegado hasta el final del renglon (salto de linea) que se esta leyendo del archivo
renglon++;
columna = 1;
}

if (renglon >= 2 && renglon <= 130) {//PAra empezar desde el renglon numero dos del archivo a leer
if (columna > 123 && columna < 131) {//PAra saber si ya se posiciono en la columna 123 del primer renglon
numero += String.valueOf((char) c);//Se guarda el primer caracter y se le concatena el siguiente caracter mientras se cumpla la condicion
}
                           
columna += 1;

if (columna == 131) {  //Para saber si ya se leyeron los primeros 8 carcteres de nuestro renglon
arreglo[indice] = Integer.valueOf(numero); //Se convierte el la variable numero a un entero para guardarlo en un arreglo de tipo entero
numero = "";//limpiamos la variable numero para que cuando vuelva a concatenar los
                                                                     caracteres no tenga guardado el numero de la concatenacion anterior
indice++;
}
}
}
entrada.close();//Se cierra el archivo de lectura


una vez que ya tengo todo el arreglo lleno con los numero que necesito para saber que renglon es mas chio que quien.
Ahora paso a ordenar los numero de mi arreglo del menor a mayor con el metodo de sort y para eso utilizo la siguiente funcion

Arrays.sort(arreglo); //y con esto estan ordenados mis numeros del menor al mayor (este metodo es de java Arrays.sort())

Despues paso a leer el archivo nuevamente pero ahora obtengo todo el renglon y lo guardo
en un arreglo

Código (python) [Seleccionar] Expandir


String pala[]=new String [131];//Arreglo para guardar la linea completa del arhivo a leer
int i = 0; //contador inicializado
String line = "";//Se guardara la linea leida momentaneamente

BufferedReader br = new BufferedReader(new FileReader("C:/refo/1333206.D"));//Archivo a leer
  while ((line = br.readLine()) != null) // lee la linea (br.readLine) y pasalo a la variable linea luego pregunta Mientras no se llegue a fin de archivo
{
pala[i]=line;//guardamos la linea obtenido dentro de nuestro arreglo a utilizar
i++;//incrementa contador
}
br.close();



Una vez que ya tengo gurdadas todas las lineas de mi arhcivo en my arreglo ahora paso a crear el nuevo archivo y he ir guardando las lineas del menor a mayor

Código (python) [Seleccionar] Expandir


         int cont=0;               
FileWriter fw2 = new FileWriter( "C:/refo/Lecturas.D"); //Archivo a crear
PrintWriter salArch = new PrintWriter(fw2); //Archivo al cual se le va escribir

//Se hara un for anidado, el pimer FOR para recorrer el arreglo en donde tenemos los numeros ya acomodados del menor al mayor
//y el segundo FOR para ir buscando el reglon que cumpla con el patron del numero

for(i=1; i<arreglo.length; ++i)//Primer for para recorrer el arreglo de los numero ordenados
{
for(int index=0; index<arreglo.length; ++index)//Segundo for para recorrer el arreglo donde se guardo todo el renglon completo
{
                                        //Pregunto que si en el primer renglon que se encuentra guardado dentro de mi arreglo pala. En ese renglon en el que estoy ahorita
                                        //hay una coincidencia con el numero que se esta guardado dentro del arreglo si no existe ese patron la funcion indexOf regresa un -1
                                        //ejemplo en mi renglo pala recordemos que tengo todas las lineas del archivo y en mi arreglo tengo todos los numeros ordenados
                                       // del menor al mayor:
                                       //pala
                                       //pos 0 -  01254152634152   2312    085465200012   FDDG4152
                                       //pos 1 -  05432105454321   15513  084527203321   NBN1321N
                                       //pos 2 -  46543131215465   12        094552254515   GFDG121F
                                       //pos 3 -  46546532154514    01       184543254855   DFG223D2
                                       //pos 4 - .
                                       //pos 5 - .
                                       //pos 6 - .
                                        asi hasta 131 lineas
                                         
                                        // y en mi arreglo los numero obtenidos anteriormente
                                       //pos 0 -  084527
                                       //pos 1 -  085465
                                       //pos 2 -  094552
                                       //pos 3 -  184543
                                       //pos 4 - .
                                       //pos 5 - .
                                       //pos 6 - .
                                                                     //esta es la posicion 0                                                                                                     //posicion 0
                                      //if(pala[01254152634152   2312    085465200012   FDDG4152] hay una coincidencia con este numero arreglo[084527] )
                                      //si no la hubo busca en el siguiente reglon (si no es diferente de -1)
                                     
                                       //                                //esta es la posicion 1                                                                                                     //posicion 0
                                      //if(pala[05432105454321   15513  084527203321   NBN1321N] hay una coincidencia con este numero arreglo[084527] )
                                      //En este caso si hubo una coincidencia y se cumple la condicion porque no se regresa -1 sino 0 y por lo tanto este es el renglon mas chico
                                      //de todos y terminamos con este FOR para aumentar la posicion en el arreglo y se vuelve otra vez arrecorrer el arreglo pala para buscar la
                                      //proxima coincidencia
if(pala[index].indexOf(String.valueOf(arreglo[i])) != -1)
{
//Se guarda exactamente el renglon que si cumplio con la condicion
                                               
salArch.println(pala[index]);
//System.out.println(pala[index]);
cont++;
break;
}
}
}
System.out.println(i+" cont: "+cont);//PAra saber cuantas veces se cumplio la condicion (cont) y la i para saber corraborar que si se dio las 131 bueltas
} //MAnejo de cualquier tipo de excepcion
                catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}



bueno el error esta en que cuando lo mando a imprimir en el archivo que yo creo no guarda todas las lineas sino 105 lineas y ya comprobe en consola
de que si se emprimen las 131 lineas pero en el archivo no y no entiendo porq alguien me podria decir en donde esta my error porq por mas que lo busco no
lo encuentro de ehco ahi se ve que hago una impresion a consola y en consola si salen todas las lineas (131 )y ordenadas del menor a mayor
pero como lo escribi antes en el archivo si se guardan las lineas del menor al mayor pero no las 131 lineas y ya revise que si se entra en la condicion 131 veces y si
entra ese numero de veces. No se si sea si despues de un rato el archivo se cierra solo autmaticamente o que es lo q pasa q solo pòne 105 lineas y no las
131 lineas que deben de ser.

PDT: NO acostumbro a documentar asi mi codigo solo lo hice para que se obtuviera una mejor comprencion de que es lo q estoy haciendo
y asi no haya con fuciones bueno eso espero jajajaja.


espero y puedan ayudarme ya que solo me falta resolver ese problemaa