Codigo java

aLeX-PhOeNiX

aLeX-PhOeNiX

Lanero Reconocido
22 Jun 2004
1,042
hola amigos laneros
me dieron un problema y no se como resolverlo espero que alguno de ustedes me ayude

el problema es el siguiente:

dada una palabra almacenar en un arreglo o en un Vector las palabras que se forman
con la permutacion de las letras( no utilizar metodo recursivo )

ejemplo:
se ingresa la palabra feo y en el vector debe estar la siguiente lista de palabras
feo
foe
eof
oef
efo
ofe

no importa el orden pero deben estar las palabras
me podrian dar una pista de como hacer o el codigo si no es mucho pedir
 
Yo te doy un consejo, buscate "algoritmos q implementen combinaciones y permutaciones" o también hay un buen libro q habla sobre ello q es el libro de "MATEMÁTICAS DISCRETAS DE ROSSEN". Buscatelo q ahi hay cosas q te pueden servir.
 
En una de las versiones del libro "Algoritmos" de Sedgewick hay implementaciones de algoritmos de permutaciones, pero la verdad no recuerdo si es el de Algoritmos en C o Algoritmos en C++
 
Tengo intención de colaborar pero sólo sé programar en C++, también existen listas enlazadas, pilas o colas en Java?. Sé como resolverlo de esa forma.
 
si hay pilas y colas y listas en java.
ejemplito:
lista enlazada:

class Employee
{
private int empno;
private String name;
private double salary;

public Employee next;

// Other members
}

lista doblemente enlazada:

class demo
{
static class Node
{
String name;
Node next;
Node prev;
}
}


colas:
public interface Queue
{
void insert (Object o);
boolean isEmpty ();
boolean isFull ();
Object remove ();
}

pilas:

public interface Stack
{
boolean isEmpty ();
Object peek ();
void push (Object o);
Object pop ();
}

con la pila y la cola, solo es ke implementes los metodos de las interfaces, ke si sabes algo de estructuras de datos y de java, no sera dificil, puedes utilizar un array simple para implementar.
bueno, no es mas x ahora xD
 
¿Esas no vienen ya implementadas y requetecontra probadas?

En C++ se utilizan templates (muy bacanos ;)) como
Código: 
list<int> the_koolest_list


En java 5 la cosa creo que es parecida con los generics.
Antes se hacía parecido, pero como no habían generics, la lista podía recibir cualquier elemento (tipo Object). La verdad no recuerdo cómo es que es la cosa, pero creo que es bastante parecido...

Si h22429005 nos colabora con la idea en C++ sería bacanísimo pues a mí me gusta mucho ese lenguaje.
 
Aquí va un ejemplito que hice hace mucho tiempo en estructura de datos. Adjunto el código fuente y el ejecutable.


#include <iostream.h>
#include <conio.h>
#include <Math.h>
#include <stdio.h>
#include <String.h>


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------


struct tpilaf
{
float pila[300];
int tope;
};


void crearpilaf(tpilaf pila1)
{
pila1.tope=0;
}


float sacarpilaf(tpilaf &pila1)
{
float e=pila1.pila[pila1.tope];
pila1.tope=pila1.tope - 1;
return e;
}


void agregarpilaf(tpilaf &pila1, float el)
{
pila1.tope=pila1.tope + 1;
pila1.pila[pila1.tope]= el;
}


int pilavaciaf(tpilaf pila1)
{
if (pila1.tope == 0)
{
return 1;
}
else
{
return 0;
}
}

char cadsub1 (char cad[], int j)
{
int i;
char cadena[100];
for (i=j;i<=j+1;i++)
{
cadena[i-j+1] = cad;
}
return cadena[1];
}


struct tpila
{
char pila[300];
int tope;
};


void crearpila(tpila pila2)
{
pila2.tope=0;
}


char sacarpila(tpila &pila2)
{
char e=pila2.pila[pila2.tope];
pila2.tope=pila2.tope - 1;
return e;
}


void agregarpila(tpila &pila2,char elem)
{
pila2.tope=pila2.tope + 1;
pila2.pila[pila2.tope]= elem;
}


int pilavacia(tpila pila2)
{
if (pila2.tope == 0)
{
return 1;
}
else
{
return 0;
}
}

tpilaf pila1;
tpila pila2;

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

main()

{

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

cout<<"laboratorio 1 de estructura de datos\t";
cout<<"\n";
cout<<"\n";

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

float i, n, a, b, f, g, r;
char h, d, cadena[300];
cout<<"\t"<<"Digite la cadena\n";
cout<<"\n";
cin>>cadena;
n=strlen(cadena);
crearpilaf(pila1);
crearpila(pila2);

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

for (i=1;i<=n;i++)
{
h= cadsub1(cadena,i-1);


if ((h == '0')||(h == '1')||(h == '2')||(h == '3')||(h == '4')||(h == '5')
||(h == '6')||(h == '7')||(h == '8')||(h == '9') )
{


f = ((float)h)-48;
agregarpilaf(pila1,f);
}

if ((h == '+')||(h == '-')||(h == '*')||(h == '/')||(h == '^'))
{
agregarpila(pila2,h);
}

if ((h == ')'))
{
b = sacarpilaf(pila1);
a = sacarpilaf(pila1);
d = sacarpila(pila2);

if ((d == '+'))
{
g = a+b;
agregarpilaf(pila1,g);
}

if ((d == '-'))
{
g = (a-b);
agregarpilaf(pila1,g);

}

if ((d == '*'))
{
g = (a * b);
agregarpilaf(pila1,g);
}
if ((d == '/'))
{
g = (a/b);
agregarpilaf(pila1,g);
}
if ((d == '^'))
{
g = pow(a,b);
agregarpilaf(pila1,g);
}
}

}

r = sacarpilaf(pila1);
cout << r;
getch ();
}

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
En el foro de desarrollo de aplicaciones móviles hay unos manes que saben full de Java, yo como dije apenas tengo la intención de aprender, así que te aconsejo que te metas al foro y le envies a lalguno un mensaje privado.
 
edgnet dijo:
ahi luego nos dices como le has hecho
Haz clic para expandir...
despues de gran esfuerzo lo logre en base a la recursion
aqui esta el codigo talves a alguien le sirva

// precondiciones : prefijo siempre debe ser ""
// metodo que devuelve una cadena en donde estan las permutaciones
// de la palabra representada por sufijo
public String calculoPermu( String prefijo, String sufijo ){
String a = "";
String nuevoPrefijo,nuevoSufijo;
int numDeCaracteres = sufijo.length();

if( numDeCaracteres == 1) {
a = ( prefijo + sufijo );
}
else {
for( int i = 0; i < numDeCaracteres; i++ ) {
nuevoSufijo = sufijo.substring(1,numDeCaracteres);
nuevoPrefijo = prefijo + sufijo.charAt(0);
// llamada recursiva con el resto de letras de
// la palabra . Rotar a la izquierda para crear
// un nuevo sufijo.
a = a + calculoPermu( nuevoPrefijo, nuevoSufijo );
sufijo = nuevoSufijo + sufijo.charAt(0);
}
}
return a;
}
 
alejandro_o dijo:
despues de gran esfuerzo lo logre en base a la recursion
aqui esta el codigo talves a alguien le sirva

// precondiciones : prefijo siempre debe ser ""
// metodo que devuelve una cadena en donde estan las permutaciones
// de la palabra representada por sufijo
public String calculoPermu( String prefijo, String sufijo ){
String a = "";
String nuevoPrefijo,nuevoSufijo;
int numDeCaracteres = sufijo.length();

if( numDeCaracteres == 1) {
a = ( prefijo + sufijo );
}
else {
for( int i = 0; i < numDeCaracteres; i++ ) {
nuevoSufijo = sufijo.substring(1,numDeCaracteres);
nuevoPrefijo = prefijo + sufijo.charAt(0);
// llamada recursiva con el resto de letras de
// la palabra . Rotar a la izquierda para crear
// un nuevo sufijo.
a = a + calculoPermu( nuevoPrefijo, nuevoSufijo );
sufijo = nuevoSufijo + sufijo.charAt(0);
}
}
return a;
}
Haz clic para expandir...

pero como es sin recursividad,es un problema de naturaleza recursiva, pero sin recursividad si esta para pensarse un ratito (que flojera (n.n)U
 
...despues de gran esfuerzo lo logre en base a la recursion
aqui esta el codigo talves a alguien le sirva...

jeje, esfuerzo mental o esfuerzo de google?
Te aconsejo, que intentes hallar las soluciones por ti mismo...
 
encontre en google en un foro que estaba en portugues un codigo para esto pero luego lo compile y me dio un monton de errores luego tuve que analizar el algoritmo para hallarle las fallas pero lo logre.
 
sta bien... pero que hay del codigo sin recursividad.... de hecho yo tambien ya lo habia hecho... pero lei que lo pedian sin recursividad :S El algoritmo no es muy dificil(con recursividad claro) ...
 

Los últimos mensajes

Los últimos temas

Arriba Pie
Atrás