Solucion #Reto 1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace Reto1_NET
{
    class Program
    {
        static void Main(string[] args)
        {
            const int numero = 1000;
            int suma = 0;
 
            Console.WriteLine("======================================================== ");
            Console.WriteLine("                      RETO #1                            ");
            Console.WriteLine("Suma de todos los multiplos de 3 y 5 por debajo de 1000  ");
            Console.WriteLine("======================================================== ");
 
            for (int i = 0; i < numero; i++)
                if ((i % 3 == 0) || (i % 5 == 0))
                {
                    Console.WriteLine(i);
                    suma = suma + i;
                }
            Console.WriteLine("La suma de los multiplos es : ");
            Console.WriteLine(suma);
            Console.ReadLine();
        }
    }
}

De momento no se me ocurre ningún reto, si alguien quiere poner algo : Que lo ponga xD

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace Reto1_Net
{
    class Program
    {
        static void Main(string[] args)
        {
            int suma = 0, i;
            for (i = 1; i < 1000; i++)
            {
                if (((i % 3) == 0) || ((i % 5) == 0))
                {
                    suma += i;
                    //Console.Write(i+" ");
                    //Por si queréis ver los números
                }
            }
 
            Console.WriteLine("El total de las sumas es: "+suma);
            Console.Read();
            //El resultado es 233168
        }
    }
}

Reto2: Teniendo los extremos de un intervalo, mostrar todos los números primos comprendidos entre ellos incluyendo dichos extremos

Quiero que sepas que te odio por estos ejercicios raros

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace Reto3_Net
{
    class Program
    {
        static void Main(string[] args)
        {
            curious obj = new curious();
            int a, b, aux;
 
            try
            {
                Console.Write("Número 1: ");
                a = Convert.ToInt32(Console.ReadLine());
 
                Console.Write("Número 2: ");
                b = Convert.ToInt32(Console.ReadLine());
 
                if (a > b)
                {
                    aux = a;
                    a = b;
                    b = aux;
                }
 
                for (aux = a; aux <= b; aux++)
                    if (obj.curioso(aux))
                        Console.Write(aux + " ");
            }
            catch(Exception e)
            {
                Console.WriteLine(e.Message);
            }
            Console.Read();
        }
    }
 
    class curious
    {
        private int num(char a)
        {
            int b = 0;
            switch (a)
            {
                case '0': b = 0;
                    break;
 
                case '1': b = 1;
                    break;
 
                case '2': b = 2;
                    break;
 
                case '3': b = 3;
                    break;
 
                case '4': b = 4;
                    break;
 
                case '5': b = 5;
                    break;
 
                case '6': b = 6;
                    break;
 
                case '7': b = 7;
                    break;
 
                case '8': b = 8;
                    break;
 
                case '9': b = 9;
                    break;
            }
 
            return b;
        }
        public bool curioso(int a)
        {
            int aux = 0;
            String cad = a.ToString();
            for (int i = 0; i < cad.Length; i++)
                aux += factorial(num(cad[i]));
 
            if (aux == a)
                return true;
 
            else
                return false;
        }
        public int factorial(int a)
        {
            if (a <= 1)
                return 1;
            else
                return a * factorial(a - 1);
        }
    }
}

Si al comprobarlo ves que no es un FAIL, me mandas un mp y pongo el cuarto reto :B

Esta forma es mas eficiente ya que solo calcula los factoriales 10 veces,
faltaria implementar factorial de manera no recursiva...

Tambien le falta agragar un poco de elegancia al codigo, no me gusta tanto el hecho de que Program.Fact sea static, deberia inclurilo dentro de una clase curious como el codigo anterior, pero eso ya no lo hago yo

El codigo esta en c#:

using System;
 
namespace Problema2Mejorado
{
    class Program
    {
        static Factorial fact = new Factorial(10);
        static void Main(string[] args)
        {
            int inicio, final;
            Console.WriteLine("Introduzca el primer numero del intervalo");
            inicio = int.Parse(Console.ReadLine());
            Console.WriteLine("Introduzca el ultimo numero del intervalo");
            final = int.Parse(Console.ReadLine());
            for (int probar = inicio; probar <= final; probar++)
            {
                if (EsCurioso(probar))
                    Console.WriteLine("{0}, ", probar);
            }
            Console.ReadKey();
        }
        //Para omitir conversiones inutiles recibo el numero como string ya q necesito analizar sus digitos
        static bool EsCurioso(int Numero)
        {
            string Num = Numero.ToString();
            int sumador = 0;
            foreach (char digito in Num)
            {
                //Con esto me ahorro todo el switch case del otro codigo :p
                int ValorDigito = int.Parse(digito.ToString());
                sumador += fact[ValorDigito];
            }
            if (sumador == int.Parse(Num))
                return true;
            else
                return false;
        }
    }
 
    class Factorial
    {
        //En este arreglo guardaremos los factoriales de 0 hasta 9, para q solo tengan q ser calculados una vez :)
        private int[] factoriales;
        public Factorial(int rango)
        {
            factoriales = new int[rango];
            for (int i = 0; i < rango; i++)
            {
                factoriales[i] = CalcularFactorial(i);
            }
        }
        int CalcularFactorial(int n)
        {
            if (n <= 1)
                return 1;
            else
                return n * CalcularFactorial(n - 1);
        }
        //Y de manera muy limpia obtenemos el factorial de un numero con el operador []
        public int this[int i]
        {
            get
            {
                return factoriales[i];
            }
        }
    }
}
 
 

Reto 3:

El usuario proporcionara un numero de pruebas p, y un numero de intervalos n

El programa debera generar p numeros aleatorios entre 1 y q (tal que q sea el menor numero divisible por n, pero mayor o igual a 100), y elaborar un reporte sobre que porcentaje de los numeros cayo en cada intervalo.

Si por ejemplo el numero de intervalos n es 4, se consideraran los intervalos 1-25, 26-50, 51-75 y 75-100.


No se si me deje entender, si no lo hice avisenme...

using System;
using System.Collections.Generic;
using System.Linq;
 
namespace Reto5
{
    public class Student
    {
        public byte Score { get; set; }
        public string Name { get; set; }
 
        public Student(string input) 
        {
            Score = Convert.ToByte(input.Substring(0, 2));
            Name = input.Substring(3);
        }
        public override string ToString()
        {
            return string.Format("Score: {0:00}, Name = {1}", Score, Name);
        }
    }
    static class Program
    {
        static int Main()
        {
            byte scoreLine = 5, capacity = 3;
 
            List<Student> students = new List<Student>();
 
            Console.WriteLine("Ingrese alumnos, formato: NN NOMBRE en donde NN es la nota.");
            string input = string.Empty;
 
            while (!string.IsNullOrEmpty(input = Console.ReadLine())) 
            {
                students.Add(new Student(input));
            }
 
            if(students.Count <= capacity)
                ShowList(students);
            else
            {
                var query = (from s in students
                            where s.Score > scoreLine
                            orderby s.Score descending
                            select s).Where((s, index) => index < capacity);
                ShowList(query);
            }
            Console.ReadKey();
            return 0;
        }
 
        private static void ShowList(IEnumerable<Student> students)
        {
            foreach (var s in students)
                Console.WriteLine(s.ToString());
        }
    }
}

Reto #6

Una lista/array/vector/queue o lo que quieran, debe contener una cantidad de palabras. El reto consiste en comparar esas palabras para conseguir posibles anagramas.
Ejm: si tengo el array: "arroz", "zorra" la aplicación debe mostrar que esos dos son anagramas.



EDIT: El array debe ser más o menos grande, o permitir la adición de elementos por parte del usuario, como quieran, pero no solamente arroz y zorra  
EDIT2: No solo es palíndromo, sino que también en forma de anagrama, por ejemplo: ROMA - AMOR - OMAR - MORA - RAMO 

Bueno cómo nadie resolvió el reto, voy a poner la solución:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace Reto6
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] words = { "programador", "framework", "zorra", "mora", "amor", "roma", "arroz" };
 
            var wordsOrdered = words.GroupBy(w => w.Trim(), new AnagramComparer());
 
            foreach (var a in wordsOrdered)
            {
                Console.WriteLine("**********************");
                foreach (var b in a)
                {
                    Console.WriteLine(b);
                }
            }
            Console.WriteLine("**********************");
        }
    }
}
 
 
public class AnagramComparer : IEqualityComparer<string>
{
    public bool Equals(string x, string y)
    {
        return getLetters(x) == getLetters(y);
    }
 
    public int GetHashCode(string obj)
    {
        return getLetters(obj).GetHashCode();
    }
 
    private string getLetters(string word)
    {
        char[] chars = word.ToCharArray();
        Array.Sort<char>(chars);
        return new string(chars);
    }
}
 

Reto #7
El número 197 es llamado primo circular porque todas las combinaciones de sus digitos son primos también.

Hay 13 primos por debajo de 100 que son circulares:  2, 3, 5, 7, 11, 13, 17, 31, 37, 71, 73, 79, and 97.

El reto consiste en saber cuantos primos circulares hay por debajo de un millón.

Reto #8
El que haga este proceso en menos tiempo.. Así que a postear soluciones que yo les mido el rendimiento del método.

 

Ni idea, calculo unos 1-2 minutos. Supongo. Puede que más.. Puede que menos x) Si ya lo terminaste, postealo, y cualquier cosa lo vamos optimizando.