Collections | Scripting and security

Crear un array con información y convertirlo en un fichero JSON

(1 votes, average: 5.00 out of 5)

[System.Collections.ArrayList] $arraylist = New-Object System.Collections.ArrayList

# Almacenar en un array información sobre libros
$null = $arraylist.Add(
    [pscustomobject] @{
    titulo = "Redes Locales"
    isbn = "9788415426479"
    imagen = "https://images-na.ssl-images-amazon.com/images/I/51ggAPSyROL._SX383_BO1,204,203,200_.jpg"
    curso = "gi1"
    obligatorio = 1
    })

$null = $arraylist.Add(
    [pscustomobject] @{
    titulo = "Sistemas Operativos Monopuesto"
    isbn = "978-84-9771-9711"
    imagen = "https://images-na.ssl-images-amazon.com/images/I/51xaG8rZaSL._SX411_BO1,204,203,200_.jpg"
    curso = "gi1"
    obligatorio = 1
    })

$json = $arraylist | ConvertTo-Json

($json | ConvertFrom-Json).titulo

[System.Collections.ArrayList] $arraylist = New-Object System.Collections.ArrayList

# Almacenar en un array información sobre libros

$null = $arraylist.Add(

[pscustomobject] @{

titulo = "Redes Locales"

isbn = "9788415426479"

imagen = "https://images-na.ssl-images-amazon.com/images/I/51ggAPSyROL._SX383_BO1,204,203,200_.jpg"

curso = "gi1"

obligatorio = 1

})

$null = $arraylist.Add(

[pscustomobject] @{

titulo = "Sistemas Operativos Monopuesto"

isbn = "978-84-9771-9711"

imagen = "https://images-na.ssl-images-amazon.com/images/I/51xaG8rZaSL._SX411_BO1,204,203,200_.jpg"

curso = "gi1"

obligatorio = 1

})

$json = $arraylist | ConvertTo-Json

($json | ConvertFrom-Json).titulo

Comparar listas de arrays de caracteres

(No Ratings Yet)

#Comparar con otro array y obtener los elementos que están en ambos arrays
#Array con valores
$Array=([System.Collections.Generic.HashSet[String]])::new([String[]]@("Carlos","Pedro","Lucas","Marcos","Mateo"))
$Array.IntersectWith([String[]]@("Pablo","Gonzalo","Marcos"))
$Array

#Obtener todos los elementos de los dos arrays sin repeticiones
#Array con valores
$Array=([System.Collections.Generic.HashSet[String]])::new([String[]]@("Carlos","Pedro","Lucas","Marcos","Mateo"))
$Array.UnionWith([String[]]@("Pablo","Gonzalo","Marcos"))
$Array

#Obtener los elementos de un array que no están en otro array
#Array con valores
$Array=([System.Collections.Generic.HashSet[String]])::new([String[]]@("Carlos","Pedro","Lucas","Marcos","Mateo"))
$Array.ExceptWith([String[]]@("Pablo","Gonzalo","Marcos"))
$Array

#Obtener todos los elementos de los dos arrays sin incluir los que están en los dos arrays
#Array con valores
$Array=([System.Collections.Generic.HashSet[String]])::new([String[]]@("Carlos","Pedro","Lucas","Marcos","Mateo"))
$Array.SymmetricExceptWith([String[]]@("Pablo","Gonzalo","Marcos"))
$Array

#Comparar con otro array y obtener los elementos que están en ambos arrays

#Array con valores

$Array=([System.Collections.Generic.HashSet[String]])::new([String[]]@("Carlos","Pedro","Lucas","Marcos","Mateo"))

$Array.IntersectWith([String[]]@("Pablo","Gonzalo","Marcos"))

$Array

#Obtener todos los elementos de los dos arrays sin repeticiones

#Array con valores

$Array=([System.Collections.Generic.HashSet[String]])::new([String[]]@("Carlos","Pedro","Lucas","Marcos","Mateo"))

$Array.UnionWith([String[]]@("Pablo","Gonzalo","Marcos"))

$Array

#Obtener los elementos de un array que no están en otro array

#Array con valores

$Array=([System.Collections.Generic.HashSet[String]])::new([String[]]@("Carlos","Pedro","Lucas","Marcos","Mateo"))

$Array.ExceptWith([String[]]@("Pablo","Gonzalo","Marcos"))

$Array

#Obtener todos los elementos de los dos arrays sin incluir los que están en los dos arrays

#Array con valores

$Array=([System.Collections.Generic.HashSet[String]])::new([String[]]@("Carlos","Pedro","Lucas","Marcos","Mateo"))

$Array.SymmetricExceptWith([String[]]@("Pablo","Gonzalo","Marcos"))

$Array

Obtener empresas del IBEX 35 en formato JSON

(No Ratings Yet)

[System.Collections.ArrayList] $arraylist = New-Object System.Collections.ArrayList

# Obtener empresas del IBEX 35
$web = Invoke-WebRequest 'http://www.bolsamadrid.es/esp/aspx/Mercados/Precios.aspx?indice=ESI100000000'
$result = $web.AllElements | Where Class -eq “DifFlBj” | %{$_.innerText}
$result += $web.AllElements | Where Class -eq “DifFlSb” | %{$_.innerText}
$result += $web.AllElements | Where Class -eq “DifFlIg” | %{$_.innerText}

# Almacenar en un array cada empresa del IBEX 35
ForEach ($elemento in $result){
    $null = $arraylist.Add(
    [pscustomobject] @{
    Empresa = $elemento
    Cotización = 0
    }
)
}

# Eliminar el primer elemento del array porque contiene una empresa no válida
$arraylist.Removeat(0)
# Número de empresas, tiene que ser 35
$arraylist.Count

# Convertir a JSON
$json = $arraylist | ConvertTo-Json

# Importar el contenido JSON y listar las empresas
($json | ConvertFrom-Json).empresa

[System.Collections.ArrayList] $arraylist = New-Object System.Collections.ArrayList

# Obtener empresas del IBEX 35

$web = Invoke-WebRequest 'http://www.bolsamadrid.es/esp/aspx/Mercados/Precios.aspx?indice=ESI100000000'

$result = $web.AllElements | Where Class -eq “DifFlBj” | %{$_.innerText}

$result += $web.AllElements | Where Class -eq “DifFlSb” | %{$_.innerText}

$result += $web.AllElements | Where Class -eq “DifFlIg” | %{$_.innerText}

# Almacenar en un array cada empresa del IBEX 35

ForEach ($elemento in $result){

$null = $arraylist.Add(

[pscustomobject] @{

Empresa = $elemento

Cotización = 0

}

)

}

# Eliminar el primer elemento del array porque contiene una empresa no válida

$arraylist.Removeat(0)

# Número de empresas, tiene que ser 35

$arraylist.Count

# Convertir a JSON

$json = $arraylist | ConvertTo-Json

# Importar el contenido JSON y listar las empresas

($json | ConvertFrom-Json).empresa

Analizar fichero XML con la lista de radares de España

(1 votes, average: 2.00 out of 5)

$radares = [XML](Invoke-WebRequest "http://www.dgt.es/images/Tramos_INVIVE_12042017.xml").content

[System.Collections.ArrayList] $arraylist = New-Object System.Collections.ArrayList

$radares.RAIZ.PROVINCIA.CARRETERA | %{
    $radar = $_.DENOMINACION + "|" + $_.RADAR.PUNTO_INICIAL.PK
    [void]$arraylist.Add($radar)
}

$arraylist | Sort-Object

$radares = [XML](Invoke-WebRequest "http://www.dgt.es/images/Tramos_INVIVE_12042017.xml").content

[System.Collections.ArrayList] $arraylist = New-Object System.Collections.ArrayList

$radares.RAIZ.PROVINCIA.CARRETERA | %{

$radar = $_.DENOMINACION + "|" + $_.RADAR.PUNTO_INICIAL.PK

[void]$arraylist.Add($radar)

}

$arraylist | Sort-Object

Detectar si el ratón pasa por alguna posición de la pantalla

(1 votes, average: 5.00 out of 5)

#Inicializa una nueva instancia de la clase ArrayList que está vacía y tiene la capacidad inicial predeterminada
[System.Collections.ArrayList] $arraylist = New-Object System.Collections.ArrayList

#Añadir posiciones 
[void]$arraylist.Add('0,0')


for (1)
{
    $dY = ([System.Windows.Forms.Cursor]::Position.Y)
    $dX = ([System.Windows.Forms.Cursor]::Position.X)
    if($arraylist.IndexOf("$dX,$dY") -ne -1)
    {
        "El ratón ha pasado por la posición $dX,$dY"
    }
    else
    {
        ""
    }
}

#Inicializa una nueva instancia de la clase ArrayList que está vacía y tiene la capacidad inicial predeterminada

[System.Collections.ArrayList] $arraylist = New-Object System.Collections.ArrayList

#Añadir posiciones

[void]$arraylist.Add('0,0')

for (1)

{

$dY = ([System.Windows.Forms.Cursor]::Position.Y)

$dX = ([System.Windows.Forms.Cursor]::Position.X)

if($arraylist.IndexOf("$dX,$dY") -ne -1)

{

"El ratón ha pasado por la posición $dX,$dY"

}

else

{

}

Comparar listas de arrays de números

(No Ratings Yet)

#Comparar con otro array y obtener los elementos que están en ambos arrays
#Array con valores
$Array=([System.Collections.Generic.HashSet[int32]])::new([int[]]@(1,2,3,4,5,6))
$Array.IntersectWith([int[]]@(5,6,7,8,9,10))
$Array

#Obtener todos los elementos de los dos arrays sin repeticiones
#Array con valores
$Array=([System.Collections.Generic.HashSet[int32]])::new([int[]]@(1,2,3,4,5,6))
$Array.UnionWith([int[]]@(5,6,7,8,9,10))
$Array

#Obtener los elementos de un array que no están en otro array
#Array con valores
$Array=([System.Collections.Generic.HashSet[int32]])::new([int[]]@(1,2,3,4,5,6))
$Array.ExceptWith([int[]]@(5,6,7,8,9,10))
$Array

#Obtener todos los elementos de los dos arrays sin incluir los que están en los dos arrays
#Array con valores
$Array=([System.Collections.Generic.HashSet[int32]])::new([int[]]@(1,2,3,4,5,6))
$Array.SymmetricExceptWith([int[]]@(5,6,7,8,9,10))
$Array

#Comparar con otro array y obtener los elementos que están en ambos arrays

#Array con valores

$Array=([System.Collections.Generic.HashSet[int32]])::new([int[]]@(1,2,3,4,5,6))

$Array.IntersectWith([int[]]@(5,6,7,8,9,10))

$Array

#Obtener todos los elementos de los dos arrays sin repeticiones

#Array con valores

$Array=([System.Collections.Generic.HashSet[int32]])::new([int[]]@(1,2,3,4,5,6))

$Array.UnionWith([int[]]@(5,6,7,8,9,10))

$Array

#Obtener los elementos de un array que no están en otro array

#Array con valores

$Array=([System.Collections.Generic.HashSet[int32]])::new([int[]]@(1,2,3,4,5,6))

$Array.ExceptWith([int[]]@(5,6,7,8,9,10))

$Array

#Obtener todos los elementos de los dos arrays sin incluir los que están en los dos arrays

#Array con valores

$Array=([System.Collections.Generic.HashSet[int32]])::new([int[]]@(1,2,3,4,5,6))

$Array.SymmetricExceptWith([int[]]@(5,6,7,8,9,10))

$Array

Ejercicios de PowerShell: analizar la frecuencia de letras en un fichero

(2 votes, average: 5.00 out of 5)

Versión 1

#Abrir el fichero texto.txt y añadir cada una de las letras que contiene el fichero en una ArrayList

#Inicializa una nueva instancia de la clase ArrayList que está vacía y tiene la capacidad inicial predeterminada
[System.Collections.ArrayList] $arraylist = New-Object System.Collections.ArrayList
 
ForEach ($elemento in gc .\texto.txt){
#Agrega un objeto al final de ArrayList
0..($elemento.Length-1) | %{
[void]$arraylist.Add($elemento[$_])
}
}

$arraylist | Group-Object | Sort-Object Count -Descending | select Name,Count

#Abrir el fichero texto.txt y añadir cada una de las letras que contiene el fichero en una ArrayList

#Inicializa una nueva instancia de la clase ArrayList que está vacía y tiene la capacidad inicial predeterminada

[System.Collections.ArrayList] $arraylist = New-Object System.Collections.ArrayList

ForEach ($elemento in gc .\texto.txt){

#Agrega un objeto al final de ArrayList

0..($elemento.Length-1) | %{

[void]$arraylist.Add($elemento[$_])

}

$arraylist | Group-Object | Sort-Object Count -Descending | select Name,Count

Versión 2

(((Get-Content .\texto.txt) -join "`r").ToUpper().GetEnumerator()) | Group-Object | Sort-Object Count -Descending | select Name,Count

1	(((Get-Content .\texto.txt) -join "`r").ToUpper().GetEnumerator()) \| Group-Object \| Sort-Object Count -Descending \| select Name,Count

Determinar si Hashtable contiene una clave específica

(1 votes, average: 5.00 out of 5)

#Agrega elementos a la clase HashTable
#https://msdn.microsoft.com/es-es/library/system.collections.hashtable(v=vs.110).aspx
$hashtable = @{uno='valoruno'; dos='valordos'; tres='valortres'}

#HashTable sin ordenar
$hashtable

#Detectar si existe un elemento en la clase HashTable
$hashtable.Contains("uno")
$hashtable.Contains("uno1")

#Agrega elementos a la clase HashTable

#https://msdn.microsoft.com/es-es/library/system.collections.hashtable(v=vs.110).aspx

$hashtable = @{uno='valoruno'; dos='valordos'; tres='valortres'}

#HashTable sin ordenar

$hashtable

#Detectar si existe un elemento en la clase HashTable

$hashtable.Contains("uno")

$hashtable.Contains("uno1")

Realizar una comunicación enviando preguntas y respondiendo de forma automática mediante el motor de síntesis de voz en PowerShell (con restricciones para una gramática de reconocimiento de voz)

(2 votes, average: 2.50 out of 5)

Introducción

####################################################################################################
####################################################################################################
#Teniendo en cuenta la idea de comunicar dos ordenadores mediante la voz del sistema operativo
#https://www.jesusninoc.com/2016/01/10/comunicar-dos-ordenadores-mediante-la-voz-del-sistema-operativo/
#Realizar una comunicación enviando preguntas y respondiendo de forma automática
####################################################################################################
####################################################################################################

####################################################################################################

#Teniendo en cuenta la idea de comunicar dos ordenadores mediante la voz del sistema operativo

#https://www.jesusninoc.com/2016/01/10/comunicar-dos-ordenadores-mediante-la-voz-del-sistema-operativo/

#Realizar una comunicación enviando preguntas y respondiendo de forma automática

####################################################################################################

Reconocimiento y respuesta (ejecutar primero)

####################################################################################################
#RECONOCIMIENTO Y RESPUESTA
####################################################################################################
#Crear objeto para reconocimiento
Add-Type -AssemblyName System.Speech
$rec = New-Object 'System.Speech.Recognition.SpeechRecognitionEngine'
#Crear las restricciones para una gramática de reconocimiento de voz
$rec.LoadGrammar([System.Speech.Recognition.GrammarBuilder]::new("tal"))
$rec.LoadGrammar([System.Speech.Recognition.GrammarBuilder]::new("años"))
$rec.LoadGrammar([System.Speech.Recognition.GrammarBuilder]::new("novia"))
$rec.LoadGrammar([System.Speech.Recognition.GrammarBuilder]::new("novio"))
$rec.SetInputToDefaultAudioDevice()

#Añadir posibles respuestas
"tal|Bien y tú?" | Out-File frases.txt
"años|40" | Out-File frases.txt -Append
"novia|Sí" | Out-File frases.txt -Append
"novio|Sí" | Out-File frases.txt -Append

#Crear un ArrayList con las respuestas
[System.Collections.ArrayList]$arraylist = New-Object System.Collections.ArrayList
ForEach ($elemento in (gc .\frases.txt).split("|")){[void]$arraylist.Add($elemento)}

#Función para comprobar si el mensaje que llega está entre las posibles respuestas
#La función responde mediante la voz del Sistema Operativo
function comprobar($frase){
    [System.Collections.ArrayList]$arraylist2 = New-Object System.Collections.ArrayList
    ForEach ($elemento in $frase.split(" ")){[void]$arraylist2.Add($elemento)}

    $arraylist2 | %{
        if($arraylist.IndexOf($_) -ne -1){
            "Respuesta: " +$arraylist[($arraylist.IndexOf($_))+1]
            (New-Object -TypeName System.Speech.Synthesis.SpeechSynthesizer).Speak($arraylist[($arraylist.IndexOf($_))+1])
        }
    }
}

#Comenzar a reconocer los audios que vayan llegando y comprobar qué mensajes llegan
do{
$mensaje=$rec.Recognize().Text
$mensaje
comprobar $mensaje
}while(1)

####################################################################################################

#RECONOCIMIENTO Y RESPUESTA

####################################################################################################

#Crear objeto para reconocimiento

Add-Type -AssemblyName System.Speech

$rec = New-Object 'System.Speech.Recognition.SpeechRecognitionEngine'

#Crear las restricciones para una gramática de reconocimiento de voz

$rec.LoadGrammar([System.Speech.Recognition.GrammarBuilder]::new("tal"))

$rec.LoadGrammar([System.Speech.Recognition.GrammarBuilder]::new("años"))

$rec.LoadGrammar([System.Speech.Recognition.GrammarBuilder]::new("novia"))

$rec.LoadGrammar([System.Speech.Recognition.GrammarBuilder]::new("novio"))

$rec.SetInputToDefaultAudioDevice()

#Añadir posibles respuestas

"tal|Bien y tú?" | Out-File frases.txt

"años|40" | Out-File frases.txt -Append

"novia|Sí" | Out-File frases.txt -Append

"novio|Sí" | Out-File frases.txt -Append

#Crear un ArrayList con las respuestas

[System.Collections.ArrayList]$arraylist = New-Object System.Collections.ArrayList

ForEach ($elemento in (gc .\frases.txt).split("|")){[void]$arraylist.Add($elemento)}

#Función para comprobar si el mensaje que llega está entre las posibles respuestas

#La función responde mediante la voz del Sistema Operativo

function comprobar($frase){

[System.Collections.ArrayList]$arraylist2 = New-Object System.Collections.ArrayList

ForEach ($elemento in $frase.split(" ")){[void]$arraylist2.Add($elemento)}

$arraylist2 | %{

if($arraylist.IndexOf($_) -ne -1){

"Respuesta: " +$arraylist[($arraylist.IndexOf($_))+1]

(New-Object -TypeName System.Speech.Synthesis.SpeechSynthesizer).Speak($arraylist[($arraylist.IndexOf($_))+1])

}

#Comenzar a reconocer los audios que vayan llegando y comprobar qué mensajes llegan

do{

$mensaje=$rec.Recognize().Text

$mensaje

comprobar $mensaje

}while(1)

Enviar preguntas

####################################################################################################
#ENVIAR PREGUNTAS
####################################################################################################
#Leer el texto contenido dentro de un fichero mediante la voz del Sistema Operativo
Add-Type -AssemblyName System.Speech

#Añadir textos para que se lean
"¿Qué tal?" | Out-File conversacion.txt
"¿Cuántos años tienes?" | Out-File conversacion.txt -Append
"¿Tienes novia?" | Out-File conversacion.txt -Append

#Leer los textos mediante la voz del Sistema Operativo
gc conversacion.txt | %{
$_
(New-Object -TypeName System.Speech.Synthesis.SpeechSynthesizer).Speak($_)
Start-Sleep -Seconds 3
}

####################################################################################################

#ENVIAR PREGUNTAS

####################################################################################################

#Leer el texto contenido dentro de un fichero mediante la voz del Sistema Operativo

Add-Type -AssemblyName System.Speech

#Añadir textos para que se lean

"¿Qué tal?" | Out-File conversacion.txt

"¿Cuántos años tienes?" | Out-File conversacion.txt -Append

"¿Tienes novia?" | Out-File conversacion.txt -Append

#Leer los textos mediante la voz del Sistema Operativo

gc conversacion.txt | %{

(New-Object -TypeName System.Speech.Synthesis.SpeechSynthesizer).Speak($_)

Start-Sleep -Seconds 3

}

Realizar una comunicación enviando preguntas y respondiendo de forma automática mediante el motor de síntesis de voz en PowerShell

(No Ratings Yet)

Introducción

####################################################################################################
####################################################################################################
#Teniendo en cuenta la idea de comunicar dos ordenadores mediante la voz del sistema operativo
#https://www.jesusninoc.com/2016/01/10/comunicar-dos-ordenadores-mediante-la-voz-del-sistema-operativo/
#Realizar una comunicación enviando preguntas y respondiendo de forma automática
####################################################################################################
####################################################################################################

####################################################################################################

#Teniendo en cuenta la idea de comunicar dos ordenadores mediante la voz del sistema operativo

#https://www.jesusninoc.com/2016/01/10/comunicar-dos-ordenadores-mediante-la-voz-del-sistema-operativo/

#Realizar una comunicación enviando preguntas y respondiendo de forma automática

####################################################################################################

Reconocimiento y respuesta (ejecutar primero)

####################################################################################################
#RECONOCIMIENTO Y RESPUESTA
####################################################################################################
#Crear objeto para reconocimiento
Add-Type -AssemblyName System.Speech
$rec = New-Object 'System.Speech.Recognition.SpeechRecognitionEngine'
$rec.LoadGrammar((New-Object 'System.Speech.Recognition.DictationGrammar'))
$rec.SetInputToDefaultAudioDevice()

#Añadir posibles respuestas
"tal|Bien y tú?" | Out-File frases.txt
"años|40" | Out-File frases.txt -Append
"novia|Sí" | Out-File frases.txt -Append
"novio|Sí" | Out-File frases.txt -Append

#Crear un ArrayList con las respuestas
[System.Collections.ArrayList]$arraylist = New-Object System.Collections.ArrayList
ForEach ($elemento in (gc .\frases.txt).split("|")){[void]$arraylist.Add($elemento)}

#Función para comprobar si el mensaje que llega está entre las posibles respuestas
#La función responde mediante la voz del Sistema Operativo
function comprobar($frase){
    [System.Collections.ArrayList]$arraylist2 = New-Object System.Collections.ArrayList
    ForEach ($elemento in $frase.split(" ")){[void]$arraylist2.Add($elemento)}

    $arraylist2 | %{
        if($arraylist.IndexOf($_) -ne -1){
            (New-Object -TypeName System.Speech.Synthesis.SpeechSynthesizer).Speak($arraylist[($arraylist.IndexOf($_))+1])
        }
    }
}

#Comenzar a reconocer los audios que vayan llegando y comprobar qué mensajes llegan
do{
$mensaje=$rec.Recognize().Text
$mensaje
comprobar $mensaje
}while(1)

####################################################################################################

#RECONOCIMIENTO Y RESPUESTA

####################################################################################################

#Crear objeto para reconocimiento

Add-Type -AssemblyName System.Speech

$rec = New-Object 'System.Speech.Recognition.SpeechRecognitionEngine'

$rec.LoadGrammar((New-Object 'System.Speech.Recognition.DictationGrammar'))

$rec.SetInputToDefaultAudioDevice()

#Añadir posibles respuestas

"tal|Bien y tú?" | Out-File frases.txt

"años|40" | Out-File frases.txt -Append

"novia|Sí" | Out-File frases.txt -Append

"novio|Sí" | Out-File frases.txt -Append

#Crear un ArrayList con las respuestas

[System.Collections.ArrayList]$arraylist = New-Object System.Collections.ArrayList

ForEach ($elemento in (gc .\frases.txt).split("|")){[void]$arraylist.Add($elemento)}

#Función para comprobar si el mensaje que llega está entre las posibles respuestas

#La función responde mediante la voz del Sistema Operativo

function comprobar($frase){

[System.Collections.ArrayList]$arraylist2 = New-Object System.Collections.ArrayList

ForEach ($elemento in $frase.split(" ")){[void]$arraylist2.Add($elemento)}

$arraylist2 | %{

if($arraylist.IndexOf($_) -ne -1){

(New-Object -TypeName System.Speech.Synthesis.SpeechSynthesizer).Speak($arraylist[($arraylist.IndexOf($_))+1])

}

#Comenzar a reconocer los audios que vayan llegando y comprobar qué mensajes llegan

do{

$mensaje=$rec.Recognize().Text

$mensaje

comprobar $mensaje

}while(1)

Enviar preguntas

####################################################################################################
#ENVIAR PREGUNTAS
####################################################################################################
#Leer el texto contenido dentro de un fichero mediante la voz del Sistema Operativo
Add-Type -AssemblyName System.Speech

#Añadir textos para que se lean
"¿Qué tal?" | Out-File conversacion.txt
"¿Cuántos años tienes?" | Out-File conversacion.txt -Append
"¿Tienes novia?" | Out-File conversacion.txt -Append

#Leer los textos mediante la voz del Sistema Operativo
gc conversacion.txt | %{
$_
(New-Object -TypeName System.Speech.Synthesis.SpeechSynthesizer).Speak($_)
Start-Sleep -Seconds 3
}

####################################################################################################

#ENVIAR PREGUNTAS

####################################################################################################

#Leer el texto contenido dentro de un fichero mediante la voz del Sistema Operativo

Add-Type -AssemblyName System.Speech

#Añadir textos para que se lean

"¿Qué tal?" | Out-File conversacion.txt

"¿Cuántos años tienes?" | Out-File conversacion.txt -Append

"¿Tienes novia?" | Out-File conversacion.txt -Append

#Leer los textos mediante la voz del Sistema Operativo

gc conversacion.txt | %{

(New-Object -TypeName System.Speech.Synthesis.SpeechSynthesizer).Speak($_)

Start-Sleep -Seconds 3

}

Mostrar un mensaje si se ha ejecutado correctamente un script de PowerShell desde C#

(No Ratings Yet)

using System;
using System.Collections.ObjectModel;
using System.Management.Automation;  // Windows PowerShell namespace.

namespace PowerSh
{
    class PowerSh
    {
        static void Main(string[] args)
        {
                using (PowerShell PowerShellInstance = PowerShell.Create())
                {
                    // use "AddScript" to add the contents of a script file to the end of the execution pipeline.
                    // use "AddCommand" to add individual commands/cmdlets to the end of the execution pipeline.
                    PowerShellInstance.AddScript("Get-Process | out-file out.txt");

                    Collection<PSObject> PSOutput = PowerShellInstance.Invoke();
                    foreach (PSObject outputItem in PSOutput)
                    {
                        // if null object was dumped to the pipeline during the script then a null
                        // object may be present here. check for null to prevent potential NRE.
                        if (outputItem != null)
                        {
                            Console.WriteLine(outputItem.BaseObject.ToString() + "\n");
                        }
                    }
                if (PowerShellInstance.Streams.Error.Count > 0)
                {
                    Console.Write("Error");
                }
                else
                {
                    Console.Write("Correcto");
                }
                    Console.ReadKey();
                }

        } // End Main.
    } // End PowerSh.
}

using System;

using System.Collections.ObjectModel;

using System.Management.Automation; // Windows PowerShell namespace.

namespace PowerSh

{

class PowerSh

{

static void Main(string[] args)

{

using (PowerShell PowerShellInstance = PowerShell.Create())

{

// use "AddScript" to add the contents of a script file to the end of the execution pipeline.

// use "AddCommand" to add individual commands/cmdlets to the end of the execution pipeline.

PowerShellInstance.AddScript("Get-Process | out-file out.txt");

Collection<PSObject> PSOutput = PowerShellInstance.Invoke();

foreach (PSObject outputItem in PSOutput)

{

// if null object was dumped to the pipeline during the script then a null

// object may be present here. check for null to prevent potential NRE.

if (outputItem != null)

{

Console.WriteLine(outputItem.BaseObject.ToString() + "\n");

}

if (PowerShellInstance.Streams.Error.Count > 0)

{

Console.Write("Error");

}

else

{

Console.Write("Correcto");

}

Console.ReadKey();

}

} // End Main.

} // End PowerSh.

}

Tutorial C# con PowerShell: bucle for

(1 votes, average: 5.00 out of 5)

$CodigoC = @”

using System;
using System.Collections.Generic;

public class For
{
    public static void Main()
    {
        int i;
        for( i = 0; i < 10; i++)
        {
                Console.Out.WriteLine(i);
        }
    }
}
 
“@
 
Add-Type -TypeDefinition $CodigoC -ErrorAction SilentlyContinue
 
[For]::Main()

$CodigoC = @”

using System;

using System.Collections.Generic;

public class For

{

public static void Main()

{

int i;

for( i = 0; i < 10; i++)

{

Console.Out.WriteLine(i);

}

“@

Add-Type -TypeDefinition $CodigoC -ErrorAction SilentlyContinue

[For]::Main()

Añadir elementos a una ArrayList

(No Ratings Yet)

#Inicializa una nueva instancia de la colección ArrayList que está vacía y tiene la capacidad inicial predeterminada
[System.Collections.ArrayList] $arraylist = New-Object System.Collections.ArrayList

#Agrega elementos a la colección ArrayList
[void]$arraylist.Add("uno")
[void]$arraylist.Add("dos")
[void]$arraylist.Add("tres")

#Número de elementos de ArrayList
$arraylist.Count

#Inicializa una nueva instancia de la colección ArrayList que está vacía y tiene la capacidad inicial predeterminada

[System.Collections.ArrayList] $arraylist = New-Object System.Collections.ArrayList

#Agrega elementos a la colección ArrayList

[void]$arraylist.Add("uno")

[void]$arraylist.Add("dos")

[void]$arraylist.Add("tres")

#Número de elementos de ArrayList

$arraylist.Count

Añadir elementos a una ArrayList y ordenar los elementos

(No Ratings Yet)

#Inicializa una nueva instancia de la clase ArrayList que está vacía y tiene la capacidad inicial predeterminada
[System.Collections.ArrayList] $arraylist = New-Object System.Collections.ArrayList

#Agrega elementos a la clase ArrayList
[void]$arraylist.Add("uno")
[void]$arraylist.Add("dos")
[void]$arraylist.Add("tres")

#Número de elementos de ArrayList
$arraylist.Count

#ArrayList sin ordenar
$arraylist

#Ordenar elementos de ArrayList
$arraylist.Sort()

#ArrayList ordenado
$arraylist

#Inicializa una nueva instancia de la clase ArrayList que está vacía y tiene la capacidad inicial predeterminada

[System.Collections.ArrayList] $arraylist = New-Object System.Collections.ArrayList

#Agrega elementos a la clase ArrayList

[void]$arraylist.Add("uno")

[void]$arraylist.Add("dos")

[void]$arraylist.Add("tres")

#Número de elementos de ArrayList

$arraylist.Count

#ArrayList sin ordenar

$arraylist

#Ordenar elementos de ArrayList

$arraylist.Sort()

#ArrayList ordenado

$arraylist

Análisis de frecuencias de letras en el libro “The Comedy of Errors” con PowerShell (parte 6)

(No Ratings Yet)

#Abrir el fichero comedyoferrors.txt, añadir a una ArrayList, agrupar y obtener la frecuencia de cada una de las letras que contiene el fichero

#Inicializa una nueva instancia de la clase ArrayList que está vacía y tiene la capacidad inicial predeterminada
[System.Collections.ArrayList] $arraylist = New-Object System.Collections.ArrayList
 
ForEach ($elemento in gc .\comedyoferrors.txt){
#Agrega un objeto al final de ArrayList
0..($elemento.Length-1) | %{
[void]$arraylist.Add($elemento[$_])
}
}

$arraylist | Group-Object | Sort-Object Count -Descending | select Name,Count

#Abrir el fichero comedyoferrors.txt, añadir a una ArrayList, agrupar y obtener la frecuencia de cada una de las letras que contiene el fichero

#Inicializa una nueva instancia de la clase ArrayList que está vacía y tiene la capacidad inicial predeterminada

[System.Collections.ArrayList] $arraylist = New-Object System.Collections.ArrayList

ForEach ($elemento in gc .\comedyoferrors.txt){

#Agrega un objeto al final de ArrayList

0..($elemento.Length-1) | %{

[void]$arraylist.Add($elemento[$_])

}

$arraylist | Group-Object | Sort-Object Count -Descending | select Name,Count

Frecuencia de uso de letras en inglés

Análisis de frecuencias de letras en el libro “El Principito” con PowerShell (parte 6)

(No Ratings Yet)

#Abrir el fichero principito.txt, añadir a una ArrayList, agrupar y obtener la frecuencia de cada una de las letras que contiene el fichero

#Inicializa una nueva instancia de la clase ArrayList que está vacía y tiene la capacidad inicial predeterminada
[System.Collections.ArrayList] $arraylist = New-Object System.Collections.ArrayList
 
ForEach ($elemento in gc .\principito.txt){
#Agrega un objeto al final de ArrayList
0..($elemento.Length-1) | %{
[void]$arraylist.Add($elemento[$_])
}
}

$arraylist | Group-Object | Sort-Object Count -Descending | select Name,Count

#Abrir el fichero principito.txt, añadir a una ArrayList, agrupar y obtener la frecuencia de cada una de las letras que contiene el fichero

#Inicializa una nueva instancia de la clase ArrayList que está vacía y tiene la capacidad inicial predeterminada

[System.Collections.ArrayList] $arraylist = New-Object System.Collections.ArrayList

ForEach ($elemento in gc .\principito.txt){

#Agrega un objeto al final de ArrayList

0..($elemento.Length-1) | %{

[void]$arraylist.Add($elemento[$_])

}

$arraylist | Group-Object | Sort-Object Count -Descending | select Name,Count

Frecuencia de uso de letras en español

SpiderFoot 2.9.0

(No Ratings Yet)

SpiderFoot 2.9.0 is now out, totaling almost 60 data collection/analysis modules for your reconnaissance, footprinting and OSINT needs. Here’s what’s […]

Análisis y representación de frecuencias de letras en el libro “El ingenioso hidalgo Don Quijote de la Mancha” cifrado de forma compleja y sin cifrar con PowerShell (parte 11)

(No Ratings Yet)

Sin cifrar

#Abrir el fichero quijote.txt, añadir a una ArrayList, agrupar y obtener la frecuencia cada una de las letras que contiene el fichero

#Inicializa una nueva instancia de la clase ArrayList que está vacía y tiene la capacidad inicial predeterminada
[System.Collections.ArrayList] $arraylist = New-Object System.Collections.ArrayList
 
ForEach ($elemento in gc .\quijote.txt){
#Agrega un objeto al final de ArrayList
0..($elemento.Length-1) | %{
[void]$arraylist.Add($elemento[$_])
}
}

#Representar la frecuencia gráficamente
$arraylist | Group-Object | Sort-Object Count -Descending | select Name,Count | %{
$frecuencia=([math]::truncate(($_.count/$arraylist.Count)*100))
$frecuenciadibujo=((1..$frecuencia) | %{Write-Host '█' -NoNewline})
Write-Host $_.name,$frecuencia,$frecuenciadibujo
}

#Abrir el fichero quijote.txt, añadir a una ArrayList, agrupar y obtener la frecuencia cada una de las letras que contiene el fichero

#Inicializa una nueva instancia de la clase ArrayList que está vacía y tiene la capacidad inicial predeterminada

[System.Collections.ArrayList] $arraylist = New-Object System.Collections.ArrayList

ForEach ($elemento in gc .\quijote.txt){

#Agrega un objeto al final de ArrayList

0..($elemento.Length-1) | %{

[void]$arraylist.Add($elemento[$_])

}

#Representar la frecuencia gráficamente

$arraylist | Group-Object | Sort-Object Count -Descending | select Name,Count | %{

$frecuencia=([math]::truncate(($_.count/$arraylist.Count)*100))

$frecuenciadibujo=((1..$frecuencia) | %{Write-Host '█' -NoNewline})

Write-Host $_.name,$frecuencia,$frecuenciadibujo

}

Cifrado complejo

#Abrir el fichero quijotecifcomplex.txt, añadir a una ArrayList, agrupar y obtener la frecuencia cada una de las letras que contiene el fichero

#Inicializa una nueva instancia de la clase ArrayList que está vacía y tiene la capacidad inicial predeterminada
[System.Collections.ArrayList] $arraylist = New-Object System.Collections.ArrayList
 
ForEach ($elemento in gc .\quijotecifcomplex.txt){
#Agrega un objeto al final de ArrayList
0..($elemento.Length-1) | %{
[void]$arraylist.Add($elemento[$_])
}
}

#Representar la frecuencia gráficamente
$arraylist | Group-Object | Sort-Object Count -Descending | select Name,Count | %{
$frecuencia=([math]::truncate(($_.count/$arraylist.Count)*100))
$frecuenciadibujo=((1..$frecuencia) | %{Write-Host '█' -NoNewline})
Write-Host $_.name,$frecuencia,$frecuenciadibujo
}

#Abrir el fichero quijotecifcomplex.txt, añadir a una ArrayList, agrupar y obtener la frecuencia cada una de las letras que contiene el fichero

#Inicializa una nueva instancia de la clase ArrayList que está vacía y tiene la capacidad inicial predeterminada

[System.Collections.ArrayList] $arraylist = New-Object System.Collections.ArrayList

ForEach ($elemento in gc .\quijotecifcomplex.txt){

#Agrega un objeto al final de ArrayList

0..($elemento.Length-1) | %{

[void]$arraylist.Add($elemento[$_])

}

#Representar la frecuencia gráficamente

$arraylist | Group-Object | Sort-Object Count -Descending | select Name,Count | %{

$frecuencia=([math]::truncate(($_.count/$arraylist.Count)*100))

$frecuenciadibujo=((1..$frecuencia) | %{Write-Host '█' -NoNewline})

Write-Host $_.name,$frecuencia,$frecuenciadibujo

}

Comparación de frecuencias (las frecuencias del fichero cifrado de forma compleja se suavizan)

Older Posts