amvulante

Buenas, esta vez les mostrare una función recursiva que determina si una palabra es palíndromo. Para los que no saben que es un palíndromo: wikipedia dijo:Un palíndromo (del griego palin dromein, volver a ir hacia atrás) es una palabra, número o frase que se lee igual hacia adelante que hacia atrás. Si se trata de un número, se llama capicúa. Habitualmente, las frases palindrómicas se resienten en su significado cuanto más largas son. :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= el algoritmo es bastante sencillo, pero les servirá a los que estén iniciando con funciones recursivas: public static boolean comprobar(String palabra){ if(palabra.length() == 1 || palabra.length() == 0) return true; else{ if(palabra.charAt(0) == palabra.charAt(palabra.length()-1) ) return comprobar(palabra.substring(1,palabra.length()-1)); return false; } } => el primer caso base es que el la longitud de la palabra sea 0 o 1 , que sera en esencia un palíndromo y retornara true. => si no cumple el primer estamento, comprueba que la primera y la ultima letra sean iguales, de ser así las "elimina" y se llama recursivamente con la palabra resultante, si las letras no eran iguales retorna false. ejemplo con la palabra aibofobia(miedo a los palíndromos ): aibofobia aibofobia ibofobi bofob ofo f <= encuentra palabra de longitud 1, y retorna true :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= Si desean utilizarlo con frases(como: "anita lava la tina" ) entonces deberían agregar un método como este: public static boolean ajustar(String palabra){ palabra.toLowerCase(); String sinespacios = palabra.replaceAll(" ", ""); return comprobar(sinespacios); } Básicamente elimina los espacios, convierte todas las letras en minúscula y llama al método comprobar con la palabra resultante. :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= Gracias por pasar!.

La clase Queue (cola en nuestro idioma) es una estructura de datos genérica que permite almacenar objetos. Para entender mejor su funcionamiento imaginémonos que un Queue es un fila de banco; las personas que llegan se ubican siempre en la ultima posición de la cola y el que encabeza la misma es el que se despacha primero. De la misma manera en clase Queue los elementos son siempre ubicados en la ultima posición, y los que se despachan(eliminan) son siempre los de la primera posición. :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= Atributos. E[ ] array => allí guardaremos nuestros elementos int tail => índice de la cola int head => índice de la cabeza :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= Métodos. consta de 3 métodos básicos: offer(E element) => inserta un elemento a la cola public void offer(E element){ array[++tail] = element; } poll() => devuelve y remueve la cabeza de la cola public E poll(){ head++; return array[head-1]; } peek() => devuelve pero no remueve la cabeza de la cola public E peek(){ return array; } se debe agregar un método que expanda el array cuando este al limite :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= Y eso es todo, es una clase bastante sencilla pero útil, gracias por pasar.

En esta ocasión les mostrare 2 algoritmos de ordenacion, el Selection sort y el Insertion sort. Selection Sort. -> La complejidad del algoritmo es O(n^2) donde n es el numero de elementos, se parece al Bubble sort pero es un poco mas eficiente, dado que a lo sumo hace 1 movimiento de elementos por iteracion. :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= public class Selection { public void sort(double [] vector) { for(int i = 0; i < vector.length-1; i++){ int idx = i; for(int j= i +1; j < vector.length ; j++){ if(vector < vector){ idx = j; } } if (i != idx){ double aux = vector; vector = vector; vector = aux; } } } } Su lógica es sencilla, compara cada elemento con sus siguientes, guardando el incide del elemento de menor valor y al final lo intercambia. ejemplo: si se dan cuenta hace solo 1 intercambio para hallar el valor adecuado en una pocision, en ese sentido es un poco mas eficiente que el Bubble sort ya que por ejemplo para hallar el numero de menor valor (-5) el algoritmo burbuja primero habria intercambiado a 5 con 1 y luego a 1 con -5 , haciendo mas de un intercambio lo que significa tiempo y memoria. :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= Insertion sort. -> complejidad del algoritmo O(n) en el mejor caso y O(n^2) en el peor caso, donde n es el numero de elementos. Este sigue siendo un algoritmo poco óptimo sin embargo es mejor que los dos anteriores. :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= private void insertionsort(double [] sinarreglar){ for( int i = 1; i < sinarreglar.length; i++){ double temp = sinarreglar; int j = i-1; boolean flag = true; while (j >= 0 && flag) { if (sinarreglar > temp){ sinarreglar[j + 1] = sinarreglar; } else{ flag = false; j++; } j--; } sinarreglar[j+1] = temp; } } su lógica, aunque sencilla, es un poco mas compleja que los anteriores, básicamente organiza de izquierda a derecha seleccionando siempre un valor, buscando en las anteriores posiciones su lugar correcto e insertándolo. un gif muy explicativo: :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= Eso fue todo, gracias por pasar!

En esta ocasión vengo a mostrarles una implementación propia de la clase LinkedList, esta clase es una coleccion de elementos con una utilidad equivalente a la de ArrayList pero con una estructura distinta. La principal diferencia es su modo de guardar los elementos; ArrayList lo hace en un array mientras LinkedList lo hace mediante una estructura de objetos encadenados(nodos) por links o instancias. ArrayList. se puede representar en casillas, donde cada una de ellas es un espacio de memoria destinado a un objeto LinkedList. los objetos están unidos por conexiones, cada elemento tiene una conexión al objeto siguiente :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= Nodo. Los objetos que almacenan los datos y links se llaman nodos, como cada nodo tiene una conexión a su siguiente solo seria necesario saber cual es el primer nodo, sin embargo se pueden poner dos links en cada nodo, uno para el nodo siguiente y uno para el anterior. acá el código del nodo: private class Node<E> { private E data; // dato de cualquier tipo private Node<E> after; //link al siguiente nodo private Node<E> before; //link al anterior nodo // Getters y Setters public E getData() { return data; } public void setData(E data) { this.data = data; } public Node<E> getAfter() { return after; } public void setAfter(Node<E> link) { this.after = link; } public Node<E> getBefore() { return before; } public void setBefore(Node<E> link) { this.before = link; } // el constructor inicializa las variables con los valores recibidos public Node(E data, Node<E> after, Node<E> before) { this.data = data; this.after = after; this.before = before; } } la clase es privada puesto que se encuentra en la clase LinkedList y solo ella la utilizara La <E> significa que es de tipo genérico, es decir que se puede almacenar cualquier tipo de dato(int, char, etc). Existen tres tipos de encadenamiento: el simplemente encadenado(cada nodo tiene un link al siguiente elemento), el doblemente encadenado(link al siguiente y al anterior) y el circular (no hay ni primer ni ultimo nodo, todos están encadenados). En mi caso utilice el doblemente encadenado, en este el primer nodo no tiene link al anterior y el ultimo no tiene link al siguiente. :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= Atributos Serian basicamente 3: -> una referencia al primer nodo. -> una referencia al ultimo nodo. -> un entero con la longitud. private int size; private Node<E> head; private Node<E> tail; :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= Metodos repito, esta es una implementación propia, así que no son los mismos métodos del API -> Constructor: public MyLinkedList() { this.clear(); } llama a un método clear que inicializa las variables. -> clear public void clear() { head = new Node<E>(null, tail, null); tail = new Node<E>(null, null, head); size = 0; } inicializa los dos nodos dando a la cabeza un link a la cola y viceversa, también asigna al tama~o el valor de 0. -> size public int size() { return size; } simplemente retorna el valor del atributo size -> isEmpty public boolean isEmpy() { return (size == 0); } dice si la lista esta vacía -> contains public boolean contains(E item) { boolean contains = false; Node<E> temp = head; for (int i = 0; i < size; i++) { temp = temp.getAfter(); // el nodo se iguala a su siguiente if (temp.getData() == item) contains = true; } return contains; } recive un elemento, crea un nodo temporal al que se iguala al primer nodo(cabeza) y se hace una iteración comparando el elemento recibido con el que contiene el nodo temporal. -> add public void add(E item) { Node<E> newNode = new Node<E>(item, tail, tail.getBefore()); // crea un nodo con el dato recivido tail.getBefore().setAfter(newNode); // el nuevo nodo sera el link siguiente al que era el ultimo nodo tail.setBefore(newNode); size++; } crea un nodo con la información recibida y lo pone al final de la lista -> getNode public Node<E> getNode(int index) throws Exception { Node<E> temp; if (index < 1 || index > size) throw new Exception("Indice fuera de rango"); else { temp = head.getAfter(); for (int i = 1; i < index; i++) { temp = temp.getAfter(); } } return temp; } devuelve el nodo de la posición recibida, igualando el nodo temporal a su siguiente tantas veces como el índice lo indique. -> get public E get(int index) throws Exception { return this.getNode(index).getData(); } retorna el dato del nodo en la posición recibida. -> delete public E delete(Node<E> nodeR) { nodeR.getAfter().setBefore(nodeR.getBefore()); nodeR.getBefore().setAfter(nodeR.getAfter()); size--; return nodeR.getData(); } remueve de la lista el nodo recibido y retorna el valor que contenía. Básicamente lo que hace es cambiar los links del anterior y del siguiente nodo para que lo omitan, el dibujo lo explica mejor: ->set public void set(int index, E item) throws Exception { this.getNode(index).setData(item); } simplemente iguala el dato del nodo en la posición recibida por el valor entrante. Esos son los métodos mas básicos, no pongo mas porque me da pereza :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= si alguno quiere el .java con otros 12 métodos me manda un mp, gracias por pasar!.

Buenas, en esta ocasión vengo a compartir una implementación propia de la clase Stack, con el fin de entender su funcionamiento. Un stack o pila es una colección de elementos donde el primer objeto ingresado es el primero que sale. Imaginémonos un grupo de libros apilados uno encima de otro en una caja, cuando introduzcamos un libro a la pila este quedara encima de los demás, es decir, sera el primero que podremos sacar. Sucede lo mismo con la clase Stack, en la que contamos con 5 métodos: empty nos permite saber si la pila esta vacia peek devuelve el valor del primer elemento (lo hojea). pop saca el primer elemento y retorna su valor push agrega un elemento a la pila search busca el elemento recibido y retorna un entero con su posición (si no esta retorna -1) La forma en que almacene los elementos fue por medio de nodos simplemente encadenados (explicado de forma general en otro post) :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= clase Nodo public class Node<E>{         E element;         Node next;         public Node(E elem, Node link){             element = elem;             next = link;         }     } no hay encapsulamiento puesto que la clase Node es una subclase de Stack :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= Atributos -> Node first referencia al primer nodo -> int size longitud de la pila :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= Metodos -> empty se puede implementar de dos maneras; la primera, mirar si el valor del atributo size es 0: public boolean empty(){      return size == 0 ; } la segunda, mirar si el elemento del primer nodo es nulo: public boolean empty(){      return first.element ==  null; } las dos son bastante sencillas -> peek retornara el valor del primer elemento, sin sacarlo de la pila: public E peek(){      return first.element; } -> pop remueve el primer elemento de la pila, retornando su valor: public E pop(){         E temp = first.element;  //guardamos el valor que vamos a retornar         first = first.next;             // "eliminamos" el nodo, diciéndole que el siguiente elemento sera el primer nodo         size--;                           //reducimos en uno el valor de la longitud         return temp;                  //retornamos el valor que habíamos guardado  } -> push agrega un elemento en la primera posición de la pila: public void push(E newElem){       Node newNode = new Node(newElem, first) //creamos un nodo con el dato recibido y una referencia del   que era el ultimo nodo       first = newNode      // ahora el primer nodo sera el que creamos       size++;                   // aumentamos en uno la longitud } -> search nos devuelve la posición del elemento que buscamos, si no se encuentra retorna -1 public int search(E toSearch){        Node current = first;         // nodo temporal que sera "recorrido"        for(int i=1; i < size ; i++){            if(current.element == toSearch) // evaluamos si es el nodo que buscamos               return i;                                   // retornamos su posición            current = current.next;               // continuamos con el siguiente       }           return -1;                                        // si no lo encontró retorna -1 } :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= Espero que les halla gustado, esta implementación también se puede hacer con vectores, pero a mi me gusta mas así , comenten cualquier duda

Buenas taringer@s, ya que mi anterior cuenta @j0rg3_l fue robada decidí crear esta para seguir subiendo dibujos... amvulante dijo: Soy un dibujante aficionado, hace cerca de un año me interese en el realismo y dibujo a dibujo sigo aprendiendo Este post es una recopilación de algunos de los dibujos que he hecho durante estos últimos 10 meses. Están organizados de forma cronológica :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= => Caballo Andaluz => grafito sobre lienzo => 35 x 45 :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= => Wolverine => grafito sobre papel Canson => 24 x 32 :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= Este fue un encargo, le puse marca de agua a las fotos pero no lo subi => Richard Wagner (un poco caricaturizado) => grafito sobre papel Canson => 24 x 32 :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= => rey Leonidas => grafito sobre papel Canson => 24 x 32 :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= => Gabriel Garcia Marquez => grafito sobre papel Canson => 24 x 32 :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= => Thor => grafito y colores sobre cartulina => 32 x 45 :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= Mi mas reciente dibujo de Andy Whitfield en su papel de Spartacus, se daño un poco la cartulina => Spartacus => grafito sobre cartulina => 32 x 45 :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:= Y por ultimo la certificada: Si pasan por los post de @j0rg3_l podrán ver algunos paso a paso y otros dibujos que ya no están en mis manos, gracias por pasar!.

Buenas, soy un estudiante de artes plásticas de segundo semestre y los dibujos que estoy publicando pertenecen a mi bitácora de Dibujo I (del semestre pasado). Solo subí algunos porque son muchos (la bitácora tiene 100 hojas). Todos los dibujos tienen el mismo formato, A4 (21 x 30 cm) papel canson, y la mayoría fueron hechos durante la clase, aprox. 2 horas. - Autorretrato: frente a un espejo,(tinta china). - Bananas: diferentes sombreados,(grafito). - Espacios negativos: debiamos dibujar un objeto industrial pero solamente trazando los espacios vacios y contornos,(lapiz). - Perrito (de la profe): eran dibujos rápidos porque el perro se movía mucho, este fue el que mas me gusto,(grafito). - Mano: es un es escorzo un poco dificil,(grafito). - Pies: nos quitamos los zapatos y ¡a dibujar!,(esfero negro). - Patio :debíamos dibujar arboles del patio, (esferos). - Whiskey :debiamos dibujar un vaso,( esferos). - Retrato sintetizado :este fue el ejercicio mas dificil, debíamos dibujar a un compañero con solo unas pinceladas, ( tinta china). - Movimiento :esto me pareció muy entretenido, lo hicimos dentro de una clase de arte danzario, debíamos dibujar rápido y captar los movimientos, (grafito). - Ojos : debiamos dibujar los ojos de un compañero, grafito - Dibujos con modelo : simplemente dibujar al modelo, (grafito y en algunos charcoal). - Alto contraste :la idea era reproducir una imagen de Sin City (aunque tendría que estar en la bitácora la hice aparte en un papel de mayor gramaje), (tinta china negra y amarilla). - Reproducciones: copias de los grandes maestros, (grafito y algunos charcoal). - Anatomía: estos son dibujos de 20-30 minutos que hice con modelos de CroquisCafe (un canal de youtube) , (charcoal). Ñapa Dos de mis escritores favoritos. J. R. R. Tolkien lo había dejé incompleto hace tiempo y esta semana decidí terminarlo Terminado Jorge Luis Borges Este lo hice hace un par de años (quedó raro ) Certificada (a mi bitácora se le dañó la tapa) Gracias por pasar! espero sus comentarios.

Hola, estos son algunos dibujos que he hecho para la facultad, algunos son copias de otros dibujos o fotografías y otros fueron dibujados con modelo en vivo . copia de un dibujo de la escuela rusa carbón vegetal y charcoal, papel edad media, 100x70 cm anatomía de una sirena vinilo en aguadas, papel propalcote, 100x62 cm ojos lápiz sepia, papel durex, formato A4 Angel? me inspiré en un cuento corto de García Márquez oleo sobre lienzo, 75x55 cm Jorge Luis Borges Tolkien grafito, papel durex, formato A4 ojo y oreja tinta china y pluma, cartón-cartulina, 35x25 cm copia de dibujo renacentista (no se de quien) tinta china y pluma, carton-catulina 25x25 cm nacimiento del gran rey mono( del libro peregrinación al oeste) grafito, papel canson, formato A4 :======================================================================== Estos son dibujos de mi bitácora, la mayoría son de anatomía, algunos los hice con modelo en vivo y otros a partir de fotos. Grafito y rapidógrafo, papel opalina, formato A4. eso es todo, espero que les haya gustado. certificada:

Bienvenidos En esta ocasión quiero compartirles un dibujo que hice la semana pasada del gran saxofonista John Coltrane. Acá su versión de Autumn Leaves: ========================================================================= ========================================================================= Materiales: - Papel opalina (A4) - Lapices grafito cretacolor - Tinta china - rapidografos ========================================================================= ========================================================================= Proceso: Empiezo con un boceto general rápido. No utilizo cuadricula, prefiero que mis ojos hagan todo el trabajo (aunque no quede tan exacto). empiezo a sombrear un ojo De aquí en adelante simplemente sigo sombreandoen esta imagen se alcanza a ver la textura del papelLlegando al cabello me di cuenta que necesitaba un material mas oscuro, por lo que opté por la tinta chinaresultado final: CertificadaEspero que les haya gustado!. Mi próximo retrato será de Miles Davis o de Thelonious Monk (no estoy seguro).

Bienvenidos ______________________________________________________________________ Como había planeado hace tiempo (quizás un año o más) dibujé a uno de mis pianistas favoritos, Thelonious Monk. Si aún no han tenido el placer de escucharlo: link: https://www.youtube.com/watch?v=wqHe50_tBVc _______________________________________________________________________ Materiales Lapices grafito cretacolor 2h, b, 2b, 4b, 7b, 9b. Borrador moldeable Difumino Rapidógrafos Tinta china Winsord and Newton pincel redondo de pelo de marta n°0 Libreta de cartulina opalina 23x28 cm _________________________________________________________________________ Sin más les muestro el proceso del dibujo o, mas bien, parte de él ya que perdí las primeras fotos donde hice el boceto y empecé el sombreado, pero bueh... aquí esta el resto: __________________________________________________________________ Resultado final para verlo en mejor calidad den clic derecho encima -> abrir imagen en otra pestaña. Certificada (con la cam de mi cel ): _________________________________________________________________ mi anterior dibujo de John Coltrane (en el post esta el proceso) https://www.taringa.net/posts/arte/19560955/Dibujando-al-inigualable-John-Coltrane.html devianart: https://inefabl3.deviantart.com/ instagram(recién creado): https://www.instagram.com/i.n.e.ff.a.b.l.e/ Mi próximo dibujo jazzero será de Chet Baker. Espero que les haya gustado, gracias por pasar.