Temas

Hola.

He hecho una clase para la estructura de datos Trie en Python y tengo un método recursivo que se llama addWord que tiene como argumentos la palabra que se quiere introducir, la subpalabra que se ha generado hasta el momento en cada llamada y el nodo actual. Me gustaría que el usuario pudiera utilizar el método con un solo argumento (la palabra a introducir), ya que los otros dos son consecuencia del algoritmo y la recursividad, de modo que el usuario no necesita conocerlos. En Java, por ejemplo, utilizaría la sobrecarga de métodos y el método addWord que he descrito sería privado y crearía otro con el mismo nombre, público y con la palabra a añadir como único argumento (creo que es el enfoque correcto, corregidme si me equivoco) ¿Hay alguna forma de hacer algo parecido en Python? ¿Cómo se procede en estos casos con este lenguaje?

(La solución obvia sería crear otro método en la clase con el argumento palabra y un nombre diferente, pero me gustaría saber si hay otro modo).

Hola. He intentado resolver el problema del 15-puzzle del Juez de la UVa en Python mediante backtracking (el problema en cuestión es este: https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=36&page=show_problem&problem=1122). El problema está en que se supone que cada solución está limitada a un máximo de 50 pasos, pero el vector solución crece hasta más de 140 pasos en la mayor parte de las iteraciones, por lo que el programa no encuentra la solución en un tiempo razonable. Adjunto el código del programa completo, pero solo es necesario mirar el método backtracking (sé que nadie va a estudiar un código tan largo, pero tampoco hace falta). Solo debería generarse un movimiento como máximo en cada llamada a backtracking, y si la rama no tiene más nodos intermedios debería volver al estado anterior y borrar del vector solución el último movimiento. La condición 

Código (python) [Seleccionar] Expandir

if(a[k] != mov_inv[c[i]]): sirve para evitar deshacer movimientos ¿Alguien puede decirme por qué el vector solución crece más allá de los 50 elementos? (Cabe decir, que efectivamente, k no sobrepasa nunca el valor 50).

Código (python) [Seleccionar] Expandir



moves = {0:('R','D'),1:('R','L','D'),2:('R','L','D'),3:('L','D'),4:('R','D','U'),5:('R','L','D','U'),
         6:('R','L','D','U'),7:('L','U','D'),8:('R','D','U'),9:('R','L','D','U'),10:('R','L','D','U'),
         11:('L','U','D'),12:('U','R'),13:('L','U','R'),14:('L','U','R'),15:('U','L')}

mov_inv = {'U':'D','D':'U','R':'L','L':'R'}


def backtracking(a,k,tab):
    c = []
    if is_solution(tab):
        process_solution(a)
    elif k < 51:
        print a
        c = construct_candidates(tab)
        for i in range(len(c)):
            if(a[k] != mov_inv[c[i]]):
                a.append(c[i])
                make_move(tab,a[k+1])
                backtracking(a,k+1,tab)
                unmake_move(tab,a[k+1])
                a = a[:-1]

def inversions(a):
    n_inv = 0
    a_copy = a[:]
    a_copy.remove(0)
   
    for i in range(len(a_copy)):
        for j in range(i,len(a_copy)):
            if a_copy[i] > a_copy[j]:
                n_inv = n_inv + 1
   
    return n_inv

def is_solvable(a):
    n_inv = inversions(a)
    if ((a.index(0) % 4) % 2) == 0 and n_inv % 2 == 0:
        return True
    if ((a.index(0) % 4) % 2) == 1 and n_inv % 2 == 1:
        return True
    return False


def construct_candidates(tab):
    i = tab.index(0)
    m = moves[i]
    c = []
    for j in range(len(m)):
        c.append(m[j])
    return c
   
def make_move(tab,m):
    i = tab.index(0)
    if m == 'U':
        c = tab[i-4]
        tab[i-4] = 0
        tab[i] = c
    elif m == 'D':
        c = tab[i+4]
        tab[i+4] = 0
        tab[i] = c
    elif m == 'L':
        c = tab[i-1]
        tab[i-1] = 0
        tab[i] = c
    elif m == 'R':
        c = tab[i+1]
        tab[i+1] = 0
        tab[i] = c
       
def unmake_move(tab,m):
    make_move(tab,mov_inv[m])

def is_solution(tab):
    if(tab[15] != 0):
        return False
    else:
        for i in range(len(tab)-1):
            if tab[i] != i+1:
                return False
    return True

def process_solution(a):
    print a

a = [-1]
tab = [2,3,4,0,
       1,5,7,8,
       9,6,10,12,
       13,14,11,15]


if not is_solvable(tab):
    print "This puzzle is not solvable"
else:
    backtracking(a,0,tab)

Hola.
Intento hacer un programa al que se le pase por parámetro (en la línea de comandos) el tamaño de un array tipo float. Tengo que reservar el espacio necesario con malloc. El usuario debe introducir los valores del array. El programa los imprime. A continuación invierte el vector (aquí viene el problema) y se vuelve a imprimir el array. El array se imprime en el orden original otra vez. Debe de ser algún problema con las referencias, pero no lo encuentro ¿Alguien me echa un cable?

Para hacer más fácil la revisión, diré que el problema probablemente esté en la función invertir, lo demás funciona sin problemas.

Edito: ya lo he resuelto. El problema no es de referencias. En la función invertir escribí mal la condición de fin del for. Debe acabar cuando el índice i supere al tam, es decir, el for quedaría:

Código (c) [Seleccionar] Expandir


for(int i = 0; i < tam; i++) {
tmp = array[i];
array[i] = array[tam];
array[tam] = tmp;
tam--;
}


Código (c) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>

int POW(int a, int b);
void invertir(float *array, int tam);

int main(int argc, char *argv[]) {
if(argc < 2 | argc > 2) {
printf("Este programa solo admite 1 argumento.\n");
return 1;
}
int numero = 1;
for(int i = 0; argv[1][i] != '\0'; i++) {
if(argv[1][i] < 48 || argv[1][i] > 57) {
numero = 0;
}
}

if(numero == 0) {
printf("Argumento NO entero\n");
return 2;
}

int tam = 0; //tamaño del vector de floats (argumento programa)
int tam_cadena = 0; //será el tamaño de la cadena argv[1]

for(int i = 0; argv[1][i] != '\0'; i++) {
tam_cadena++;
}

printf("Tamaño de la cadena argumento: %d\n", tam_cadena);

for(int i = 0; argv[1][i] != '\0'; i++) {
tam += ((int)argv[1][i] - 48) * POW(10, tam_cadena-1-i);
}

printf("%d\n", tam);
//Creación del array tipo float de tamaño introducido por el usuario
float *dir_array_float;
dir_array_float = (float*)malloc(tam*sizeof(float));

float elem;

for(int i = 0; i < tam; i++) {
printf("Introduzca el elemento (float) nº %d del array: \n", i+1);
scanf("%f", &dir_array_float[i]);
}

printf("\n");

for(int i = 0; i < tam; i++) {
printf("%f\n", dir_array_float[i]);
}

invertir(dir_array_float, tam);

printf("\n");

for(int i = 0; i < tam; i++) {
printf("%f\n", dir_array_float[i]);
}

return 0;
}

int POW(int a, int b) {
int base = a;

if(b>0) {
while(b>1) {
a *= base;
b--;
}
}
else if(b == 0) {
return 1;
}

return a;
}

void invertir(float *array, int tam) {
float tmp;
tam--;

for(int i = 0; i > tam; i++) {
tmp = array[i];
array[i] = array[tam];
array[tam] = tmp;
tam--;
}

return;
}

Hola.

Tengo una pequeña duda con un código de un libro que estoy leyendo de desarrollo de Android, pero el problema que tengo es simplemente de Java. El código es el siguiente:

Código (java) [Seleccionar] Expandir


public class Workout {
    private String name;
    private String description;

    public static final Workout[] workouts = {
            new Workout("The Limb Loosener",
                    "5 Handstand push-ups\n10 1-legged squats\n15 Pull-ups"),
            new Workout("Core Agony",
                    "100 Pull-ups\n100 Push-ups\n100 Sit-ups\n100Squats"),
            new Workout("The Wimp Special",
                    "5 Pull-ups\n10 Push-ups\n15 Squats"),
            new Workout("Strength and Length",
                    "500 meter run\n21 x 1.5 pood kettleball swing\n21 x pull-ups")
    };

    //Each workout has a name and a description
    private Workout(String name, String description) {
        this.name = name;
        this.description = description;
    }

    public String getDescription() {
        return description;
    }

    public String getName() {
        return name;
    }

    public String toString() {
        return this.name;
    }
}


Mi duda está en la diferencia entre el método getName() y el método toString(). Según lo que tenía entendido hasta ahora, el toString daría el nombre de un objeto Workout ya instanciado (por el this) ¿Alguien me puede aclarar esto?