Mensajes

Cuando un método ha de ser público y otro privado, carece de sentido sobrecargar un método, dale al privado el nombre que te dé la gana y listo...

La sobrecarga sólo tiene sentido, cuando todos esos métodos son públicos y por tanto se permite al que use la librería elegir la sobrecarga que mejor le vaya  ...en cada ocasión... Si un método es privado, entonces el usuario que lo use, "ni fú ni fá", no tiene acceso, no lo ve, no puede elegir, carece de sentido que sea una sobrecarga.

Si tu método público se llama AddWord, el privado podría llamarse AddWord0, AddWordPriv, AddWordX, etc...

Entendido. Gracias por la aclaración.

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;
}

por ahi lei pero no encuentro donde...... que los setters y getters contradicen a alguno de los principios de SOLID

aca una lectura de solid......
https://scotch.io/bar-talk/s-o-l-i-d-the-first-five-principles-of-object-oriented-design


saludos

Ni siquiera conocía SOLID. Nunca he programado en POO, solo aprendí un poco con Python y Java solo lo he trabajado en el paradigma imperativo. Me veo forzado a utilizar POO para aprender a desarrollar para Android. Gracias 

si estas programando en POO entonces no deberas abusar de setter y getters

http://stackoverflow.com/questions/9416245/how-to-avoid-getters-and-setters

Grosso modo según he visto más o menos es por tema de seguridad, ¿no? Pero no todo el mundo los desaconseja, por lo que veo, si no que hay que distinguir bien en qué situaciones hay que usar uno de los dos, ambos, o ninguno, no poner sistemáticamente setter y getter a todas las clases, ¿no?

(si funciona como c)

name te dará como retorno el valor de una variable global llamada name... this.name te dará el valor de la variable name en esta clase... lo que no tenga "this" referenciará a globales, cualquier interno necesita el this para se llamado

Entiendo que al decir variable global name te refieres a una definida fuera de la clase. El caso es que el getter (sin this) devuelve el valor del atributo name del array de tipo Workout indicado, por ejemplo:
println(workouts[0].getName()) imprimiría por pantalla "TheLimbLoosener". Cabe decir que en el libro se define el método toString() (con el this), pero, al menos de momento, no se ha usado. De todos modos, mi duda sigue siendo respecto al uso o no del this.

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?