Jason Igneel

Script sin verificación de credenciales

------------------------------
Send-MailMessage -From "Jason Igneel <jasonigneel@ejemplo.com>" -To "user@ejemplo.com.ec" -Subject "Sending the Attachment" -Body "Forgot to send the attachment. Sending now." -dno onSuccess, onFailure -SmtpServer "11.110.190.78" -Port "587"
------------------------------

Podemos guiarnos como referencia al primer script  Aqui.

Script con validación de credenciales

creamos un block de notas con estos parámetros
-----------------------------
Nombre, Email, Mensaje
Jason Igneel, jasonpruba@ejemplo.com.ec, Hello everyone
----------------------------
guardamos el archivo de bloc de notas con la extensión .cvs  

en el siguiente archivo creamos un bloc de notas nuevo y copiamos el código de abajo y guardamos con la extensión .ps1 

Código:
------------------------------
$Listado = Import-Csv C:\Users\desktop\Listado.csv

$SMTPServer = "smtp.gmail.com"
$SMTPPort = "587"

$Username = "email@gmail.com"
$Password = "password email"

foreach ( $persona  in  $Listado)
{
    $iName =$persona.Nombre
    $iEmail =$persona.Email
    $iMensaje =$persona.Mensaje
     
    $to = $persona.Email
    $subject ="email@gmail.com"
    $body = @"
    Hola $iName,
     $iMensaje
"@                       

    $mensaje = New-Object System.Net.Mail.MailMessage
    $mensaje.subject = $subject
    $mensaje.body = $body
    $mensaje.to.add($to)
    $mensaje.From = $Username

    $smtp = New-Object System.Net.Mail.SmtpClient ( $SMTPServer , $SMTPPort ) ;
    $smtp.EnableSSL = $true
    $smtp.Credentials = New-Object System.Net.NetworkCredential ( $Username , $Password ) ;
    $smtp.send($mensaje)
    Write-Host  de escritura de correo enviado a $iName
}

MODULO DE FACTURACIÓN

MegaDownloader v1.7 Multilenguaje

#include<iostream>
#include <stdio.h>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
//****************************** INSERTAR ************************************//

int *Insertar(int *A ,int N)
{
 for( int i = 0 ; i < N ; i++ )
    {
        cout<<endl<<"    - Ingrese el valor ["<<i + 1<<"] = ";
        cin>>A[i];
   
    }
 return A;  
}
//******************************* MOSTRAR ************************************//
void Mostrar(int *A ,int N)
{

 for( int i = 0 ; i < N ; i++ )
    {
   
    cout<<endl<<"      - Valor ["<<i + 1<<"] = "<<A[i]<<endl;
   
    }    
}

/****************************************************************************
el método de la sacudida (shaker sort).
Es la operación de arreglar los registros de una tabla en algún orden secuencial de acuerdo a cierto criterio de orden,
con el propósito principal de facilitar las búsqueda de los miembros del conjunto ordenado.
//****************************** SHAKER o sacudida**************************************/

int *Shaker(int *A, int N)
{
 int i = 0 , izq = 1 , der = N-1 , k = N-1 , aux = 0;
 while( der >= izq )
      {
      for( i = der ; i>= izq ; i-- )  
            if( A[i-1] > A[i])
              {
                aux = A[i-1];
                       
                A[i-1]=A[i];
                       
                A[i]=aux;
                       
                k=i;                    
              }            
      izq = k + 1;    
      for( i = izq ; i <= der ; i++)
             
            if( A[i-1] > A[i] )
                 
              {
                   
                aux = A[i-1];
                       
                A[i-1]=A[i];
                       
                A[i]=aux;
                       
                k=i;
              }
     
      der = k-1;

    }
 return A;
}

int main()
{
  system("COLOR F3");
   
  int *A = NULL;

  A = (int*)malloc(sizeof(int));

  int N;

  int opcion;
     
  cout<<endl<<"  >> INGRESE LOS VALORES :  ";
  cout<<endl<<"      --------------------------------> ";
  cin>>N;
 
  A = Insertar( A , N );
  A = Shaker( A , N );
               
                cout<<endl<<"  - [ METODO MEDIANTE SHAKER (SACUDIDA) ] - "<<endl;
               
                Mostrar(A , N);
    cout<<endl<<endl;
 system("pause");

}
//metodo de Shell
#include<iostream>
#include <stdio.h>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
//****************************** INSERTAR ************************************//

int *Insertar(int *A ,int N)
{
 for( int i = 0 ; i < N ; i++ )
    {
        cout<<endl<<"    - Ingrese el valor ["<<i + 1<<"] = ";
        cin>>A[i];
   
    }
 return A;  
}
//******************************* MOSTRAR ************************************//
void Mostrar(int *A ,int N)
{

 for( int i = 0 ; i < N ; i++ )
    {
   
    cout<<endl<<"      - Valor ["<<i + 1<<"] = "<<A[i]<<endl;
   
    }    
}

/****************************************************************************
El ordenamiento Shell (Shell sort en inglés) es un algoritmo de ordenamiento. El método se denomina Shell en honor de su inventor Donald Shell.
Su implementación original, requiere O(n2) comparaciones e intercambios en el peor caso. Un cambio menor presentado en el libro de V.
Pratt produce una implementación con un rendimiento de O(n log2 n) en el peor caso.
Esto es mejor que las O(n2) comparaciones requeridas por algoritmos simples pero peor que el óptimo O(n log n).
Aunque es fácil desarrollar un sentido intuitivo de cómo funciona este algoritmo, es muy difícil analizar su tiempo de ejecución.
//****************************** SHELL ***************************************/
int *Shell(int *A , int N)
{

 int i,j,bandera,aux;


 for( j = N/2 ; j > 0 ; j = j/2)
   
    {

    do
     {
   
        bandera=0;

       for( i = 0 ; i < N - j ; i++)
            {
           
          if( A[i] > A[i+j] )
            {
           
                aux = A[i];
             
                A[i] = A[i+j];
             
                A[i+j] = aux;
             
                bandera=1;
               
            }
     
            }
        }    
   
    while(bandera);

  }
 
 return A;
     
}

int main()
{
  system("COLOR F9");
   
  int *A = NULL;

  A = (int*)malloc(sizeof(int));

  int N;

  int opcion;
     
  cout<<endl<<"  >> INGRESE LOS VALORES :  ";
  cout<<endl<<"      --------------------------------> ";
  cin>>N;
 
  A = Insertar( A , N );
  A = Shell( A , N );
         cout<<endl<<"  - [ METODO MEDIANTE SHELL ] - "<<endl;
               
                Mostrar(A , N);
    cout<<endl<<endl;
 system("pause");

}
#include<iostream>
 #include <algorithm> //para la función sort
 #define LIM 50
 using namespace std;
 /****************************************************************************
El ordenamiento rápido (quicksort en inglés) es un algoritmo basado en la técnica de divide y vencerás, que permite, en promedio,
ordenar n elementos en un tiempo proporcional a n log n.
//****************************** Quitshort **************************************/

 void LeerArray(int n,int x[]);
 void MostrarArray(int n,int x[]);

 int main()
 {
  int n;
  int x[LIM];
  cout<<" -> Ingrese el numero de elementos :";cin>>n;
  LeerArray(n,x);
  sort(x,x+n);//sort(array,array+numeroelementos);
  cout<<"\t\t\t *** MEtodo Quic sort *** "<<endl<<endl;
  cout<<"\t";MostrarArray(n,x);
  system("pause>>null");
  return 0;
 }

 void MostrarArray(int n,int x[])
 {
     for(int i=0;i<n;i++)
     {
         cout<<x[i]<<" ";
     }
 }
 void LeerArray(int n,int x[])
 {
     for(int i=0;i<n;i++)
     {
         cout<<" Elemento ["<<i<<"]:";cin>>x[i];
     }
}