Hacer un Triangulo de Pascal en C#

el triángulo de Pascal es una representación de los coeficientes binomiales ordenados en forma triangular. Es llamado así en honor al matemático francés Blaise Pascal, quien introdujo esta notación en 1654, en su Traité du triangle arithmétique. Si bien las propiedades y aplicaciones del triángulo fueron conocidas con anterioridad al tratado de Pascal por matemáticos indios, chinos o persas, fue Pascal quien desarrolló muchas de sus aplicaciones y el primero en organizar la información de manera conjunta.

La construcción del triángulo está relacionada con los coeficientes binomiales según la fórmula (también llamada Regla de Pascal).

Esta aplicación ya la había subido anteriormente pero en C++, esta vez modificando la sintaxis funciona igual

Aquí les dejo el link del triangulo hecho en C++ para quien le interese.

Link : Pascal C++

La salida de este programa sería de esta forma:

El código es el siguiente :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Pascal{
    class Pascal{
        public static int factorial(int numero){
            int factorial = 1;
            for (int i = 1; i <= numero; ++i)
                factorial *= i;
            return factorial;
        }
        public static int formula(int numero, int posicion){
            int combinacion;
            combinacion = factorial(numero) / 
                (factorial(numero - posicion) * factorial(posicion));
            return combinacion; 
        }

        static void Main(string[] args){
            Console.WriteLine("\t\t Triangulo de Pascal en C#");
            Console.WriteLine("\t________________________________________");
            Console.ForegroundColor = ConsoleColor.Red;
            Console.Write("\nIngresa la potencia: ");
            int numero = int.Parse(Console.ReadLine());
            int x = numero * 2;
            for (int i = 0; i <= numero; ++i, x -= 2){
                for (int s = 0; s <= x; ++s)
                    Console.Write(" ");
                Console.ForegroundColor = ConsoleColor.Yellow;
                for (int k = 0; k <= i; ++k)
                    Console.Write(String.Format("{0,4:D}", formula(i,k)));
                Console.WriteLine();
            }            
            Console.ReadKey();
        }
    }
}

Hacer un método de ordenamiento rápido (Quicksort) en C#

El ordenamiento rápido (quicksort en inglés) es un algoritmo creado por el científico británico en computación C. A. R. Hoare 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.


El algoritmo trabaja de la siguiente forma:

• Elegir un elemento de la lista de elementos a ordenar, al que llamaremos pivote.
• Resituar los demás elementos de la lista a cada lado del pivote, de manera que a un lado queden todos los menores que él, y al otro los mayores. Los elementos iguales al pivote pueden ser colocados tanto a su derecha como a su izquierda, dependiendo de la implementación deseada. En este momento, el pivote ocupa exactamente el lugar que le corresponderá en la lista ordenada.
• La lista queda separada en dos sublistas, una formada por los elementos a la izquierda del pivote, y otra por los elementos a su derecha.
• Repetir este proceso de forma recursiva para cada sublista mientras éstas contengan más de un elemento. Una vez terminado este proceso todos los elementos estarán ordenados.

Como se puede suponer, la eficiencia del algoritmo depende de la posición en la que termine el pivote elegido.

• En el mejor caso, el pivote termina en el centro de la lista, dividiéndola en dos sublistas de igual tamaño. En este caso, el orden de complejidad del algoritmo es O(n·log n).
• En el peor caso, el pivote termina en un extremo de la lista. El orden de complejidad del algoritmo es entonces de O(n²). El peor caso dependerá de la implementación del algoritmo, aunque habitualmente ocurre en listas que se encuentran ordenadas, o casi ordenadas. Pero principalmente depende del pivote, si por ejemplo el algoritmo implementado toma como pivote siempre el primer elemento del array, y el array que le pasamos está ordenado, siempre va a generar a su izquierda un array vacío, lo que es ineficiente.

En el caso promedio, el orden es O(n·log n).
No es extraño, pues, que la mayoría de optimizaciones que se aplican al algoritmo se centren en la elección del pivote.

Este método es mucho mas eficiente que el método burbuja, aunque el algoritmo sea mas complejo, lo que lo hace mas eficiente es que es mucho menos pesado en cuanto a búsqueda y acomodo de los datos.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace QuickSort{
    class Ordenamiento{       
        private static int cont;
        public Ordenamiento(){
            cont = 0;
        }
        public static void swap(int []datos, int i, int j) {
            int aux = datos[i];
            datos[i] = datos[j];
            datos[j] = aux;
            cont++; // variable global
        }
        public  static int OrdenamientoRapido(int []datos, int numero) { 
            cont = 0;
            OrdenamientoRapido(datos, 0, numero-1);
            return cont;
        }
        public static void OrdenamientoRapido(int []datos, int inf, int sup) {
            if (sup > inf) {
                int pivote = datos[sup];
                int i = inf - 1;
                int j = sup;
                do {
                    while (datos[++i] < pivote);
                    while (datos[--j] > pivote);
                    if (i < j) 
                       swap(datos, i, j);
                } 
                while (i < j);
                swap(datos, i, sup);
                OrdenamientoRapido(datos, inf, i-1);
                OrdenamientoRapido(datos, i+1, sup);
            }
        }        
        static void Main(string[] args){
            int limite;
            String linea;
            Console.WriteLine("Ordenamento rapido en C#...\n");
            Console.Write("Ingresa el limite: ");
            linea = Console.ReadLine();
            limite = int.Parse(linea);
            int[] arreglo = new int[limite];

            for (int i = 0; i < limite; ++i){
                Console.Write("{0} : ", i + 1);
                linea = Console.ReadLine();
                arreglo[i] = int.Parse(linea);
            }
            OrdenamientoRapido(arreglo, limite);

            Console.ForegroundColor = ConsoleColor.DarkRed;
            for (int i = 0; i < limite; ++i){
                Console.WriteLine("\n{0} : {1}", i+1, arreglo[i]);
            }
            Console.ReadKey();
        }
    }
}

Esta sería la salida del mismo...

Hacer una calculadora en C#

Hoy les traje este POST, donde muestro un ejemplo de como hacer una calculadora  en la consola, esto solo con el fin de que se den una idea los que aun les cuesta trabajo adaptarse a C#, aquellos que ya han hecho algo parecido en C++ o en Java no tendrán problema alguno en entender este sencillo código.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1{
    class Calculadora{
        public static double suma(double numero, double numero2){
            return numero + numero2;
        }
        public static double resta(double numero, double numero2) {
            return numero - numero2;
        }
        public static double multiplicacion(double numero, double numero2){
            return numero * numero2;
        }
        public static double division(double numero, double numero2){
            if(numero2 == 0)
                Console.WriteLine("error");
            return  (numero / numero2);
        }
        public static int menu(){
            int opcion;
            Console.WriteLine("1) Suma ");
            Console.WriteLine("2) Resta ");
            Console.WriteLine("3) Multiplicacion ");
            Console.WriteLine("4) Division ");
            Console.WriteLine("5) Salir\n");
            Console.Write("Opcion: ");
            opcion = Convert.ToInt32(Console.ReadLine());
            return opcion;            
        }
        public static void insertar(ref double numero1,ref double numero2){
            Console.Write("Ingresa el primer numero: ");
            numero1 = Convert.ToDouble(Console.ReadLine());
            Console.Write("Ingresa el segundo numero: ");
            numero2 = Convert.ToDouble(Console.ReadLine());
        }
        static void Main(){
            double numero1 = 0;
            double numero2 = 0;
            double resultado = 0;
            int opcion=0;
            do{
                Console.Clear();
                opcion = menu();
                switch (opcion){
                    case 1:
                        insertar(ref numero1, ref numero2);
                        resultado = suma(numero1, numero2);
                        Console.WriteLine("El resultado es: {0}", resultado);
                        break;
                    case 2:
                        insertar(ref numero1, ref numero2);
                        resultado = resta(numero1, numero2);
                        Console.WriteLine("El resultado es: {0}", resultado);
                        break;
                    case 3:
                        insertar(ref numero1, ref numero2);
                        resultado = multiplicacion(numero1, numero2);
                        Console.WriteLine("El resultado es: {0}", resultado);
                        break;
                    case 4:
                        insertar(ref numero1, ref numero2);
                        resultado = division(numero1, numero2);
                        Console.WriteLine("El resultado es: {0}", resultado);
                        break;
                    case 5:
                        Console.WriteLine("Adios");
                        break;
                    default:
                        Console.WriteLine("Error");
                        break;                         
                }
                string algo = Console.ReadLine();
    Console.ReadKey();
            } while (opcion != 5);
        }
    }
}

Hacer un Metodo burbuja en C#

La Ordenación de burbuja (Bubble Sort en inglés) es un sencillo algoritmo de ordenamiento. Funciona revisando cada elemento de la lista que va a ser ordenada con el siguiente, intercambiándolos de posición si están en el orden equivocado. Es necesario revisar varias veces toda la lista hasta que no se necesiten más intercambios, lo cual significa que la lista está ordenada. Este algoritmo obtiene su nombre de la forma con la que suben por la lista los elementos durante los intercambios, como si fueran pequeñas "burbujas". También es conocido como el método del intercambio directo. Dado que solo usa comparaciones para operar elementos, se lo considera un algoritmo de comparación, siendo el más sencillo de implementar.

Anteriormente ya había hecho una publicación de un método burbuja en C++, así que todo aquel que anteriormente ya hubiera hecho un método burbuja o método rápido, o cualquiera, se podrá dar cuenta que es bastante fácil hacerlo en C#, solo es cuestión de acostumbrarse a la sintaxis que maneja C#. Eh aquí el ejemplo.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1{
    class Program{
        static void Main(string[] args){
            Console.ForegroundColor = ConsoleColor.Green;
            string linea;
            int limite;
            Console.WriteLine("Metodo Burbuja en C#... \n");
            Console.Write("Ingresa el limite: ");
            linea = Console.ReadLine();
            limite = int.Parse(linea);
            Console.ForegroundColor = ConsoleColor.Blue;
            int[] arreglo = new int[limite];
            for (int i = 0; i < limite; ++i){
                Console.Write("{0} : ", i+1);
                linea = Console.ReadLine();
                arreglo[i] = int.Parse(linea);
            }
            for (int i = 0; i < limite; ++i){
                for (int j = i; j < limite; ++j){
                    if (arreglo[i] > arreglo[j]){
                        int aux = arreglo[i];   
                        arreglo[i] = arreglo[j];
                        arreglo[j] = aux;
                    }
                }
            }
            Console.ForegroundColor = ConsoleColor.DarkRed;
            for (int i = 0; i < limite; ++i)
                Console.WriteLine("\n{0} : {1}", i+1, arreglo[i]);
            Console.ReadKey();
        }
    }
}

Esta seria la salida del programa:

Eliminar Virus Recycler de la memoria USB y mas

Bueno antes que nada, ya había hecho una pequeña aplicación donde podían guardarla en la raíz de su memoria y ejecutarla para eliminar el virus RECYCLER y restaurar carpetas.

Esta vez hice uno parecido, este esta un poco mas completo, viene con un menú para recuperar las carpetas, eliminar otros virus conocidos y el famoso RECYCLER .

Les dejo el link para que lo descarguen de una cuenta FTP.

Recuerden guardarlo solamente en la raíz de la memoria.

Se aceptan sugerencias...

Link: AntiRecyclerMejorado