domingo, 5 de agosto de 2012

Lista de repeticiones de una cadena dentro de otra

import List

esPrefijoDe :: [Char] -> [Char] -> Bool
esPrefijoDe [] _ = True
esPrefijoDe _ [] = False
esPrefijoDe (x:xs) (y:ys) | x/=y = False
                          | otherwise = esPrefijoDe xs ys

posicionsub :: [Char] -> [Char] -> Int
posicionsub _ [] = -1
posicionsub (x:xs) (y:ys) | esPrefijoDe (x:xs) (y:ys) = 1
                          | otherwise =  1 + posicionsub (x:xs) ys

sumador :: [Int] -> [Int]
sumador [] = []
sumador [x] = [x]
sumador (x:y:[]) = [x] ++ [x+y]
sumador (x:y:xs) = [x] ++  sumador ([x+y] ++ xs)

busquedas3 :: [Char] -> [Char] -> [Int]
busquedas3 _ [] = []
busquedas3 xs (y:ys) | pos+1<length(ys)+1 = [pos] ++ busquedas3 xs (drop (pos-1) ys)
                     | otherwise = busquedas3 xs ys
  where pos = posicionsub xs (y:ys)

busquedas4 :: [Char] -> [Char] -> [Int]
busquedas4 xs ys = sumador(busquedas3 xs ys)

Combinaciones sin repetición en Haskell

import List

comb :: Int -> [a] -> [[a]]
comb 0 _ = [[]]
comb _ [] = []
comb (n+1) (x:xs) =  [x:ys | ys <-comb n xs] ++ comb (n+1) xs

miércoles, 25 de julio de 2012

Relación de ejercicios argentina en Haskell

https://dl.dropbox.com/u/30592764/haskell/practico2.pdf
El 8 está chulo, muchos ejercicios cortitos.

Técnicas de programación recursiva en Haskell

4. Técnicas de programación Recursiva

En esta sección se indicarán varios patrones de tratamiento de estructuras recursivas. Estos patrones se aplicarán principalmente a listas, pero muchos de ellos pueden generalizarse a otras estructuras como árboles, rosales, etc.

4.1. Aplicar una función a cada elemento

Ejemplo (aplica)
> aplica :: (a -> b) -> [a] -> [b]
> aplica f [] = []
> aplica f (x:xs) = f x : aplica f xs


Nota: La función aplica está predefinida como la función map

4.2. Recorrer y transformar una estructura en un valor

Obsérvese la definición de las siguientes funciones
Ejemplo (sumaLs)
> sumaLs :: Num n => [n] -> n
> sumaLs [] = 0
> sumaLs (x:xs) = x + sumaLs xs


Ejemplo (prodLs)
> prodLs :: Num n => [n] -> n
> prodLs [] = 1
> prodLs (x:xs) = x * prodLs xs


Ejemplo (longLs)
> longLs :: Num n => [a] -> n
> longLs [] = 0
> longLs (x:xs) = 1 + longLs xs


En la definición de las siguientes funciones, puede observarse que se utiliza siempre un mismo patrón. Un caso básico cuando la lista está vacía, cuyo valor es 0, 1 y 0; y un caso recursivo en el cual se realiza una operación combinando el elemento x con el resultado de la llamada recursiva. La operación, en el primer caso es \x r -> x + r, en el segundo caso es \x r -> x * r y en el último caso es \x r -> 1 + r.
El patrón descrito podría generalizarse en una función foldRight que tome como parámetros el valor e a devolver en el caso básico y la operación op a realizar en el caso recursivo.
Ejemplo (foldRight)
> foldRight :: (a -> b -> b) -> b -> [a] -> b
> foldRight op e [] = e
> foldRight op e (x:xs) = x `op` foldRight op e xs


?-foldRight (+) 0 [2,3,4]9
Nota: La función foldRight está predefinida como la función foldr
A partir de la función foldr, pueden redefinirse las funciones sumaLs,prodLs y longLs.
Ejemplo (sumaLs')
> sumaLs' = foldr (+) 0


Ejemplo (prodLs')
> prodLs' = foldr (*) 1


Ejemplo (longLs')
> longLs' = foldr (\x r -> 1 + r) 0


Además de las funciones anteriores, existen numerosas funciones que trabajan sobre listas y que pueden definirse a partir de la función foldr
Ejemplo (andLs)
> andLs :: [Bool] -> Bool
> andLs = foldr (&&) True


Nota: La función andLs está predefinida como la función and
Ejemplo (orLs)
> orLs :: [Bool] -> Bool
> orLs = foldr (||) False


Nota: La función orLs está predefinida como la función or
Ejemplo (append)
> append :: [a] -> [a] -> [a]
> append xs ys = foldr (\x r -> x : r) ys xs


Nota: La función append está predefinida como el operador (++)
Ejemplo (vuelta)
> vuelta :: [a] -> [a] 
> vuelta = foldr (\x r -> r ++ [x]) []


Nota: La función vuelta está predefinida como la función reverse
Ejemplo (tomaMientras)
> tomaMientras :: (a -> Bool) -> [a] -> [a] 
> tomaMientras f = foldr (\x r -> if f x then x:r else []) []


?-tomaMientras (>3) [6,5,2,4,1] [6,5]
Nota: La función tomaMientras está predefinida como la función takeWhile
Ejemplo (filtra)
> filtra :: (a -> Bool) -> [a] -> [a] 
> filtra f = foldr (\x r -> if f x then x:r else r) []


?-filtra (>3) [6,5,2,4,1] [6,5,4]
Nota: La función filtra está predefinida como la función filter

4.3. Combinar dos estructuras

Ejemplo (comb)
> comb :: [a] -> [b] -> [(a,b)]
> comb xs [] = []
> comb [] ys = []
> comb (x:xs) (y:ys) = (x,y):comb xs ys


?-comb [2,3,4] "hola"[(2,'h'),(3,'o'),(4,'l')]
Nota: La función comb está predefinida como la función zip

4.4. Listas intensionales

El lenguaje Haskell admite una notación que facilita la definición de listas. Esta notación es similar a las definiciones matemáticas intensionales
Ejemplo (cpares20)
La función cpares20 calcula los cuadrados de los números pares entre 1 y 20
> cpares20 :: [Integer]
> cpares20 = [x ^ 2 | x <- [1..20], x `mod` 2 == 0]


?-cpares20[4,16,36,64,100,144,196,256,324,400]
Ejemplo (divisores)
La función divisores calcula los divisores de un número
> divisores :: Integer -> [Integer]
> divisores n = [d | d <- [1..n], n `mod` d == 0]


?-divisores 24[1,2,3,4,6,8,12,24]

4.5. Otras posibilidades de recorrer y transformar una lista en un valor

La función foldr actúa de la siguiente forma:
foldr op e [x1,x2,x3] = x1 `op` (x2 `op` (x3 `op` e)) 
Como puede observarse, la operación se asocia hacia la derecha. El nombre foldr viene de fold-right, a la derecha.
Es posible definir una función fold-left que se denominará foldl y realiza la asociación a la izquierda.
foldl op e [x1,x2,x3] = ((e `op` x1) `op` x2) `op` x3
Ejemplo (foldLeft)
> foldLeft :: (b -> a -> b) -> b -> [a] -> b
> foldLeft op e [] = e
> foldLeft op e (x:xs) = foldLeft op (e `op` x) xs


?-foldLeft (+) 0 [1,3,4]8
Nota: La función foldLeft está predefinida en Haskell como foldl
Cuando la operación op es asociativa y e es el elemento neutro de op, se cunple que:
foldr op e = foldl op e
En general, foldr es más eficiente que foldl. Sin embargo, foldl puede ser útil en cierto tipo de definiciones
Ejemplo (ls2n)
La función ls2n convierte una lista de dígitos en un número decimal
> ls2n :: [Integer] -> Integer
> ls2n = foldl (\r a -> r * 10 + a) 0


?-ls2n [1,3,4]134
Si las listas no están vacías, puede ser necesario aplicar la operación sobre los elementos sin utilizar un elemento básico. Los operadores foldr1 y foldl1 actúan de la siguiente forma:
foldr1 op [x1,x2,x3] = x1 `op` (x2 `op` x3)
foldl1 op [x1,x2,x3] = (x1 `op` x2) `op` x3
Ejemplo (maxLs)
La función maxLs devuelve el valor máximo de una lista de enteros
> maxLs :: [Integer] -> Integer
> maxLs = foldr1 max


?-maxLs [-1,-3,-4]-1

4.6. Recorrer y transformar una estructura generando resultados parciales

Los operadores predefinidos scanr, scanl, scanr1 y scanl1 recorren la lista generando resultados parciales de la siguiente forma:
scanr op e [x1,x2,x3] = 
   [x1 `op` (x2 `op` (x3 `op` e)), x2 `op` (x3 `op` e), x3 `op` e, e]
scanl op e [x1,x2,x3] = 
   [e, e `op` x1, (e `op` x1) `op` x2, ((e `op` x1) `op` x2) `op` x3]
scanr1 op e [x1,x2,x3] = 
   [x1 `op` (x2 `op` x3), x2 `op` x3, x3]
scanl1 op e [x1,x2,x3] = 
   [x1, x1 `op` x2, (x1 `op` x2) `op` x3]
Ejemplo (ruffini)
La función ruffini aplica la regla de ruffini
> ruffini :: Float -> [Float] -> [Float]
> ruffini a = scanl1 (\r x -> r * a + x) 


?-ruffini 3 [2,4,3][2,10,33]

4.7. Generar una estructura

La generación de una lista a partir de un valor puede capturarse mediante la siguiente función
Ejemplo (unfold)
La función unfold realiza el proceso inverso a la función foldr
> unfold :: (a -> Bool) -> (a -> b) -> (a -> a) -> a -> [b]
> unfold p f g x = if p x then [] 
>                  else f x : unfold p f g (g x)


Ejemplo (d2b)
La función d2b convierte un número decimal en su representación binaria
> d2b :: Integer -> [Integer]
> d2b = reverse . unfold (==0) (`mod` 2) (`div` 2)  


?-d2b 13[1,1,0,1]
Ejemplo (pals)
La función pals convierte devuelve la lista de palabras que forman una cadena de caracteres
> pals :: String -> [String]
> pals = palsAux . quitaEsp
>   where palsAux  = unfold (=="") tomaPal quitaPal
>         tomaPal  = takeWhile (not . esp)
>         quitaPal = quitaEsp . dropWhile (not . esp)
>         quitaEsp = dropWhile esp
>         esp x    = x == ' ' || x == '\n'


?-pals "mi perro es listo"["mi","perro","es","listo"]

4.8. Otras estructuras recursivas

Los combinadores definidos en las secciones anteriores pueden generalizarse para otras estructuras recursivas.
Ejemplo (foldA)
La función foldA recorre y transforma un árbol en un valor
> foldA :: (a -> b -> b -> b) -> b -> Arbol a -> b
> foldA f e Hoja = e
> foldA f e (Rama x i d) = f x (foldA f e i) (foldA f e d)


La función sumaArbol calcula la suma de los nodos de un árbol
> sumaArbol :: Num n => Arbol n -> n
> sumaArbol = foldA (\x i d -> x + i + d) 0


?-sumaArbol a114
La función nodosArbol devuelve la lista de nodos de un árbol
> nodosArbol :: Arbol a -> [a]
> nodosArbol = foldA (\x i d -> [x] ++ i ++ d) [] 


?-nodosArbol a1[3,4,5,2]
Ejemplo (foldRosal)
La función foldRosal recorre y transforma un rosal en un valor
> foldRosal :: (a -> [b] -> b) -> b -> Rosal a -> b
> foldRosal f e Vacio = e
> foldRosal f e (Nodo x ls) = f x (map (foldRosal f e) ls) 


La función sumaRosal calcula la suma de los nodos de un rosal
> sumaRosal :: Num n => Rosal n -> n 
> sumaRosal = foldRosal (\x ls -> x + sum ls) 0



La función nodosRosal devuelve la lista de nodos de un rosal
> nodosRosal :: Rosal a -> [a]
> nodosRosal = foldRosal (\x ls -> [x] ++ concat ls) []


Nota: Sería deseable definir una función fold genérica que recorriese y transformase todo tipo de estructuras recursivas. Aunque Haskell no permite este tipo de definiciones, existe una extensión del lenguaje denominada Generic Haskell que permite definir funciones genéricas, también denominadas politípicas.

4.9. Combinadores recursivos básicos

Muchas estructuras recursivas básicas que en otros lenguajes están predefinidas, pueden ser definidas por el usuario
Ejemplo (hasta)
La función hasta captura un patrón recursivo básico
> hasta :: (a -> Bool) -> (a -> a) -> a -> a
> hasta p f x = if  p x then x 
>               else hasta p f (f x)


PDF con funciones recursivas básicas en Haskell

Lista de divisores en Haskell recursiva

divisores:: Int -> [Int]
divisores n = divisoresDesde n 1
divisoresDesde:: Int -> Int -> [Int]
divisoresDesde n m
|n == m = [n]
|n > m && (n `mod` m == 0) = m:(divisoresDesde n (m+1))
|n > m && (n `mod` m /= 0) = divisoresDesde n (m+1)
Segundo Cuatrimestre

Máximo de una lista en Haskell recursivo

maximo:: Int -> [Int] -> Int
maximo [] = error"No hay maximo"
maximo [x] = x
maximo (x:xs)
| x < maximo xs = maximo xs
| x >= maximo xs = x

Longitud de una lista en Haskell recursiva

longitud:: [a] -> Int
longitud [] = 0
longitud (x:xs) = 1 + longitud xs

Introducción a Haskell

Haskell (/ˈhæskəl/) es un lenguaje de programación estandarizado multi-propósito puramente funcional con semánticas no estrictas y fuerte tipificación estática. Su nombre se debe al lógico estadounidense Haskell Curry. En Haskell, "una función es un ciudadano de primera clase" del lenguaje de programación. Como lenguaje de programación funcional, el constructor de controles primario es la función. El lenguaje tiene sus orígenes en las observaciones de Haskell Curry y sus descendientes intelectuales.
Las características más interesantes de Haskell incluyen el soporte para tipos de datos y funciones recursivas, listas, tuplas, guardas y calce de patrones. La combinación de las mismas pueden resultar en algunas funciones casi triviales cuya versión en lenguajes imperativos pueden llegar a resultar extremadamente tediosas de programar. Haskell es, desde 2002, uno de los lenguajes funcionales sobre los que más se ha investigado. Se han desarrollado muchas variantes:
  • Versiones paralelas del MIT y Glasgow, ambas denominadas Parallel Haskell.
  • Más versiones paralelas y distribuidas de Haskell llamadas Distributed Haskell (anteriormente Goffin) y Eden
  • Una versión con ejecución especulativa: Eager Haskell
  • Varias versiones orientadas a objetos: Haskell++, O'Haskell y Mondrian.
  • Una versión educativa llamada Gofer desarrollada por Mark Jones que fue suplantada por Hugs (ver abajo).

domingo, 26 de febrero de 2012

Diseño de bases de datos Modelo Entidad Relación Ejercicio 2 Empleados y...

Software para crear diagramas del modelo Entidad Relación y capturar pan...

Diseño de bases de datos Modelo Entidad Relación Ejercicio 4 Clientes y ...

Diseño de bases de datos Modelo Entidad Relación Ejercicio 3 Futbolistas...

Diseño de bases de datos Modelo Entidad Relación Ejercicio 5 Personas Co...

Diseño de bases de datos Modelo Entidad Relación Ejercicio 6 Personas Co...

Diseño de bases de datos Modelo Entidad Relación Ejercicio 8 Coches y co...

Diseño de bases de datos Modelo Entidad Relación Ejercicio 9 Aula ordena...

Diseño de bases de datos Modelo Entidad Relación Ejercicio 10 Aula orden...

sábado, 18 de febrero de 2012

Shell Scritp Ejercicio bastante completito

#!/bin/bash
#TODOS LOS SCRIPTS EN http://oposinf.blogspot.com/search/label/shellscript
#Realizar un script llamado copiaSeg para gestionar el sistema centralizado de copias de seguridad de un servidor.
#El script sin parámetros hará una copia de segundad de todos los usuarios del sistema, y con el parámetro -u usuario hará una copia de seguridad de la información del usuario pasado como parámetro. Este script sólo podrá ser ejecutado por root. La sintaxis del script será:
#copiaSeg [-u usuario ]
#Los usuarios podrán utilizar el sistema de copias automatizado creando en su directorio de trabajo un fichero oculto, llamado copiaSeg.dat con el siguiente contenido:
#Copias que se desean mantener
#numeroCopias=2
#Contenido de la copia, único obligatorio
#contenidoCopia=dir1:dir2:fichero1:fichero2,,.
#En caso de que no exista alguno de los campos configurables anteriores, se usarán los valores por defecto, definidos en el propio script. El único campo obligatorio es el campo contenidoCopia,que contendrá todos los ficheros y directorios que se desean incluir en la copia.
#Si dicho campo no estuviese definido, no se copiaría nada para ese usuario.
#El sistema creará un directorio /copiaSeg y dentro un directorio por usuario, si no existiese, que sólo podrá ser accesible por su dueño. En el interior de este directorio se almacenarán tantas copias de seguridad copiaSeg_hhmmDDMMYYYY.tgz como defina numeroCopias. Paraque un fichero o directorio sea añadido a la copia debe ser de su propiedad.
#El script borrará las copias más antiguas manteniendo en el sistema sólo las que se indiquen en el fichero de configuración copiaSeg.dat y, si no está definido numeroCopias, lo que marque el valor por defecto.

function error {
    echo "¡¡Horror!! Uso "$0" [-u usuario]"
    exit
}

#capturar parámetros en variables
parametro=$1
nusuario=$2
#variables por defecto
numcopiaspordefecto=3
directoriocopiasgeneral="/copiaSeg"
carpetausuarios="/home"

#si no introducimos parámetros, se hace la copia de seguridad completa
if [ "$parametro" = "" ]
then
    echo "Entrando en copia de seguridad completa"
    #comprobar si existe la carpeta
    if [ -d $directoriocopiasgeneral ]
    then
        echo "El directorio general de copias existe. Se sigue el proceso."
    else
        echo "El directorio no existe. Se crea."
        sudo mkdir $directoriocopiasgeneral
        if [ $? -ne 0 ]
        then
            echo "Error al crear el directorio. Seguramente, no tienes permiso para copiar en él"
            echo "Saliendo del programa"
            exit
        fi
    fi
    #calcula el número de copias realizadas
    #lista solo los archivos que hay en el directorio raiz y cuenta el número de líneas
    numcopiashechas=`ls -p $directoriocopiasgeneral | grep -v / | wc -l`
    echo $numcopiashechas
    #si se ha llegado al límite de número de copias
    if [ "$numcopiashechas" -eq "$numcopiaspordefecto" ]
    then
        #busca la más antigua
        ficheromasantiguo=`ls -ptr $directoriocopiasgeneral | grep -v / | head -1`
        #y la borra
        sudo rm $directoriocopiasgeneral/$ficheromasantiguo
    else
        #no se hace nada
        echo -n
    fi
    #genera nombre del archivo
    hora=`date +%H`
    minutos=`date +%M`
    dia=`date +%d`
    mes=`date +%m`
    ano=`date +%Y`
    nombrecopia=`echo copiaSeg_$hora$minutos$dia$mes$ano.tgz`
    echo $nombrecopia
    #cambia nombre carpeta para pruebas
    carpetausuarios="/home/jluserovilchez/Escritorio/scripts"
    sudo tar -czf "$directoriocopiasgeneral/$nombrecopia" "$carpetausuarios"
   
#si el parámetro es -u
elif [ "$parametro" = "-u" ]
then
    #y el usuario no es vacío
    if [ "$nusuario" != "" ]
    then
        echo "Entrando en copia de seguridad de usuario"
        echo $nusuario
        #crear carpeta de usuario si no existe
        if [ -d $directoriocopiasgeneral/$nusuario ]
        then
            #si existe, no se crea
            echo -n
        else
            #si no existe, se crea
            sudo mkdir $directoriocopiasgeneral/$nusuario
        fi
        #buscar archivo copiaSeg.dat en carpeta de usuario
        #si existe carpeta de usuario
        if [ -d /home/$nusuario ]
        then
            #buscar el archivo oculto de usuario
            if [ -e "/home/$nusuario/.copiaSeg.dat" ]
            then
                echo "El fichero copiaSeg.dat existe"
                existecontenidoCopia=`cat /home/$nusuario/.copiaSeg.dat | grep "contenidoCopia"`
            #echo $existecontenidoCopia
            if [ "$existecontenidoCopia" = "" ]
            then
                echo "No existe contenidoCopia"
                echo "Defina la variable contenidoCopia en el archivo copiaSeg.dat para seleccionar archivos. Copiando todos los archivos del usuario."
                numcopias=$numcopiaspordefecto
            #comienzo de copia de archivos
                numcopiashechas=`ls -p $directoriocopiasgeneral/$nusuario | grep -v / | wc -l`
                echo $numcopiashechas
                #si se ha llegado al límite de número de copias
                if [ "$numcopiashechas" -eq "$numcopiaspordefecto" ]
                then
                    #busca la más antigua
                    ficheromasantiguo=`ls -ptr $directoriocopiasgeneral/$nusuario | grep -v / | head -1`
                    #y la borra
                    sudo rm $directoriocopiasgeneral/$nusuario/$ficheromasantiguo
                else
                    #no se hace nada
                    echo -n
                fi
                #genera nombre del archivo
                hora=`date +%H`
                minutos=`date +%M`
                dia=`date +%d`
                mes=`date +%m`
                ano=`date +%Y`
                nombrecopia=`echo copiaSeg_$hora$minutos$dia$mes$ano.tgz`
                echo $nombrecopia
                #cambia nombre carpeta para pruebas
                carpetausuario="/home/jluserovilchez/Escritorio/scripts"
                #descomentar siguiente línea para funcionamiento real
                #carpetausuario="/home/$nusuario"
                sudo tar -czf "$directoriocopiasgeneral/$nusuario/$nombrecopia" "$carpetausuario"
            #fin copia todos los archivos del usuario
           
            else
                #comienzo copia de seguridad archivos elegidos por usuario
                echo "Sí existe contenidoCopia"
                echo "Obteniendo número de copias por defecto para usuario $nusuario"
                existencopias=`cat /home/$nusuario/.copiaSeg.dat | grep "numeroCopias"`
                echo "Existencopias:$existencopias"
                if [ "$existencopias" = "" ]
                then
                    echo "No existe número de copias. Valor por defecto $numcopiaspordefecto"
                    numcopias=$numcopiaspordefecto
                else
                    echo "Sí existe número de copias"
                    numcopias=`cat /home/$nusuario/.copiaSeg.dat | head -1 | awk -F= '{print $2}'`
                    echo $numcopias
                fi
                numcopiashechas=`ls -p $directoriocopiasgeneral/$nusuario | grep -v / | wc -l`
                echo $numcopiashechas
                #si se ha llegado al límite de número de copias
                if [ "$numcopiashechas" -eq "$numcopias" ]
                then
                    #busca la más antigua
                    ficheromasantiguo=`ls -ptr $directoriocopiasgeneral/$nusuario | grep -v / | head -1`
                    #y la borra
                    sudo rm $directoriocopiasgeneral/$nusuario/$ficheromasantiguo
                else
                    #no se hace nada
                    echo -n
                fi
                #genera nombre del archivo
                hora=`date +%H`
                minutos=`date +%M`
                dia=`date +%d`
                mes=`date +%m`
                ano=`date +%Y`
                nombrecopia=`echo copiaSeg_$hora$minutos$dia$mes$ano.tgz`
                echo $nombrecopia
                #cambia nombre carpeta para pruebas
                #carpetausuario="/home/jluserovilchez/Escritorio/scripts"
                #descomentar siguiente línea para funcionamiento real
                carpetausuario="/home/$nusuario"
                #sudo tar -czf "$directoriocopiasgeneral/$nusuario/$nombrecopia" "$carpetausuario"
                #obtener lista de archivos
                listaarchivos=`cat /home/$nusuario/.copiaSeg.dat | tail -1 | awk -F= '{print $2}'`
                echo $listaarchivos
                #separar carpetas y archivos
                arr=$(echo $listaarchivos | tr ":" " " | tr "," "\n")
                echo $arr
                cd $carpetausuario
                sudo tar -czvf "$directoriocopiasgeneral/$nusuario/$nombrecopia" $arr
                #código interesante para el futuro
                #for x in $arr
                #do
                #    echo "Copiando $x"
                #done
                #fin copia de seguridad archivos elegidos por usuario
            fi
            else
                echo "No existe el fichero copiaSeg.dat Creelo para definir los ficheros a copiar y el número de copias"
            fi
        else
            #si no existe carpeta de usuario
            echo "No existe carpeta de usuario. El usuario no existe"
        fi
    else
        #error por no introducir el nombre de usuario
        echo "No ha introducido nombre de usuario"
        error
    fi
else
    #error por introducir parámetro distinto de -u
    echo "El parámetro ha de ser -u. Parámetro incorrecto."
    error
fi

Shell Script AWK muy completo

viernes, 10 de febrero de 2012

Shell Script Ejemplos de GREP

#!/bin/bash
#TODOS LOS SCRIPTS EN http://oposinf.blogspot.com/search/label/shellscript
#1. Utilidad grep
#El fichero /etc/passwd es un fichero de texto que contiene información #acerca de las cuentas de usuario definidas en el sistema.
#Cada línea contiene siete datos, separados por el carácter ‘:’. Estos datos son: nombre de la cuenta, password encriptado (opcional), el código de usuario (user ID), el código del grupo (group ID), un comentario, el nombre del directorio ‘home’ y el nombre del intérprete de comandos que se ejecutará cuando el usuario se conecte.
#Vamos a utilizar este fichero en las cuestiones siguientes.
#1. Mostrad la línea correspondiente a la cuenta alu.
#2. Mostrad las cuentas que empiecen por a.
#3. Mostrad las cuentas que empiecen por a o r.
#4. Mostrad las cuentas que terminen por u.
#5. Mostrad las cuentas que usen bash como intérprete de comandos.
#6. Mostrad las cuentas que NO usen bash como intérprete de comandos.
#7. Mostrad las cuentas que no empiecen por vocal.
#8. Mostrad las cuentas que empiecen por mayúscula.
#9. Mostrad las líneas cuyo tercer campo tenga una sola cifra.
#10. Mostrad las líneas que tengan cifras de 3 a 5 dígitos.
#11. Mostrad las líneas que tengan cifras de 3 dígitos en el cuarto campo.
#12. Mostrad las cuentas root o de ftp.
#13. ¿Qué ficheros de cabecera usan la constante MAXDOUBLE?
#14. ¿En qué ficheros aparece la palabra bash? (En mayúscula o minúscula)

#1.como no existe alu, pongo man
echo "1.Cuenta MAN"
grep ^man /etc/passwd
#2.
echo "2.Cuentas que empiezan por a"
grep ^a /etc/passwd
echo "3. Cuentas que empiezan por a o r"
grep ^[ar] /etc/passwd
echo "4. Cuentas que terminan en z"
cat /etc/passwd | awk -F : '{print $1}' | grep z$
echo "5. Cuentas que usen bash como intérprete de comandos"
#cat /etc/passwd | awk -F : '{print $7}' | grep /bin/bash
cat /etc/passwd | grep /bin/bash$ | awk -F : '{print $1}'
echo "6. Mostrad las cuenta que no usen bash como intérprete de comandos."
cat /etc/passwd | grep -v /bin/bash$ | awk -F : '{print $1}'
echo "7. Mostrad las cuentas que no empiecen por vocal."
cat /etc/passwd | awk -F : '{print $1}' | grep ^[^aeiou]
echo "8. Mostrad las cuentas que empiecen por mayúscula."
cat /etc/passwd | awk -F : '{print $1}' | grep ^[A-Z]
echo "9. Mostrad las líneas cuyo tercer campo tenga una sola cifra."
cat /etc/passwd | awk -F : '{print $3}' | grep ^[0-9]$
echo "10. Mostrad las líneas que tengan cifras de 3 a 5 dígitos."
cat /etc/passwd | grep -E [0-9]\{3,5\}
echo "11. Mostrad las líneas que tengan cifras de 3 dígitos en el cuarto campo."
#cat /etc/passwd | awk -F : '{print $4}' | grep -E ^[0-9]{3}$
cat /etc/passwd | grep -E *:*:*:[0-9]{3}:
echo "12. Mostrar las cuentas root o de ftp."
cat /etc/passwd | grep -E '^(root|ftp)'
echo "13. ¿Qué ficheros de cabecera usan la constante MAXDOUBLE?"
#los ficheros de cabecera están en la carpeta /usr/include
grep -r MAXDOUBLE /usr/include 2>/dev/null
#14. ¿En qué ficheros aparece la palabra bash? (En mayúscula o minúscula)
echo "14. ¿En qué ficheros aparece la palabra bash? (En mayúscula o minúscula)"
grep -Er '(FILE|file)' /usr/include 2>/dev/null

Shell Script Ejemplos de sort

#!/bin/bash
#TODOS LOS SCRIPTS EN http://oposinf.blogspot.com/search/label/shellscript
#1. Ordenad el fichero /etc/passwd por orden alfabético.
#2. Ordenadlo en sentido inverso.
#3. Ordenadlo ignorando mayúsculas.
#4. Ordenadlo según el tercer campo.
#5. Ordenadlo según el tercer campo en orden numérico.
#6. Ordenadlo según el cuarto campo en orden numérico y eliminando repeticiones.

echo "Introduce una opción(1-6)"
read opcion
case $opcion in
    1)
     echo "Ordenad el fichero /etc/passwd por orden alfabético."
     sort /etc/passwd
     ;;
    2)
     echo "Ordenadlo en sentido inverso."
     sort -r /etc/passwd
     ;;
    3)
     echo "Ordenadlo ignorando mayúsculas."
     sort -f /etc/passwd
     ;;
    4)
     echo "Ordenadlo según el tercer campo."
     sort -t: -k 3 /etc/passwd
     ;;
    5)
     echo "Ordenadlo según el tercer campo en orden numérico."
     sort -g -t: -k 3 /etc/passwd
     ;;
    6)
     echo "Ordenadlo según el cuarto campo en orden numérico y eliminando repeticiones."
     sort -u -g -t: -k 4 /etc/passwd
     ;;
esac

Shell Script para ver select para recorrer lista de archivos

sábado, 4 de febrero de 2012

Bases de datos relacional, buena página

Apuntes de oposiciones TIC

Libro Fundamentos de bases de datos

Noticia Jedi en periódico

Religión Jedi, noticias

Iglesia Jedi, ¡la monda!

Jedi en Wikipedia

Generador de nombres Jedi

Religión Jedi

Examen Oposiciones 2008 Shell Script

#!/bin/bash
#TODOS LOS SCRIPTS EN http://oposinf.blogspot.com/search/label/shellscript
#OPOSICIONES CUERPOS DOCENTES 2008
#EJERCICIO PRÁCTICO - PLANTEAMIENTO
#El ejercicio práctico se realizará bajo sistema operativo LINUX. Se podrá hacer uso del comando man.
#Elabora un script para llamado informe.sh que muestre información sobre el uso del sistema que realiza un determinado usuario.mEl shell-script tendra la siguiente sintaxis:
#informe.sh opcion [usuario]
#Las opciones pueden ser –u y –a. Si la opción que recibe es –u, deberá recibir como segundo argumento un nombre de usuario.
#Si el script ser ejecuta de la primera forma (-u usuario), deberá presentar un informe del usuario que se ha pasado por parámetro. En el informe deberán aparecer los siguientes datos:
#· Nombre del usuario.
#· Número de procesos que ha lanzado.
#· Nombre del primer proceso que lanzó.
#· Listado de todos los procesos que ha lanzado.
#· Número de directorios que tiene.
#· Número de ficheros regulares que tiene.
#· Uso del espacio en disco que ocupa.
#· Tanto por ciento de espacio en disco usado por el usuario.

function error {
    echo "¡¡Horror!! Uso "$0" -[u|a] [usuario]"
    exit
}

function numprocesos() {
    echo "Contando procesos, $1..."
    usuario=$1
    numproc=`ps -U $usuario | wc -l`
    echo "Número de procesos del usuario $usuario:$numproc"
}

function numprocesostotal() {
    echo "Contando procesos totales"
    usuario=$1
    numproc=`ps | wc -l`
    echo "Número de procesos total:$numproc"
}

function procesomasantiguo() {
    echo "Buscando proceso más antiguo, $1..."
    usuario=$1
    ps -F -U $usuario | head -2 | tail -1 | awk '{print $11}'
}

function procesomasantiguototal() {
    echo "Buscando proceso más antiguo total"
    ps -F | head -2 | tail -1 | awk '{print $11}'
}

function listadoprocesos() {
    echo "Listando procesos de usuario, $1..."
    usuario=$1
    ps -F -U $usuario
}

function listadoprocesostotal() {
    echo "Listando procesos total"
    ps -F
}

function numdirectorios() {
    echo "Contando número de directorios, $1..."
    usuario=$1
    carpetausuario=`cat /etc/passwd | grep ^$usuario | cut -d: -f6`
    #ls -ldr $carpetausuario/*   
    find $carpetausuario -type d -ls | wc -l
}

function numdirectoriostotal() {
    echo "Contando número de directorios total"
    carpetausuario="/home"
    #ls -ldr $carpetausuario/*   
    find $carpetausuario -type d -ls | wc -l
}

function fichregulares() {
    echo "Número de ficheros regulares, $1..."
    usuario=$1
    carpetausuario=`cat /etc/passwd | grep ^$usuario | cut -d: -f6`
    find $carpetausuario -type f -ls  | wc -l
}

function fichregularestotal() {
    echo "Número de ficheros regulares total"
    carpetausuario="/home"
    find $carpetausuario -type f -ls  | wc -l
}

function espacioendisco() {
    echo "Espacio en disco, $1..."
    usuario=$1
    carpetausuario=`cat /etc/passwd | grep ^$usuario | cut -d: -f6`
    du -sh $carpetausuario | awk {'print $1'}
}

function espacioendiscototal() {
    echo "Espacio en disco total"
    carpetausuario="/home"
    du -sh $carpetausuario | awk {'print $1'}
}

function tantoporcientoendisco() {
    echo "Tanto por ciento en disco, $1..."
    usuario=$1
    carpetausuario=`cat /etc/passwd | grep ^$usuario | cut -d: -f6`
    du -sh $carpetausuario | awk {'print $1'}
    ocupadocarpeta=`du -sh $carpetausuario | awk {'print $1'}`
    #le quita la letra del final
    ocupadocarpeta=`echo $ocupadocarpeta|sed 's/.$//'`
    tamanodisco=`df -h | head -2 | tail -1 | awk {'print $2'}`
    #le quita la letra del final
    tamanodisco=`echo $tamanodisco | sed 's/.$//'`
    echo "Ocupado carpeta:$ocupadocarpeta"
    echo "Tamaño disco:$tamanodisco"
    #expr no da decimales
    #porcentajecarpeta=`expr $ocupadocarpeta / $tamanodisco`
    #bc sí da decimales
    porcentajecarpeta=$( echo "scale=2;$ocupadocarpeta/$tamanodisco" | bc)
    porcentajecarpeta=$( echo "scale=2;$porcentajecarpeta*100" | bc)
    echo "El porcentaje de la carpeta $carpetausuario sobre el tamaño total del disco es $porcentajecarpeta%"
}


function tantoporcientoendiscototal() {
    echo "Tanto por ciento en disco total"
    carpetausuario="/home"
    du -sh $carpetausuario | awk {'print $1'}
    ocupadocarpeta=`du -sh $carpetausuario | awk {'print $1'}`
    #le quita la letra del final
    ocupadocarpeta=`echo $ocupadocarpeta|sed 's/.$//'`
    tamanodisco=`df -h | head -2 | tail -1 | awk {'print $2'}`
    #le quita la letra del final
    tamanodisco=`echo $tamanodisco | sed 's/.$//'`
    echo "Ocupado carpeta:$ocupadocarpeta"
    echo "Tamaño disco:$tamanodisco"
    #expr no da decimales
    #porcentajecarpeta=`expr $ocupadocarpeta / $tamanodisco`
    #bc sí da decimales
    porcentajecarpeta=$( echo "scale=2;$ocupadocarpeta/$tamanodisco" | bc)
    porcentajecarpeta=$( echo "scale=2;$porcentajecarpeta*100" | bc)
    echo "El porcentaje de la carpeta $carpetausuario sobre el tamaño total del disco es $porcentajecarpeta%"
}


#echo $#

if [[ $# -eq 0 ]]
then
    error
elif [[ $# -gt 0 ]]
then
    #Decir buenos días, nombre del usuario
    #nombreusuario=`id -un`
    #si el primer parámetro es -u
    if [[ $1 == "-u" ]]
    then
        echo "Entrando en -u"
        if [[ $2 == "" ]]
        then
            echo "No has introducido nombre de usuario. Saliendo del programa"
            error
        else #usuario correcto
            nombreusuario=$2
            echo $nombreusuario
            if id $nombreusuario > /dev/null 2>&1
            then
               echo "Usuario existe. Comenzando proceso"
               echo $nombreusuario
               numprocesos $nombreusuario   
               procesomasantiguo $nombreusuario
               listadoprocesos $nombreusuario      
               numdirectorios $nombreusuario
               fichregulares $nombreusuario
               espacioendisco $nombreusuario
               tantoporcientoendisco $nombreusuario
            else
              echo "El usuario no existe."
              error
            fi
        fi
    elif [[ $1 == "-a" ]]
    then
        echo "Entrando en -a"
        numprocesostotal   
        procesomasantiguototal
                listadoprocesostotal
        numdirectoriostotal
        fichregularestotal
        espacioendiscototal
        tantoporcientoendiscototal
    else
        error
    fi
else
    error
fi

Operaciones matemáticas en Shell Script

sábado, 28 de enero de 2012

Shell Script Nº de usuarios conectados

Buena referencia para Shell Scripts

awk es mejor que cut

tamfichmenor=`ls -S -l -r -R| head -3 | tail -1 | awk '{print $5}'
Con cut al final, detecta los espacios, así que no me saca el tamaño del fichero.

Enlace a buena página de shell script en español

Shell Script Enero 5. Leer un número indeterminado de argumentos, ejecutar, crear copia de seguridad, parámetros con letras, fichero de ayuda

#!/bin/bash
#TODOS LOS SCRIPTS EN http://oposinf.blogspot.com/search/label/shellscript
#5. Implementar un shell-script bajo Linux que realice lo siguiente: El script tendrá el siguiente formato ej5.sh [opciones] [argumentos] Al ejecutar el shell-script, eśte deberá mostrar un saludo (Buenos días) con el nombre del usuario que lo ejecuta.
#Las opciones que puede recibir el shell son las siguientes:
#Sin opciones ni argumentos, deberá mostrar el contenido del propio shell-script.
#-m Comprobará que los argumentos (tras -m) son ficheros, en cuyo caso muestra su contenido por pantalla.
#-x Deberá comprobar que los argumentos (tras -x) son programas ejecutables, en cuyo caso los ejecutará.
#-b Con esta opción se borrarán todos los ficheros y directorios que se le pasen como parámetro. Antes de ser eliminados, creará una copia de seguridad de los mismos en el directorios $HOME/backup.
#-help Mostrará el contenido de un fichero de texto, de nombre ayuda.hlp, en el que se explicará el funcionamiento del shell-script.
#Se valorará es uso de funciones y llamadas a shell-scripts externos, si procede.

function error {
    echo "¡¡Horror!! Uso "$0" -[|m|x|b|help] [argumentos] "
    exit
}

echo $#

if [[ $# -eq 0 ]]
then
    echo "Contenido del archivo."
    cat enero05
elif [[ $# -gt 0 ]]
then
    #Decir buenos días, nombre del usuario
    nombreusuario=`id -un`
    echo "Buenos días, $nombreusuario"
    #si el primer parámetro es -m
    if [[ $1 == "-m" ]]
    then
        echo "Entrando en -m"
        #la siguiente línea muestra todos los parámetros en una línea, pero no me gusta mucho, voy a probar otra opción       
        #echo $*
        #esta manera es muy limpia
        #primero se quita de en medio el primer parámetro, que es la -m
        shift
        #y luego va sacando cada parámetro hasta que la lista de parámetros esta vacía
        #ni hay que contar parámetros ni nada
        while [[ $1 != "" ]]
        do
            archivo=$1           
            if [ -f $archivo ]
            then
                echo "LISTANDO ARCHIVO $archivo..."
                cat $archivo
            else
                echo "El archivo $archivo no existe"
            fi
            #pasa al siguiente parámetro, esto es, borra el primero y pasa todos los demas hacia adelante, así que el 2º pasa a ser el 1º
            shift
        done
    elif [[ $1 == "-x" ]]
    then
        echo "Entrando en -x"
        shift
        while [[ $1 != "" ]]
        do
            archivo=$1           
            if [ -f $archivo ]
            then
                echo "EJECUTANDO $archivo..."
                $archivo               
            else
                echo "El archivo $archivo no es ejecutable."
            fi
        shift
        done
    elif [[ $1 == "-b" ]]
    then
        echo "Entrando en -b"
        shift
        #comprobar si existe carpeta de backup y, si no, crearla
        nombreusuario=`id -un`
        echo $nombreusuario
        carpeta=`cat /etc/passwd | grep $nombreusuario | cut -d: -f6`
        echo $carpeta
        if [ -d $carpeta/backup1 ]
        then
            echo "La carpeta backup existe"
        else
            echo "Creando carpeta backup en carpeta de usuario"
            mkdir $carpeta/backup1
        fi
        while [[ $1 != "" ]]
        do
            archivo=$1           
            if [ -f $archivo ]
            then
                echo "BORRANDO $archivo..."
                cp $archivo $carpeta/backup1
                #esto lo comento para evitar que borre archivos
                #rm $archivo
            else
                echo "El archivo $archivo no existe."
            fi
        shift
        done
    elif [[ $1 == "-help" ]]
    then
        cat ayuda.hlp

    else
        error
    fi
   
   
else
    error
fi

Shell Script Enero 4. Escribir un programa copiabin.sh que mueva todos los programas del directorio actual (archivos ejecutables) hacia el subdirectorio bin del directorio propio del usuario, muestre los nombres de los que mueve e indique cuántos ha movido o que no ha movido ninguno. Si el directorio bin no existe, deberá ser creado.

#!/bin/bash

#4. Escribir un programa copiabin.sh que mueva todos los programas del directorio actual (archivos ejecutables) hacia el subdirectorio bin del directorio propio del usuario, muestre los nombres de los que mueve e indique cuántos ha movido o que no ha movido ninguno. Si el directorio bin no existe, deberá ser creado.

if [[ $# -gt 1 ]]
then
    echo "¡¡Horror!! Uso "$0" nombrearchivo "
    exit
fi

nombreusuario=`id -un`
echo $nombreusuario
carpeta=`cat /etc/passwd | grep $nombreusuario | cut -d: -f6`
echo $carpeta
#carpeta= `echo $carpeta/bin 2>/dev/null`
#carpeta= `echo "$carpeta/bin"` 
#carpetabin= `echo "$carpeta"/bin`

if [ -d $carpeta/bin ]
then
    echo "La carpeta bin existe"
else
    echo "Creando carpeta bin en carpeta de usuario"
    mkdir $carpeta/bin
fi

ls > ficheros.txt
while read linea
do
    echo $linea
    if [ -f "$linea" ]
    then
        if [ -x "$linea" ]
        then
            cp $linea $carpeta/bin       
        fi
    fi
done < ficheros.txt

Shell Script Enero 3. Realizar un script que permita copiar un archivo pasado como parámetro en un directorio cualquiera también pasado como parámetro, antes de copiar comprobar si el archivo se puede leer.

#!/bin/bash

#3. Realizar un script que permita copiar un archivo pasado como parámetro en un directorio cualquiera también pasado como parámetro, antes de copiar comprobar si el archivo se puede leer.

if [[ $# -gt 3 ]]
then
    echo "¡¡Horror!! Uso "$0" nombrearchivo "
    exit
fi

archivo=$1
carpeta=$2

if [ -r $nombre ]
then
    cp $archivo $carpeta
fi

Shell Script Enero 2. Recibir un nombre de archivo como parámetro e indicar, imprimiendo todas las leyendas que correspondan, si el archivo es legible, modificable y ejecutable por el usuario.

#!/bin/bash

#2. Recibir un nombre de archivo como parámetro e indicar, imprimiendo todas las leyendas que correspondan, si el archivo es legible, modificable y ejecutable por el usuario.

if [[ $# -gt 2 ]]
then
    echo "¡¡Horror!! Uso "$0" nombrearchivo "
    exit
fi

archivo=$1

if [ -f $nombre ]
then
    if [ -r $nombre ]
    then
        echo "El archivo $archivo se puede leer"
    else
        echo "El archivo $archivo no se puede leer"   
    fi

    if [ -w $nombre ]
    then
        echo "El archivo $archivo se puede escribir"
    else
        echo "El archivo $archivo no se puede escribir"   
    fi

    if [ -x $nombre ]
    then
        echo "El archivo $archivo se puede ejecutar"
    else
        echo "El archivo $archivo no se puede ejecutar"   
    fi

fi

Shell Script Enero 1. Hacer un script que visualice un menú de tres opciones, la primera borra un fichero leído por teclado, la segunda visualiza un fichero también leído por teclado y la tercera sale del programa

#!/bin/bash

#1. Hacer un script que visualice un menú de tres opciones, la primera borra un fichero leído por teclado, la segunda visualiza un fichero también leído por teclado y la tercera sale del programa

function menu {
echo "1. Borrar fichero."
echo "2. Visualizar fichero."
echo "3. Salir."
echo "Introduce una opción:"
}

until [[ $opcion -eq 3 ]]
do
menu
read  opcion
#echo $opcion
if [[ $opcion -eq 1 ]] ;then
    echo "Opción 1 seleccionada"
    read -p "Introduce el nombre del archivo" nombre
    #echo $nombre
    if [ -f $nombre ]
    then
        rm $nombre
    fi
elif [[ $opcion -eq 2 ]] ; then
    echo "Opción 2 seleccionada"
    read -p "Introduce el nombre del archivo" nombre
    $echo $nombre
    if [ -f $nombre ]
    then
        cat $nombre
    fi
else
    echo "Saliendo del programa..."
fi
done

sábado, 21 de enero de 2012

¡Ya está bien! CULTURA LIBRE Y GRATUITA

¡Ya está bien! Ya está bien de pagar por algo que es patrimonio de la humanidad.
¿Quién inventó el cine? Los hermanos Lumiere. ¿Se le paga a la familia de los hermanos Lumiere cada vez que alguien hace una película? No.
¿Qué es Star Wars? Un pastiche de escenas de películas del oeste, bélicas, de espada y brujería, de kárate, trufado de referencias a las más variadas culturas:
los moños de la princesa Leia están copiados de la Dama de Elche, los trajes de Jedi son japoneses, los caballeros Jedi son los de la Mesa Redonda,
los Padawan llevan una coleta como los toreros... ¿Eso no es copiar? ¿Eso no es piratear ideas? Ah, no, eso es "inspirado en". (Y mira que soy fan de Star Wars).
Yo me gastaba la paga de un mes para comprar un disco de vinilo. Un cd costaba 50 pesetas, y te cobraban 20€, con suerte, por 10 canciones, de las cuales, 2 o 3 estaban bien y el resto era relleno.
Las industrias cinematográfica y discográfica son herramientas de marketing que crean estrellas como Amy Winehouse, pero luego no la ayudan cuando tiene problemas.
¿Cuántos niños prodigio han acabado siendo víctimas de su propio éxito? Macauley Culkin, Joselito, Edward Furlong...
Marisol fue inteligente y consiguió escapar del rodillo asesino de las grandes multinacionales.
¿Por qué Rock Hudson no podía ser él mismo? ¿Cuánto sufrimiento tuvo que pasar esa persona porque alguien creía que iba a vender menos si salía del armario?
¿Cuánto dinero han amasado? ¿Qué han hecho con él? Y siguen queriendo exprimir la gallina de los huevos de oro.
No se dan cuenta de que las personas somos inteligentes y de que no nos dejamos manipular.
Que hay miles de chavales y chavalas con más talento, ganas y capacidad de trabajo que las supuestas estrellitas que nos venden y con las que nos machacan día tras día.
Si una mentira se repite las suficientes veces, acaba convirtiéndose en la verdad (Joseph Goebbels). Joseph Goebbles fue ministro de propaganda de la Alemania Nazi.
Pues lo mismo intentan usar con nosotros: Pitbull es muy bueno, Shakira es muy buena, Carlos Jean es muy bueno... Lo ponen una y otra vez, una y otra vez, y repiten que son buenos.
Tenemos criterio, tenemos inteligencia y tenemos libertad. Y si prohiben intercambiar las cosas de una manera, saldré a la calle y le pediré al panadero que me preste la última serie de éxito.
¿Estaré cometiendo un delito? ¿Qué nos van a poner, un policía al lado a ver si le presto mis cosas a alguien? ¡Anda ya!
Yo abogo por una protesta pacífica: cambiar los contratos de todos los curritos, y cada vez que alguien pise una loseta que un albañil o albiñila ha puesto, que pague por ello,
cada vez que un alumno o alumna sume, que se pague al profesor que le enseñó a sumar, cada vez que alguien use un ordenador que yo he arreglado, que me pague,
cada vez que alguien haga una foto en Nueva York, que pague a los dueños de las casas, al Ayuntamiento por poner el río y al que hizo la Estatua de la Libertad.
Y llegamos al absurdo... Cada vez que alguien use un número, ¿quién tiene la patente de los números? ¿Y del teorema de Bolzano? ¿Y de la estructura básica del ordenador de Von Neumann?
LA CULTURA HA DE SER LIBRE Y GRATUITA. TODA. SIEMPRE.
Y si te crees con derecho a tener más que los demás por escribir 100 líneas de poemas en 2 años, ¿cuánto debería tener yo, que escribo 100 líneas de código en una hora? Deberías estar contento de que una persona igual que tú valore lo que haces y sea un poco más feliz gracias a ti. Pero no, tú quieres dinero, dinero, dinero...

viernes, 13 de enero de 2012

Shell Script Examen Viernes 13

Shell Script Examen Viernes 13

Para mis queridos alumnos y alumnas, para que vean que yo también hago exámenes:

#!/bin/bash

#examen viernes 13

#Elabora un Shell script que nos permitirá gestionar las copias de seguridad
#de un determinado directorio, que se recibirá por parámetro.
#Admitirá como argumento dos parámetros, el primero deberá ser Backup o
#Restore, y el segundo el nombre de un directorio.
#Si el primer parámetro es Backup, el Shell realizará una copia de seguridad
#(backup), para todos los usuarios del sistema, en el directorio pasado como
#segundo argumento.
#Si el primer parámetro es Restore, el Shell deberá restaurar todas las
#copias de seguridad guardadas en el directorio pasado como segundo
#parámetro. Se supone que restaura en el home.
#PD.- Recordad que es imprescindible comentad el código. (hacerlo a
#conciecia y la vinculación curricular aunque no lo pida).

#Comprueba el número de parámetros y si es distinto de 2, avisa del error y sale del programa
if (( $# != 2 ))
then
    echo "Número de parámetros no correcto"
    echo "Uso $0 Backup|Restore carpeta"
    exit
fi

#echo "Número de parámetros:"$#
#inicialización de variables
#operación a realizar, Backup o Restore
operacion=$1
#carpeta destino u origen
directorio=$2
#echo $operacion
#Se comprueba si la operación es Backup o Restore y si no lo es, se sale del programa
if [ $operacion = "Backup" ]
then
    echo "Operación Backup en curso..."   
else
    if [ $operacion = "Restore" ]
    then
        echo "Operación Restore en curso..."
    else
    echo "La operación debe ser Backup o Restore y tú has escrito " $operacion
    echo "Saliendo del programa..."
    exit
    fi
fi
#ahora se comprueba si existe el directorio destino u origen
#y si no se crea
if [ -d $directorio ]
then
    echo "El directorio existe. Se sigue el proceso..."
else
    echo "El directorio no existe. Se crea."
    mkdir $directorio
    if [ $? -ne 0 ]
    then
        echo "Error al crear el directorio. Seguramente, no tienes permiso para copiar en él"
        echo "Saliendo del programa"
        exit
    fi
fi
#echo "Operación:" $operacion
#si la operación es Backup
if [ $operacion = "Backup" ]
then
#se realiza la copia de seguridad
    echo "Realizando copia de seguridad..."
    cd $directorio
    carpetahome="/home/ubuntu" #esta es la carpeta de la que se hace la copia de seguridad
    tar -cf seguridad.tar $carpetahome
else
#se restaura la copia de seguridad
    echo "Realizando la restauración..."
    #cambia a la carpeta donde restaurar, que sería home   
    cd /home/jluserovilchez/examen13
    #descomprime
    tar -xf $directorio/*.tar
fi

martes, 10 de enero de 2012

Shell Script Sistemas de archivos ocupados al 90%

#!/bin/bash
#El comando df muestra el espacio disponible en los sistemas de archivos #montados. Su salida tiene esta forma:
#  Filesystem  1024-blocks   Used  Available  Capacity  Mounted on
#  /dev/hda2      1484386  433463     974213      31%   /
#  /dev/hda1      1228736  524576     704160      31%   /dosc
#  /dev/hda3       68263    63484       4779      93%   /tmp
#Los campos están separados por espacios. El campo Capacity indica el porcentaje ocupado. Escribir un script espacio que invoque el comando df y muestre en su salida el nombre del sistema de archivo y su capacidad ocupada para los sistemas de archivos con 90% o más espacio ocupado.

if [ $# -gt 1  ] #comprobar número de parámetros introducidos
then          #gracias a Alejandro por sus buenas formas
    echo "¡¡Horror!! Uso "$0" "
    exit
fi

df | tr -s " " | cut -d" " -f1,5 | grep 9[0-9]%

Shell Script Hacer ping a máquinas en archivo /etc/hosts

#!/bin/bash

#Un administrador de una máquina UNIX debe revisar día a día si hay conexión hacia todas las máquinas contenidas en el archivo /etc/hosts. Para ello dispone del comando
#   ping -c1 <nombre de la máquina destino>

lunes, 9 de enero de 2012

Shell Script Sumadora usando expr


#Escribir un script sumadora para hacer sumas y restas de enteros. #Presentará al usuario una interfaz similar a ésta:
#  SUMADORA: suma y resta enteros.
#  Los símbolos aceptados son: + y -
#  Debe haber espacio entre todos los operandos y operadores.
#  Ejemplo: 5 + 3 - 20 + 35
#  Ingrese operaciones:
#  3 * 2 + 10
#  Resultado:
#  16
#Si la expresión ingresada es correcta, el script realizará el cálculo y #presentará el resultado; si no lo es, emitirá en lugar del resultado el #mensaje "Expresión incorrecta. Debe comenzar de nuevo" y saldrá.
#¿Qué dificultas se presentaría al incluír otras operaciones?
#Sugerencia: para controlar la validez de la expresión, capturar el valor #de retorno del comando que realiza la operación.

Shell Script Agregar máquinas al archivo /etc/hosts

#!/bin/bash

#Ejercicio 12. Escribir un script admaq para agregar una máquina al archivo /etc/hosts. Solicitará al usuario un número IP y luego un nombre #de máquina. El ingreso del nombre de máquina se reiterará hasta que el usuario ingrese un nombre de máquina vacío (tecla #Enter sin escribir nada). El script armará la línea en el formato del archivo hosts y la presentará al usuario pidiendo #confirmación. Si la obtiene, adjuntará la línea al final del archivo /etc/hosts.

Shell Script Número de elementos en un array y más

Resumen de Shell Script muy bueno

domingo, 8 de enero de 2012

sábado, 7 de enero de 2012

Podcast Informática Divulgada 03 Tema 27 Estructuras de Programación

Pogramita número 3 de mi PODCAST

Podcast Informática Divulgada 03  Tema 27 Estructuras de Programación

27. Estructuras de programación
27.1. Tipos de datos y variables.
27.2. Expresiones y operadores.
27.3. Estructuras de control de flujo.
27.4. Subrutinas y funciones.
27.5. Paso de parámetros.
27.6. Programación basada en eventos.

 

IES Campanilllas, atacado

Me he intentado meter en la web el IES Campanillas y me redirige a otra dirección.
QUE FAIL
Éste es el FAIL2.

Programación didáctica: dudas

-Los dos primeros trimestres tienen 26 semanas, mientras que aquí da para 242 horas. He puesto, incluyendo días no lectivos. ¿Está bien?

viernes, 6 de enero de 2012

C++ Clase cola circular de enteros

//archivo ccolacircular.h
// Class automatically generated by Dev-C++ New Class wizard

#ifndef CCOLACIRCULAR_H
#define CCOLACIRCULAR_H

Podcast Informática 02 Cajas y placas base

2. Cajas y placas base para el ensamblaje de sistemas microinformáticos. 2.1. Factores de forma 2.2. Funcionalidades y componentes de una placa base 2.3. BIOS. Buses, puertos y conectores 2.4. Arquitecturas vigentes
Aquí se describe la estructura del ordenador desde un punto de vista físico.




Descarga directa

Web sobre listas circulares en C++

C++ Clase card para almacenar y mostrar datos sobre libros

//archivo ccard.h
// Class automatically generated by Dev-C++ New Class wizard
#include <string>
#include <iostream>
#include <string.h>   // Required by strcpy()
#include <stdlib.h>
#ifndef CCARD_H
#define CCARD_H

C++ Pila simple para almacenar caracteres mediante un array de caracteres

//archivo cpila.h
// Class automatically generated by Dev-C++ New Class wizard
#include <iostream>
#ifndef CPILA_H
#define CPILA_H

jueves, 5 de enero de 2012

C++ Clase entera simple con métodos para leer y escribir datos

//archivo centero.h
// Class automatically generated by Dev-C++ New Class wizard

#ifndef CENTERO_H
#define CENTERO_H

Tutoriales de C++ con clase

Muy buena.
C++ con clase

Página web de donde saco la música para el Podcast

www.jamendo.com
Lo mejor de la música libre.

Java Clase Pez Añadir número de objetos de la clase Pez creados.

Hemos añadido a la clase base cPez, una variable pública que se inicializa a 0 al crear el primer objeto de la clase cPez. La variable está fuera de cualquier método y, al ser pública, puede ser accedida desde sus clases derivadas e incrementada, que es lo que se hace en las clases derivadas cada vez que se crea un objeto.

Java Clase Pez getNombre setNombre Crear 2 clases que extiendan la clase pez.

//archivo cPez.java
public class cPez {
    protected String nombre;
   
    public cPez(){
        this("");
    }

Java Realiza un programa que muestre por pantalla el siguiente cuadrado: 1 1 1 1 1 1 2 3 4 5 1 3 6 10 15 1 4 10 20 35 1 5 15 35 70 El programa podrá generar cuadrados de cualquier dimensión. Utiliza la recursividad.

Sin recursividad.
//archivo cCuadroRecursivo
public class cCuadradoRecursivo {
    private int n;
    int [][] tabla;

Java Ejercicio 5 Realiza una clase con un método decimalToRomano que transforme números en formato decimal a números en formato romano

No lo hace bien. ¿Por qué? En próximas entradas, la solución.
//fichero cromano.java
public class cromano {
    protected int n;
    protected String romano;
    /**
     * @param args
     */

miércoles, 4 de enero de 2012

Java Lucky Number Número de la suerte Calcula tu numero de la suerte a partir de tu fecha de nacimiento

//fichero cLuckynumber.java
import java.util.*;
import java.io.*;
import java.util.Calendar;

public class cLuckynumber {
    protected Date fechanac;
   

Ejemplos de Java a tutiplen en inglés

Podcast Informática 01 Informática para todos

Este es el primer pogramita del Podcast de Informática que estoy pergeñando.
La principal intención es explicar la informática para que se entere todo el mundo. ¿Qué hace el ordenador desde que tocamos una tecla hasta que nos saca el resultado en la pantalla?
 
Descarga directa
http://www.ivoox.com/podcast-informatica-01-audios-mp3_rf_977087_1.html

Java Escalera con astericos

*
**
***
****
*****

//archivo cAsteriscos.java


Java Clase para calcular número de personas según el número de chocos y de papas

Ampliar el programa anterior creando una clase que permita almacenar los kilos de papas y chocos del restaurante.

import java.io.*;
public class cPapaschocos2 {


Java Calcular el número de personas según los kilogramos de papas y chocos que tenga

 El enunciado del ejercicio original está en http://pizarra2011.wikispaces.com/Ejercicio+11+t2
/*
Carlos Pascual Piles García

11. El restaurante mejicano de Israel cuya especialidad son las papas con chocos nos pide diseñar