Mostrando las entradas con la etiqueta arrays. Mostrar todas las entradas
Mostrando las entradas con la etiqueta arrays. Mostrar todas las entradas

lunes, 30 de diciembre de 2013

Tutorial Java en Linux Basico 3

Vectores y matrices

En java podemos definir arrays igual que en otros lenguajes de programación,los mas sencillos son los vectores,arrays unidimensionales. Un arreglo sea de una dimensión o de dos o mas es una agrupación de valores del el mismo tipo(en Java).

Un array lo usamos para agrupar datos relacionados,no necesariamente relacionados pero es para lo que se usaría comúnmente,un array se define como un tipo de dato solo que lo que lo diferencia es que lo definimos junto con una pareja de corchetes ,por ejemplo un array de strings de una dimensión(vector) con 6 elementos:

String [] arrayS;

o

String arrayS [];

Un vector se crea como un objeto,con la palabra new pero se le pasa el numero de elementos que vamos a crear dentro de otros corchetes por ejemplo, 5 palabras:

arrayS = new String[5];

 Luego podemos definir cada valor comenzando desde 0:

arrayS[0] = "Palabra1";arrayS[1] = "Palabra2";...
También podemos hacerlo mas sencillo:

String arrayS []  = new String[5];
Bueno eso es el estilo de definición solamente,pero también contamos con la definición al mismo tiempo,para hacer esto usamos una pareja de  ({}),y no necesitamos decir el numero de elementos,esto se hace automático por el sistema(compilador):

String [] arrayS = {"Palabra1","Palabra2","..."};

Como decía en el tutorial anterior los vectores se pasan por referencia,así que si le pasamos un valor a una función puede modificar el valor:


1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
 * Archivo Ejemplo.java
 * Ejecuta : javac Ejemplo.java && java Ejemplo
 * @author Atheyus
 *
 */

public class Ejemplo {
	
	public static void main(String[] args) {
		String [] arrayS = {"Palabra1","Palabra2","..."};
		System.out.println("Valor 1 antes de la funcion : "+arrayS[1]); // Vale 10
		cambiar(arrayS);
		System.out.println("Valor 1 despues de la funcion : "+arrayS[1]); // Vale 10

	}
	
	private static void cambiar(String [] x) {
		System.out.println("Valor 1 en la funcion antes del cambio : "+x[1]); // Vale 10
		x[1] = "Cambio";
	}

}


Para los arrays tenemos varias funciones,algunas que se heredan de un nivel mas alto,la mas importante(que no es una funcion):

length

Que devuelve el numero de elementos del array:

Una función para recorrer los valores de un vector seria esta:


1
2
3
4
5
6
private static void recorre(String [] x) {
	for (int i = 0;i < (x.length);i++ ){
		System.out.println("Numero "+i+" :"+x[i]);
	}
        System.out.println("Ultimo valor :"+x[x.length-1]); // Para obtener el ultimo valor se usa esta solucion
}


Los vectores pueden ser de cualquier dato,siempre y cuando sea el mismo tipo.

Matrices

Una matriz es un array bidimensional,el cual se define igual que un vector pero con el doble de corchetes,podemos decir que es un vector de vectores:

Para no complicar mucho vamos a crear un valor de dos filas(primera dimension) y dos columnas
(segunda dimensión):


1
2
3
4
5
String[][] matrizS = new String[2][2];
matrizS[0][0] = "Palabra uno fila 1";
matrizS[0][1] = "Palabra dos fila 1";
matrizS[1][0] = "Palabra uno fila 2";
matrizS[1][1] = "Palabra dos fila 2";


Eso es todo,ahora podemos acceder a sus valores,solamente que hay que tratar la primera dimencion como un vector no como un valor en si:

Si quisiéramos saber el numero de elementos de la primera fila haríamos esto:

matrizS[0].length();

También podemos usar una definición,de una sola linea,solo que debemos subir un nivel en ({}):


1
2
String [][] matrizS = {{"Palabra uno fila 1","Palabra dos fila 1"},
{"Palabra uno fila 2","Palabra dos fila 2"}};

Como lo consultamos?

Fácil,el algoritmo que yo uso(que aprendí en C) lo usamos creando un bucle anidado en cada nivel es una dimensión,esto es bueno porque he visto arrays de mas de tres dimensiones:

Solución:


1
 2
 3
 4
 5
 6
 7
 8
 9
10
private static void recorre(String[][] x) {

	for (int i = 0; i < x.length; i++) {
		int columnas = x[i].length;
		System.out.println("Fila : "+(i+1));
		for (int o = 0; o < columnas; o++) {
			System.out.println("Valor : "+x[i][o]);
		}
	}
}



Bien,como dije arriba los arrays tienen funciones pero estas son inútiles a excepción de length que no es una función si no que es una variable,pero Java nos ofrece una biblioteca muy buena para usar algunas funciones sobre nuestros arrays de una dimensión:

Primero debemos importar:

import java.util.Arrays;


Para ordenar un vector alfabéticamente o en orden asendente(numeros):

Arrays.sort(vector);
Como dije los valores de los vectores se pasan por referencia,por lo que no hay porque hacer esto:

ejem = Arrays.sort(ejem); // no
sort también tiene constructores mas avanzados,los veremos en su momento.

Arrays.toString(vector)

Esa función devuelve una String que representa el vector.

Arrays.equals(vector1,vector2)

Esa función devuelve un boolean para saber si dos vectores son iguales.

 De momento es todo, existen algunas cosas un poco mas avanzadas y utiles como son los diccionarios y las listas ademas de las funciones avanzadas de la clase Arrays,pero lo veremos en su momento :D.

Codigo completo: Vectors y Matrices
Leer más...

domingo, 23 de junio de 2013

Saber el numero mayor de un array Perl

En ocasiones necesitamos saber cual es valor mas alto numéricamente hablando,de un array o de un hash,en esta ocasion veremos los array,el algoritmo es simple:

1.Definir un valor a 0

2.Recorrer el array y comparar el valor de cada elemento con el de 0.

3.Como es obvio esperar un valor mayor a 0 cambiamos el valor de 0 al valor del elemento del array.

4.Regresamos al paso 2

Eso en Perl luce asi:



 #!/usr/bin/env perl  
 my @prueba = ( 8,1,2,2,6881);  
 print num_mayor(@prueba),"\n";  
 sub num_mayor  
 {  
   my @array = @_;  
   my ($n,$mayor) = (0,0); # Definimos dos numeros para trabajar el bucle  
   while ($n < scalar(@array)) # Recorremos el array  
   {  
     if ($mayor >= $array[$n]) # Vemos si es mayor o igual  
     {  
       $mayor = $mayor; # Si es asi sigue teniendo su valor  
     }  
     else # Si no es asi  
     {  
       $mayor = $array[$n]; # Obviamente es menor y le ponemos un nuevo valor  
     }  
     $n+=1; # Interaccion  
   }  
   return $mayor if ($mayor != 0); # Regresamos valor si no es 0  
 }  


Es simple el algoritmo,y podemos hacerlo en C,PHP,Lua,Javascript,etc,por ejemplo en ruby:


O en python me gusta usar un "truco",voltear la lista y imprimir el primer valor que debería ser el numero mayor:

 #!/usr/bin/env python3  
 prueba = [2,4,3,222,12]  
 def num_mayor(x):  
   mayor = sorted(x)  
   mayor = mayor[::-1]  
   return mayor[0]  
 print (num_mayor(prueba))  

En perl no se si existen estas funciones,porque hemos hablado de pop,shift,etc pero trabajan diferente,de todas formas me gusta parsear,para ver como funcionan las funciones del lenguaje de programación :D.

Espero que les sirva.
Leer más...

miércoles, 27 de marzo de 2013

Tutorial Array de Arrays Perl Unix


Creo que ya hemos hablado de listas de listas en Python ahora vamos a hablar un poco de como se crean estructuras de arrays verticales,osea Arrays de Arrays o como les digo Arrays anidadas,esto nos servirá para almacenar datos en una sola lista de arrays y no perdernos tanto cuando ya tenemos cierto numero de arreglos en nuestro script/programa, por ejemplo si ya tengo dos arreglos de dos versiones de sistemas:

my @windows = ("XP","Vista","Seven");

Y uno de Mac:

my @Mac = ("Leopard","Lion","Tiger");

Podemos meterlos en otro array que se llame sistemas, por ejemplo

my @sistemas = # Seguir leyendo

Para crear un llamado array anidado debemos definir primero nuestros arrays horizontales,como lo hice arriba, y después llenar el array con esta sintaxis

my @ArrayDarrays = (\@array1,\@array2,\@etc);

Este carácter (\) se usa para referenciar un valor,en este caso estamos referenciando dos array's a otro.

Para llamar nuestros arrays es igual que siempre:

print "$array[valor]"; 

Como vimos anteriormente en donde valor es el numero del elemento del array,contando de izquierda a derecha comenzando por el cero.

En los Arrays anidados es así

$arrayA[Avalor][valor]; # (A es Anidado)

El Avalor es el valor del array dentro del array anidado,igual partiendo de izquierda a derecha desde el cero,y en el valor es el valor del array del Avalor,por ejemplo:

¿esto que da como resultado?

#/usr/bin/env perl

use strict;

my @sistemas = qw(Mac Windows);
my @windows = qw(XP Vista Seven);
my @Mac = qw(Leopard Lion Tiger);

my @OS = (\@sistemas,\@windows,\@Mac);

print "Mi sistema de escritorio es " . "$OS[2][1]" . " de " . "$OS[0][0]\n";


Si pensaste que la respuesta es

Mi sistema de escritorio es XP de Windows

Estas equivocado,la respuesta es



Mi sistema de escritorio es Lion de Mac

Aunque uso Gentoo....

Bien,para recorrer todo el Array de Arrays lo hacemos igual que con un array normal,solo que también anidado,por ejemplo foreach anidado en while:






Esto lo vamos a ver cuando haga un tutorial de referencias,ya que no lo he hecho,pero aqui les dejo un ejemplo que esta hasta abajo de como es una referencia simple


#/usr/bin/env perl

use strict;

my @sistemas = qw(Mac Windows);
my @windows = qw(XP Vista Seven);
my @Mac = qw(Leopard Lion Tiger);
my @OS = (\@sistemas,\@windows,\@Mac);

print "Mi sistema de escritorio es " . "$OS[2][1]" . " de " . "$OS[0][0]\n";

my $i = 0; my $n = 0;

while ($i < $#OS+1 ) {
foreach $n (0..@{$OS[$i]}-1) {
print "Mi sistemas son $OS[$i][$n]\n";
}
$i+=1;
}
my $referencia = \@OS;
print "Referencia" . " $referencia->[0]->[0]" . "\n";


Leer más...

lunes, 5 de noviembre de 2012

Tutorial perl desde Unix variables arrays


Esta es una parte de nuestros tutoriales perl y en este caso veremos variables,como he dicho hay distintos tipos de variables en perl y en este caso veremos los arrays.

Este tutorial sera muy corto ya que el uso de arrays es muy fácil pero eso no quiere decir que el uso que le demos sea pequeño,el uso que le demos puede ser muy grande aunque este tutorial sea pequeño.

Que son los arrays?

Los arrays son arreglos,son listas de datos que podemos usar o llamar cuando queramos,los arrays a diferencia de los escalares se definen con @ en ves de $ y los datos que contienen se definen adentro de comillas ya sean simples o dobles y separados por comas ademas de que deben ir adentro de paréntesis () 

Ejemplo de definición:

my @arreglo = ( 'dato1',
'dato2',
'dato3'
);

Para hacer una consulta se tiene que definir cual dato vamos a llamar de nuestra array,esta consulta se hace como si de un vector se tratara, iniciando por el cero de izquierda a derecha

dato1 = 0 

dato2 = 1

etc

Pero antes lo tenemos que definir en una variable:

Ejemplo de definición:

my $variable = $arreglo[0];

Ya sabiendo eso podemos ver el ejemplo de consulta

Ejemplo de consulta(mostrar todo):


print @arrgelo;

Ejemplo de consulta(mostrar solo algunos datos):


my $dato1= $arreglo[0];

print "$dato1\n"

Ejemplo de ambas consultas en un script:

#!/usr/bin/env perl

my @sistemas = ('GNU/Linux',
'FreeBSD',
'OS X',
'iOS');

my $sistema1= $sistemas[0];

my $sistema2= $sistemas[1];

my $sistema3= $sistemas[2];

my $sistema4= $sistemas[3];

print "@sistemas\n";

print "$sistema1\n";

print "$sistema2\n";

print "$sistema3\n";

print "$sistema4\n";




Eso es todo,sobre el manejo de datos con arrays en perl.

Leer más...