Reto al azar: 003

Actualmente tenemos 30 retos en nuestra base de datos. Accediendo al reto 3.

Nivel de dificultad aproximado (1 a 5): 2  

Tienes un reloj digital con LEDs de 7 segmentos. Un día, al despertar de un sueño de ciencia-ficción, te preguntas: ¿cuántos segmentos se han encendido DESPUÉS DE X segundos, desde la posición 00:00:00?

Considera que en cada segundo, todos los led se apagan y luego se encienden los correspondientes al instante actual.

(Recuerda: no debe ser "amigable", sino estricto: no debe decir nada como "introduce los segundos" ni responder con nada como "la cantidad de LEDs es..."; debe tomar cada línea de datos de la entrada estándar, analizarla y mostrar los resultados en la salida estándar, tantas veces como líneas de entrada existan).

Ejemplo de entrada
0
4

Salida correspondiente
36
172

Aportar una solución

Tu nombre (si quieres que aparezca):
Tu web/blog (si quieres que incluyamos un enlace a ella):
Tu e-mail (no se mostrará; si quieres que te avisemos cuando esté publicado):
¿Eres humano? ¿Cuánto es 2 más 3?
Lenguaje
Fuente:

// Solución al reto 003: LEDs de un reloj
// Autor: Caranim
// Mayo 2012
// Nota del recopilador:
// La lógica es buena, pero no es una solución totalmente válida,
// Por mostrar información adicional en pantalla
// Y emplear colores y Readkey
using System;
namespace Leds_encendidos
{
    class Program
    {
 
        public static int Segmentos_Encendidos(string hora)
            // Calcular los segmentos encendidos para la hora pasada como string.
            // Devolvemos un entero.
        {
            int encendidos = 0;
            for (int f = 0; f < 6; f++)
            {                
                encendidos += segmentos[(int)char.GetNumericValue(hora[f])];
            }
            return encendidos;
        }
 
        public static string Convertir_cadena(int numero)
            // Recibe un entero y devuelve un string de longitud dos rellenando a ceros por la izquierda.
        {
            string retorno;
            retorno = Convert.ToString(numero);
            if (retorno.Length == 1)
            {
                retorno = "0" + retorno;
            }
            return retorno;
        }
 
        // Definimos una tabla con los leds encendidos para cada cifra.
        public static int[] segmentos = new int[] { 6, 2, 5, 5, 4, 5, 6, 3, 7, 6 };
 
        static void Main(string[] args)
        {            
            int hora = 0, minutos = 0, segundos = 0;
            int segundos_transcurridos;
            int leds_encendidos = 0;
            string hora_actual;
 
            Console.BackgroundColor = ConsoleColor.Gray;
            Console.ForegroundColor = ConsoleColor.White;
            Console.Clear();
            Console.WriteLine("Número de segundos transcurridos.");
            segundos_transcurridos = Convert.ToInt32(Console.ReadLine());// Conversión directa para simplificar.
 
            while (segundos_transcurridos > -1)
            {
                hora_actual = Convertir_cadena(hora) + Convertir_cadena(minutos) + Convertir_cadena(segundos);
                leds_encendidos += Segmentos_Encendidos(hora_actual);
                segundos++;
                if (segundos == 60)
                {
                    segundos = 0;
                    minutos++;
                    if (minutos == 60)
                    {
                        minutos = 0;
                        hora++;
                        if (hora > 23)
                        {
                            hora = 0;
                        }
                    }
                }
                segundos_transcurridos--;
            }
 
            Console.CursorTop = Console.CursorTop + 2;
            Console.WriteLine("Leds Encencidos: {0}.", leds_encendidos);
            Console.ReadLine();
        }
    }
}
 

import java.util.Scanner;
 
/**
 * Programa que da solución al problema del reloj mostrado en la web de Nacho
 * Cabanes Nota: No contempla que la cantidad de segundos supere a un día (es
 * decir 24 horas). Después de todo, quién podrá dormir más de 24 horas?? xD
 *
 * @author Rafael Perez Torres
 * about.me/s0lver
 * Marzo 2013
 */
public class ElReloj {
 
    public static void main(String[] args) {
        Scanner console = new Scanner(System.in);
        String linea = console.nextLine();
        while (linea.length() > 0) {
            resolver(linea);
            linea = console.nextLine();
        }
    }
 
    public static void resolver(String linea) {
        int segundos = Integer.valueOf(linea);
        int contadorLeds = 0;
        String horaActual;
        while (segundos >= 0) {
            horaActual = convertirAHora(segundos);
            contadorLeds += contarLeds(horaActual);
            // Esta linea pude mostrar la cantidad de leds necesaria para mostrar la hora actual
            // System.out.println(horaActual + " = " + contarLeds(horaActual));
            segundos--;
        }
        System.out.println(contadorLeds);
    }
 
    /**
     * *
     * Dado un string de hora (sin los : intermedios) retorna la cantidad de
     * leds necesaria para mostrarla en un reloj
     *
     * @param hora Un string de hora
     * @return La cantidad de leds necesaria para mostrar la hora
     */
    public static int contarLeds(String hora) {
        int resultado = 0;
        for (int i = 0; i < hora.length(); i++) {
            switch (hora.charAt(i)) {
                case '1':
                    resultado += 2;
                    break;
                case '2':
                case '3':
                case '5':
                    resultado += 5;
                    break;
                case '4':
                    resultado += 4;
                    break;
                case '6':
                case '9':
                case '0':
                    resultado += 6;
                    break;
                case '7':
                    resultado += 3;
                    break;
                case '8':
                    resultado += 7;
            }
        }
        return resultado;
    }
 
    /**
     * *
     * Devuelve la representacion XX:XX:XX de la hora después de haber
     * transcurrido los segundos especificados. Tal vez un pequeño hack podría
     * utilizar las librerias propias de la API de Java y sustituir este método
     *
     * @param segundos
     * @return Un String que representa la hora en formato XX:XX:XX (sin los
     * ':') después de haber transcurrido los segundos especificados
     */
    public static String convertirAHora(int segundos) {
        int horas = segundos / 3600;
        int resto = segundos % 3600;
        int minutos = resto / 60;
        resto = resto % 60;
        return rellenar(horas) + rellenar(minutos) + rellenar(resto);
    }
 
    public static String rellenar(int dato) {
        String tmp = String.valueOf(dato);
        if (tmp.length() < 2) {
            return "0" + tmp;
        } else {
            return tmp;
        }
    }
}