ejercicio 0. - hp scds · entrada no se requiere salida welcome to codewars! ejercicio 1....

Ejercicio 0. Bienvenidos a CodeWars! – 1 Punto Enunciado ¡Bienvenidos a CodeWars! Vamos a empezar la competición con un regalo. Debéis desarrollar un programa que muestre por pantalla el siguiente mensaje de bienvenida: Welcome to CodeWars!

Test cases Entrada No se requiere Salida Welcome to CodeWars!

Ejercicio 1. ¡Bienvenidos a CodeWars! (Modo experto) – 2 Puntos

Enunciado Coged vuestras toallas y secad el sudor de vuestras frentes después del ejercicio anterior. Este es el primer problema serio…Debéis desarrollar un programa que muestre por pantalla un mensaje de bienvenida personalizado para vuestro equipo.

Test cases Entrada WarriorsTeam Salida Welcome to CodeWars WarriorsTeam

Ejercicio 2. ¡A descomprimir! – 4 Puntos Enunciado Una vez se parsean los trabajos de impresión, se obtienen unos documentos que son mapas de bits que pueden tener un tamaño gigantesco. Supongamos un documento en blanco y negro impreso en una página A4 (8,3 pulgadas x 12 pulgadas) a una resolución de 1200 puntos por pulgada. Estaríamos hablando de 143 millones de puntos de impresión (0s y 1s, al ser en blanco y negro). Para ahorrar espacio y tiempo de procesamiento, estos mapas de bits suelen enviarse comprimidos con un algoritmo lossless (sin pérdida). Este tipo de algoritmos cuentan el número de bits iguales consecutivos y en vez de escribirlos todos indica el número de bits consecutivos y su valor (siempre que el número de bits iguales consecutivos sea menor que 9). Así, por ejemplo: - Si llegan 4 bits a cero (0000), la salida es 40 - Si llegan 13 bits a uno (1111111111111), la salida es 9141 (es decir 9 bits a 1 y 4 bits a 1) - Si en cambio solo hay una repetición del bit a 0 o a 1, se deja tal cual. Si llega 101, se deja como 101 Un ejemplo completo. Con la siguiente entrada: 10000111011100000101010010110001000101111010111110101110000010000000000000010000000 Al comprimirse quedaría así: 14031031501010120102130130104101051010315019050170 Se pide escribir un programa que reciba una cadena con formato comprimido lossless, y transformarla en una cadena de bits.

Test cases Entrada 14031031501010120102130130104101051010315019050170 Salida 10000111011100000101010010110001000101111010111110101110000010000000000000010000000

Solución (C++) #include <stdio.h>

#include <iostream>

#include <string>

#include <cstdlib>

int main()

{

std::string cadena;

std::getline(std::cin, cadena);

//201010101091915190908021

char letra=cadena[0];

char letra2;

for (int i=1; i<cadena.length(); i++)

{

if (letra=='0' || letra=='1')

{

std::cout << letra;

}

else

{

letra2=cadena[i];

int val = letra - '0';

for (int j=0; j<val; j++)

{

std::cout << letra2;

}

i++;

}

if (i<cadena.length())

letra=cadena[i];

}

}

Ejercicio 3. Simulando un ojo – 4 Puntos Introducción Como sabéis el ojo humano tiene dos tipos de células, los bastones y los conos. Los primeros permiten detectar la luz, mientras que los segundos son receptores de color. El ojo humano tiene tres tipos de receptores de color. Uno de ellos es más sensible al color azul, otro es más sensible al color verde y el tercero es más sensible al color rojo. Como curiosidad, el 62% de los conos del ojo humano detectan colores rojizos, el 36% detecta colores verdosos y solo el 2% detecta colores azulados. Su grado de sensibilidad no es continuo. Más bien, es como se muestra en la siguiente imagen:

Como se puede comprobar, los conos “azules” detectan principalmente el color azul pero también podrían llegar a detectar colores verdosos. Caso similar ocurre en el resto de tipo de conos. Sin embargo, estos niveles de detección de color son ligeramente diferentes en los conos de cada persona, siendo este el motivo por el cual cada ojo humano puede ver colores que otros no ven. Pero y ¿Qué son los colores? Su definición indica que es una “Impresión que producen en la retina los rayos de luz, según la longitud de onda de estos rayos”. Según la anterior imagen, el color azul se encuentra aproximadamente en una longitud de onda de 460 nm, el verde en 535 nm y el rojo en 575 nm.

Enunciado Se pide realizar un programa que lea un valor numérico por teclado de la longitud de onda recibida por un ojo humano y en función de la siguiente tabla indique el color que se está apreciando. Por ejemplo, para la entrada 420, la salida deberá mostrar el mensaje: Morado.

Longitud de Onda Color

< 400 Ultravioleta

400-440 Morado

441-460 Violeta

461-510 Azul

511-555 Verde

556-575 Amarillo

576-615 Naranja

616-700 Rojo

>700 Infrarrojo

Test cases Entrada 123 Salida Ultravioleta Entrada 555 Salida Verde


int main() {

int longitude;

scanf("%d", &longitud);

if (longitud < 400){

printf("Ultravioleta");

} else if (longitud <= 440){

printf("Morado");


printf("Violeta");


printf("Azul");


printf("Verde");


printf("Amarillo");


printf("Naranja");


printf("Rojo");

} else {

printf("Infrarrojo");

}

return 0;

}

Ejercicio 4. Homenaje a Kobe Bryant – 5 Puntos Introducción Como seguro que todos sabréis, Kobe Bryant fue un jugador de Los Ángeles Lakers que falleció en un accidente de helicóptero el pasado 26 de Enero de 2020. Para ensalzar su trayectoria profesional, vamos a crear un programa orientado a sus grandes partidos como profesional y leyenda del baloncesto en el que tendremos que calcular sus puntos totales en un partido y la manera en la que encestó (triples "3 puntos", tiros de campo "2 puntos" y tiro libre "1 punto").

Enunciado Se pide crear un programa que solicite:

- Ingresar una serie de números (3, 2 o 1) que estén separados por espacios y en la misma línea. - Si el usuario ingresa un número que no sea 3, 2 o 1, el programa deberá mostrar un mensaje de

error. - El programa deberá mostrar los puntos totales obtenidos en el partido y el número de canastas

encestadas con tiros de 3, de 2 y de 1.

Test cases Entrada 3 2 3 1 2 1 1 3 2 3 3 3 3 2 1 1 2 1 3 Salida Kobe Bryant ha encestado un total de 40 puntos. Triples: 8 Tiros de campo con valor 2: 5 Tiros libres: 6 Entrada 3 2 4 1 Salida No existen puntos con este valor.

Solución (C++) #include <iostream>

#include <vector>

#include <algorithm>

using namespace std;

//variables

string numbers;// 3 3 2 1 2 1

vector<int> listOfPoints; // 332121

int totalPoints = 0;

int threePoints = 0;

int twoPoints = 0;

int onePoints = 0;

bool incorrectNumbers = false;

//methods

vector<int> addNumbersToVector(string num);

int main()

{

cout << "Ingresa una secuencia de numeros: ";

getline(cin,numbers);

//Insert numbers in the vector

listOfPoints = addNumbersToVector(numbers);

// Types of points

for (int i = 0; i < listOfPoints.size(); ++i)

{

if(listOfPoints[i] == 3)

{

threePoints++;

}

else if(listOfPoints[i] == 2)

{

twoPoints++;

}

else if(listOfPoints[i] == 1)

{

onePoints++;

}

else

{

incorrectNumbers = true;

cout << "No existen puntos con este valor." << endl;

break;

}

}

// To show if the numbers are correct

if(!incorrectNumbers)

{

totalPoints = (3*threePoints)+(2*twoPoints)+(onePoints);

cout << "Koby Bryant ha encestado un total de "<< totalPoints

<< " puntos." << endl;

cout << "Numero de triples: " << threePoints << endl;

cout << "Numero de tiros de campo con valor 2: " << twoPoints

<< endl;

cout << "Numero de tiros libres: " << onePoints << endl;

}

cout << endl;

return 0;

}

vector<int> addNumbersToVector(string num)

{

for (int i = 0; i < num.length(); i++)

{

if(num[i] != ' ')

{

int n = num[i] - '0'; //To convert number to int

listOfPoints.push_back(n); //To add number in the vector

}

}

return listOfPoints;

}

Ejercicio 5. HEX to RGB – 5 Puntos Introducción El sistema hexadecimal es un método de numeración posicional que utiliza como base el número 16 (Base-16), es decir, existen 16 símbolos de dígitos posible. Sus números están representados por los 10 primeros dígitos de la numeración decimal y el intervalo del número 10 al número 15 se representa por las letras del alfabeto: A, B, C, D, E y F. Este sistema, introducido en el año 1963 por la empresa IBM, es empleado comúnmente en sistemas computacionales con el fin de reducir grandes cadenas de números binarios en conjuntos de varios dígitos, que se pueden de esta forma comprender fácilmente. Este sistema utiliza la combinación de tres códigos de dos dígitos para expresar las diferentes intensidades de los colores primarios RGB, donde la correspondencia entre la numeración hexadecimal y la decimal u ordinaria viene dada por la siguiente fórmula:

𝐷𝑒𝑐𝑖𝑚𝑎𝑙 = (𝑃𝑟𝑖𝑚𝑒𝑟𝑎 𝐶𝑖𝑓𝑟𝑎 𝐻𝑒𝑥𝑎𝑑𝑒𝑐𝑖𝑚𝑎𝑙 𝑥 16) + 𝑆𝑒𝑔𝑢𝑛𝑑𝑎 𝐶𝑖𝑓𝑟𝑎 𝐻𝑒𝑥𝑎𝑑𝑒𝑐𝑖𝑚𝑎𝑙 De esta forma, cualquier color queda definido por tres pares de dígitos y por tanto la intensidad máxima

es ff, que se corresponde con (15 × 16) + 15 = 255 en decimal, y la nula es 00, también 0 en decimal.

Enunciado Conociendo la información anterior, se pide desarrollar un programa que reciba el color en formato Hex y muestre su equivalente en formato RGB. Además, se pide validar si cada valor de la entrada es válido (dígito 0-10 o letra A-F), indicando en caso contrario el carácter inválido y su posición. Nota: Las palabras de la salida aparecerán sin tildes.

Test cases Entrada #ff1256 Salida (255, 18, 85) Entrada #3412g4 Salida Caracter invalido: g. Posicion: 5

Solución (Python) #!/usr/bin/python

# -*- coding: utf-8 -*-

#

======================================================================

==========================#

#

#

# __ __ _______ ______ _______

______ ______ #

# | | | | | __ | | ___| | _____|

| __ \ | ___| #

# | |__| | | |__| | | |___ | |

| | \ | | |___ #

# | __ | | ____| |____ | | |

| | | | |____ | #

# | | | | | | ____| | | |____

| |__/ | ____| | #

# |__| |__| |__| |______| |_______|

|______/ |______| #

#

#

#

#

# FILE: hexToRGB.py

#

#

#

# USAGE: python hexToRGB.py < input.txt

#

#

#

# DESCRIPTION: ---

#

#

#

# REQUIREMENTS: ---

#

# AUTHOR: Jesús Iglesias García <[email protected]>

#

# ORGANIZATION: HP SCDS

#

# EVENT: CODE WARS 2020

#

#

======================================================================

=========================#

########################################

# IMPORTS #

########################################

try:

import sys # System-specific

parameters and functions

import fileinput # Iterate over lines

from multiple input streams

import string # Common string

operations

except ImportError as importError:

print("Error to import: " + importError.message.lower() + ".")

sys.exit(1)

########################################

# FUNCTIONS #

########################################

def checkHex(inputHex):

"""Checks if the input is in Hex format.

@param inputHex Value in Hexadecimal

@return True, if the input is valid. False, otherwise"""

flag = True

hexValues = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a",

"b", "c", "d", "e", "f"]

for i, value in enumerate(inputHex, start=1):

if not value in hexValues:

print("Caracter invalido: {0}. Posicion: {1}".format(value,

i))

flag = False

break

return flag

def hexToRGB(inputHex):

"""Converts the value Hex to RGB and print it.

@param inputHex Value in Hexadecimal"""

print(tuple(int(inputHex[i:i + 2], 16) for i in (0, 2, 4)))

def main():

"""Main function"""

# Reads each line of the input file

for line in fileinput.input():

# Reads each line

line = line.rstrip("\n")

value = line.lstrip('#')

# Checks the format

validInput = checkHex(value)

# Hex to RGB conversion

if (validInput):

hexToRGB(value)

########################################

# MAIN PROGRAM #

########################################

if __name__ == "__main__":

main() # Main function

Ejercicio 6. La máquina de Vending – 5 Puntos Introducción Los altos directivos de HP han tenido una idea para aumentar las ventas: Crear una máquina de vending donde, en vez de pastelitos, se puedan obtener, las 24h del día, productos de HP. Pero aún no están muy convencidos, así que han pedido tener una demo del funcionamiento de la máquina. Como suele ser habitual estas solicitudes van pasando de mano en mano hasta llegar al programador más novato de la compañía. ¿Podríais ayudarle a realizar este programa para los jefes?

Enunciado Se pide realizar un programa que lea por teclado el dinero que introducimos en la máquina de Vending y, a continuación, el código del producto escogido. En función de la siguiente tabla y de si tenemos dinero suficiente, el programa deberá:

a) Devolver el nombre del producto e imprima el dinero restante que se devuelve b) Indique que no tenemos dinero suficiente (“Dinero insuficiente”) c) No haga nada cuando hayamos introducido un código incorrecto

Código Producto Precio (€)

A1 HP Notebook 255 G7 239.35

A2 HP Pavilion 15 899.00

B1 HP Deskjet 3720 72.15

B2 HP Smart Tank Plus 555 247.00

B3 Cartucho Tinta HP 344 57.45

C1 HP 913A Cartucho Pagewide 73.30

C2 HP 85A Toner Negro 123.50

Test cases Entrada 1000 A1 Salida HP Notebook 255 G7 760.65 Entrada 99 B2 Salida Dinero insuficiente Entrada 99 F2 F3

G2 Hola Respondeme! B3 Salida Cartucho Tinta HP 344 41.55

Solución (C++)

#include <iostream>

#include <map>

#include <utility>

int main()

{

float dinero;

std::map<std::string, std::pair<std::string,float>> map =

{

{ "A1", std::make_pair("HP Notebook 255 G7", 239.35)},

{ "A2", std::make_pair("HP Pavilion 15", 899.00)},

{ "B1", std::make_pair("HP Deskjet 3720", 72.15)},

{ "B2", std::make_pair("HP Smart Tank Plus 555", 247.00)},

{ "B3", std::make_pair("Cartucho Tinta HP 344", 57.45)},

{ "C1", std::make_pair("HP 913A Cartucho Pagewide", 73.30)},

{ "C2", std::make_pair("HP 85A Toner Negro", 123.50)},

};

std::map<std::string, std::pair<std::string,float>>::iterator it;

std::pair<std::string,float> found;

bool invalido=true;

std::string codigo;

std::cin >> dinero;

std::pair<std::string,float> data;

while (invalido)

{

std::cin >> codigo;

it = map.find(codigo);

if (it != map.end())

{

invalido=false;

}

}

data = it->second;

std::string def= data.first;

float value= data.second;

if (dinero<value)

{

std::cout << "Dinero insuficiente";

}

else

{

std::cout << def << std::endl;

std::cout << dinero - value << std::endl;

}

}

Ejercicio 7. PostScript Parser – 6 Puntos Introducción Una impresora realmente es un dispositivo electrónico bastante tonto puesto que en un principio únicamente quiere conocer dónde debe esparcir las gotas de tinta. Sin embargo, con el tiempo y la evolución tecnológica se ha conseguido que sea capaz de entender no solo mapas de puntos, sino también discernir cierta información de la imagen y crear por si misma este mapa de puntos. Por este motivo, a la hora de mandar un documento a la impresora, se puede hacer de dos formas. O bien el ordenador extrae y gestiona el mapa de puntos y se lo manda directamente a la impresora en formato ráster para que ésta solamente localice el sitio donde debe soltar cada microgota, o bien se envía a la impresora un fichero que indica donde se deben localizar determinados objetos en la hoja y es la placa formatter de la propia impresora quien genera el mapa de puntos que se imprimirá. Tal vez os suenen los nombres de PDF o PostScript. Estos son solo dos de los formatos de fichero que entienden los formatters de las impresoras. El siguiente es un ejemplo de este tipo de ficheros:

En este ejemplo, se está indicando el tipo de letra que se usará (Courier 20), la posición del cursor (72, 72) y el mensaje a imprimir: Hola mundo.

Enunciado Se pide un programa que lea un fichero PostScript introducido por teclado y escriba por pantalla lo que se pida imprimir. Para no complicar mucho el ejercicio, este fichero solo admitirá dos líneas con el siguiente formato (y en este orden):

X Y moveto (ABCD) show

Es decir, colocarse en una determinada posición de la pantalla y escribir lo que se indique. Para saber dónde empieza la hoja de impresión, se escribirán 5 guiones justo antes de la primera línea de la primera página y otros 5 al acabar la impresión. Por ejemplo, con el siguiente fichero PostScript:

7 3 moveto (Adiooos) show

Se espera la siguiente salida en la cual a modo de ejemplo se muestran números en vertical y horizontal para pintar las filas y columnas, respectivamente pero que se deben omitir en la salida del programa ya que son meramente informativas para entender lo que se pide. En este ejemplo, la palabra Adioos se encuentra en la fila 3 y la letra A comienza en la columna 7.

----- 1 2 3 4 5 6 7 8 9 10 11 12 13 14 (columnas) 1 2 3 Adiooos 4 5 6 (filas) ----- Nota: No es necesario realizar control de errores en cuanto al formato de entrada. El programa siempre recibirá dos líneas. En la primera habrá siempre dos números enteros seguidos de la palabra moveto. En la segunda, dentro de los paréntesis se encontrará el texto que queramos escribir y que será de no más de 80 caracteres, seguido de la palabra show.

Test cases Entrada 7 3 moveto (Adiooos) show Salida Adiooos Entrada 1 1 moveto (Primera linea) show Salida Primera linea


#include <iostream>

#include <string>

#include <cstdlib>

int main()

{

int x;

int y;

std::string line1;

std::string line2;

std::getline (std::cin, line1);

std::getline (std::cin, line2);

std::string::size_type rest;

x=std::stoi(line1, &rest);

y=std::stoi(line1.substr(rest));

std::size_t pos = line2.find("(");

std::string str3 = line2.substr (pos); //string starting with

word we want to print

std::size_t pos2 = str3.find(")");

std::string str2 = str3.substr (1,pos2-1);

for (int i=0; i<y-1; i++)

std::cout << std::endl;

for (int j=0; j<x; j++)

std::cout << " ";

std::cout << str2;

}

Ejercicio 8. ¡¡¡¡Volteador!!!! – 6 Puntos Introducción En ocasiones, el cabezal de impresión se encuentra en la parte inferior y es necesario darle la vuelta a una imagen (de izquierda a derecha) para imprimirla. De igual manera en ocasiones se pide imprimir un documento (o imagen) comenzando por el final.

Enunciado Se pide escribir un programa que llamaremos “volteador” que reciba dos valores. Por una parte, el sentido en que se quiera voltear una imagen y, por otra parte, la imagen. En este caso lo haremos con caracteres para simular una imagen. Una imagen (una serie de caracteres, en este caso) se puede voltear horizontal (H) o verticalmente(V). Como primer valor, el programa recibirá una H o una V (y en caso contrario volverá a pedir ese primer parámetro hasta que metamos una H o un V). El segundo valor será el número de líneas de la imagen (Hasta un máximo de 64, y un mínimo de 1). El tercer valor será el ancho de la imagen. Por último, se introducirá la imagen línea a línea hasta el número de líneas que le hayamos indicado en el parámetro 2. Si alguna línea es más larga que el ancho de línea indicado en el parámetro, se descartarán los caracteres sobrantes (los últimos). El programa deberá imprimir la imagen volteada horizontal o verticalmente tal y como se le haya pedido.

Test cases Entrada H 3 3 1234 12 234 Salida 321 21 432 Entrada V 3 3 12345 12 566 Salida 566 21

123


#include <iostream>

#include <sstream>

#include <vector>

#include <iomanip>

#include <string>

#include <stdlib.h>

#include <cmath>

int main()

{

char tipo='A';

int lineas;

int ancho;

std::vector<std::string> array;

std::string linea;

while (tipo!='H' && tipo!='V')

{

std::cin >> tipo;

}

std::cin >> lineas;

std::cin >> ancho;

for (int i=0; i<lineas; i++)

{

std::cin >> linea;

//rellenamos con blancos para que tenga el ancho adecuado

if (linea.length() < ancho){

for (int j=linea.length(); j<ancho; j++)

{

linea.append(" ");

}

}

array.push_back(linea);

}

if (tipo=='H')

{

for (int j=0; j<lineas; j++)

{

linea=array.at(j);

for (int i=ancho-1; i>=0;i--)

{

std::cout << linea[i];

}


}

}

if (tipo=='V')

{

for (int j=lineas-1; j>=0; j--)

{

linea=array.at(j);

for (int k=0; k<ancho; k++)

{

std::cout << linea[k] ;

}


}

}

return 0;

}

Ejercicio 9. ROT13 – 6 Puntos Enunciado Este algoritmo permite realizar una encriptación sencilla de frases, usando caracteres en el alfabeto inglés

(26 caracteres : abcdefghijklmnopqrstuvwxyz). Es un caso especial del cifrado cesar, que realiza una transformación de una letra “desplazando” N posiciones su posición. En el caso del ROT13, es un caso especial, ya que es su propio inverso, al tratarse de un desplazamiento de 13 caracteres (la mitad). La idea es asignar a cada carácter, 13 posiciones de desplazamiento. Si asignamos el valor de 0 a la “a”, entonces pasaría a ser el 13. En el ejemplo se pueden comprobar los elementos. Por ejemplo:

El ejercicio consiste en implementar este algoritmo. NOTA: para facilitar el algoritmo, al input se ha de considerar siempre en minúsculas.

Test cases Entrada hola Salida ubyn

Solución (Python)

#!/usr/bin/env python

# -*- coding: utf-8 -*-

def rt13(x):

'''

Pythonic implementation

'''

abc = "abcdefghijklmnopqrstuvwxyz"

return "".join([abc[(abc.find(c) + 13) % 26] for c in x])

def rot13(s):

'''

Algoritmic implementation

'''

result = ""

# Loop over characters.

for v in s:

# Convert to number with ord.

c = ord(v)

# Shift number back or forward.

if c >= ord('a') and c <= ord('z'):

if c > ord('m'):

c -= 13

else:

c += 13

# Append to result.

result += chr(c)

# Return transformation.

return result

phrase = input()

print(rt13(phrase.lower()))

#print(rot13(phrase))

Ejercicio 10. In outer space – 6 Puntos Introducción HP también está en el espacio. En 2016, la NASA comenzó a enviar servidores HP ZBook a la Estación Espacial Internacional (ISS). En total 120 servidores ZBook fueron instalados (incluyendo los de recambio) para ayudar a realizar las misiones de la estación. En 2017, la NASA seleccionó a la impresora HP OfficeJet 5740 Printer como su “Next Generation Printer” para reemplazar las opciones de impresión existentes en ese momento en la ISS. Como respuesta a la solicitud de la NASA, HP desarrolló una impresora especial, la HP ENVY Zero-Gravity Printer con capacidad de imprimir en gravedad cero. Sin embargo, la colaboración con la NASA no es solo reciente. HP ya colaboró en las misiones Apollo en los años 60. Para homenajear estos hechos, vamos a simular el alunizaje del Apollo 11.

Enunciado Se pide escribir un programa que controle un robot de exploración lunar. El programa recibirá como entrada una serie de comandos en el siguiente formato: TL TL MF MF MF TR MF Los posibles comandos son los siguientes:

• MF (Move Forward). Mueve el robot hacia adelante.

• MB (Move Backwards). Mueve el robot hacia atrás.

• TR (Turn Right). Gira el robot hacia la derecha (sin avanzar ni retroceder).

• TL (Turn Left). Gira el robot hacia la izquierda (sin avanzar ni retroceder).

Ejemplo:

MF MF TR MF MF MF TL MB MB

Dando por hecho de que el cohete parte de la posición 0,0, y dada una secuencia de comandos de entrada (separados entre sí por espacios en blanco) el programa debe calcular el punto final en el que quedará el robot. La salida deberá estar en el formato siguiente: X: 3, Y: -5

Nótense los espacios, las comas y los símbolos de dos puntos, porque son importantes.

Test cases Entrada MF MF TR MF MF TR MF MF MF Salida X: 2, Y: -1


#include <string>

#include <vector>


int main()

{

std::vector<std::string> a;

std::string b;

std::string line;

std::getline(std::cin, line);

char delim=' ';

std::size_t current, previous = 0;

current = line.find(delim);

while (current != std::string::npos) {

a.push_back(line.substr(previous, current - previous));

previous = current + 1;

current = line.find(delim, previous);

}

a.push_back(line.substr(previous, current - previous));

int posx=0;

int posy=0;

int direccion=0;

for (int i=0; i<a.size(); i++)

{

if (a.at(i)=="MF")

{

switch(direccion)

{

case 0:

posy++;

break;

case 1:

posx++;

break;

case 2: //abajo

posy--;

break;

case 3: //izq

posx--;

break;

}

}

if (a.at(i)=="MB")

{

switch(direccion)

{

case 0:

posy--;

break;

case 1:

posx--;

break;

case 2: //abajo

posy++;

break;

case 3: //izq

posx++;

break;

}

}

if (a.at(i)=="TR")

{

direccion=(direccion+1)%4;

}

if (a.at(i)=="TL")

{

direccion=(direccion-1);

if(direccion==-1) direccion=3;

}

}

std::cout << "X: " << posx << ", Y: " << posy;

return 0;

}

Ejercicio 11. Viernes, noche de juegos – 6 Puntos Enunciado ¡Por fin es viernes! Todas las semanas quedas con tus amigos para jugar unas partidas a juegos de mesa. Es el día de la semana más esperado por ti y tu grupo de juegos, pero siempre os pasa lo mismo y hasta última hora no sabéis cuantas personas seréis para la partida, lo cual es un inconveniente ya que el juego o juegos a los que jugareis depende un poco del número de jugadores y siempre se pierde mucho tiempo revisando el número de jugadores que acepta cada juego. Como la vida es muy corta como para perder tiempo con pequeñas cosas has decidido que lo mejor es crearte una aplicación que te liste los juegos a los que podéis jugar en función del número de jugadores. Como dispones una lista con los juegos de mesa que tenéis y el rango de jugadores que acepta cada juego, la mitad del trabajo está hecho. La aplicación pedirá la lista de juegos y el número de jugadores y devolverá el nombre de los juegos a los que podrían jugar dichos jugadores. Primero se introducirá el número de juego en el listado: 5 Luego se introducirán los juegos y los jugadores mínimos y máximos. Todo ello en una línea. El nombre del juego y los jugadores se separarán por un símbolo ‘;’. El número de jugadores mínimo y máximo serán dos números enteros separados por un ‘-‘. Algo así:

Y luego en la última línea el número de jugadores que seréis para la partida: 5 El programa imprimirá a que juegos, de los indicados anteriormente, se puede jugar esta noche: CARCASSONE ZOMBICIDE VIRUS En caso de no poder jugar a ninguno simplemente se mostrará el mensaje “Buscate algo que hacer…“

Test cases Entrada 5 CARCASSONE;2-5 ZOMBICIDE;2-6 PANDEMIC;2-4 VIRUS;2-5 AGRICOLA;2-4 5 Salida Se mostrará por pantalla a los juegos que podéis jugar en función del número de jugadores que seáis: CARCASSONE

ZOMBICIDE

VIRUS Entrada 5

CARCASSONE;2-5 ZOMBICIDE;2-6 PANDEMIC;2-4 VIRUS;2-5 AGRICOLA;2-4 0 Salida Entrada 5 CARCASSONE;2-5 ZOMBICIDE;2-6 PANDEMIC;2-4 VIRUS;2-5 AGRICOLA;2-4 6 Salida ZOMBICIDE

Solución (Java) package problems;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.util.Scanner;

public class Juegos {

public static void main(String[] args)

{

System.out.println("Introduce fichero con lista de juegos:");

Scanner readJue = new Scanner(System.in);

String juegos;

juegos = readJue.next();

System.out.println("Introduce numero de jugadores:");

Scanner readJug = new Scanner(System.in);

int jugadores;

jugadores = readJug.nextInt();

buscaJuegos(juegos, jugadores);

readJug.close();

readJue.close();

}

public static void buscaJuegos(String listaJuegos,int jugadores)

{

File archivo = null;

FileReader fr = null;

BufferedReader br = null;

try {

archivo = new File (listaJuegos);

fr = new FileReader (archivo);

br = new BufferedReader(fr);

String linea;

while((linea=br.readLine())!=null)

{

String[] juego = linea.split(";");

String[] rangoJugadores = juego[1].split("-");

if(Integer.parseInt(rangoJugadores[0]) <= jugadores &&

Integer.parseInt(rangoJugadores[1]) >= jugadores)

{

System.out.println(juego[0].toString());

}

}

}

catch(Exception e){

e.printStackTrace();

}finally{

try{

if( null != fr ){

fr.close();

}

}catch (Exception e2){

e2.printStackTrace();

}

}

}

}

Ejercicio 12. Cambiando la cinta – 7 Puntos Enunciado Una printer mueve el papel (a menudo en tamaños A1 y A2) con 4 motores que son los círculos de la siguiente figura:

La cinta que mueve el papel es empujada por los cuatro motores, como se ve en la imagen anterior. Por desgracia, en ocasiones se rompe y es necesaria sustituirla. Se pide realizar un programa que indique la longitud de la cinta a partir de las distancias entre los 4 motores, que en cada printer es diferente. La longitud de la cinta es la suma de los cuatro tramos que unen los cuatro motores. Las posiciones de los cuatro motores se introducirán por teclado basándose en su posición X,Y en un plano, empezando por el motor de la esquina superior izquierda y en sentido horario. Así, por ejemplo, los puntos donde se encuentran los motores de la imagen de arriba son: 1,6 4,5 6,-1 0,0 Para saber la longitud de cada una de las secciones, solo hay que aplicar la siguiente formula:

Así, en el ejemplo anterior, la distancia entre el punto 1, 6 y el punto 4,5 será:

Es decir:

Para facilitar el ejercicio se considerarán motores de radio 0 (Es decir, puntos en el plano). La salida se dará con dos decimales.

Test cases Entrada 1, 6 4, 5 6, -1 0, 0 Salida 21.65


#include <iostream>

#include <string>

#include <cstdlib>

#include <cmath>

#include <math.h>

int main()

{

std::string motor1, motor2, motor3, motor4;

std::getline(std::cin, motor1);




int pos[4][2];

pos[0][0]=std::stoi(motor1.substr(0, motor1.find(",")));

pos[0][1]=std::stoi(motor1.substr(motor1.find(",")+1,

motor1.length()));



motor2.length()));



motor3.length()));



motor4.length()));

double lengths[4];

lengths[0]=sqrt(pow(pos[1][0]-pos[0][0],2) + pow(pos[1][1]-

pos[0][1],2));


pos[1][1],2));


pos[2][1],2));


pos[3][1],2));

printf("%.2f", lengths[0]+lengths[1]+lengths[2]+lengths[3]);

}

Ejercicio 13. Números Silla – 7 Puntos Enunciado El problema planteado se trata en mostrar todos los puntos de silla de una matriz, donde un punto de silla será aquel número que sea el máximo valor de una fila y mínimo valor de una columna. Por ejemplo, dada la matriz:

2 0

4 0

El número “2” es un número de silla porque es el máximo de su fila y a la vez el mínimo de su columna. Se pide, que indicando por consola las filas, columnas y una matriz de números enteros (donde irán ordenados por columnas, es decir, empezando por el número de fila 1 columna 1, seguirá el de la fila 2 columna 1, etc), se pide que se muestren aquellos números de silla existentes. Si no hay, se mostrará un mensaje indicándolo con el siguiente texto: "No hay numeros de silla".

Test cases

Entrada

2 2 3 4 0 1 Salida Números de silla encontrados: 1 en 1,1

Solución (Python) #!/usr/bin/env python

# -*- coding: utf-8 -*-

import sys

filas = int(input())

columnas = int(input())

minimoColumnas = [ sys.maxsize for x in range(columnas) ]

maximoFilas = [ -sys.maxsize for x in range(filas) ]

array = [[int(input()) for x in range(filas)] for y in range(columnas)]

# Find the max per row and min per column

for fila in range(filas):

for columna in range(columnas):

item = array[fila][columna]

if item > maximoFilas[fila]:

maximoFilas[fila] = item

if item < minimoColumnas[columna]:

minimoColumnas[columna] = item

print("Numeros de silla encontrados:")

numeros_silla = set()

for fila in range(filas):

for columna in range(columnas):

item = array[fila][columna]

if (item == maximoFilas[fila]) and (array[fila][columna] ==

minimoColumnas[columna]):

numeros_silla.add("{} en {},{}".format(item, fila,

columna))

if len(numeros_silla) > 0:

[print(x) for x in numeros_silla]

else:

print("No hay numeros de silla")

Ejercicio 14. La fiesta de la democracia – 7 Puntos Enunciado El partido partidario del descanso diario (PPDD) no han obtenido los resultados deseados en las últimas elecciones y no entienden el motivo con el buen “naming” que tienen. De cara a las próximas elecciones han decidido que solamente con el nombre no es suficiente y quieren hacer llegar su imagen al mayor número posible de personas. Para ello han obtenido un censo cedido por la junta electoral que utilizaran para mandar cartas personalizadas a cada una de las personas en edad legal para votar, pero no todo va a ser tan sencillo. El censo tiene los datos necesarios para hacer llegar las cartas a cada persona, pero en un formato que no sería valido para un envío postal y además tendrían que filtrar por edades para mandar las cartas solo a los mayores de edad. Pero son una formación joven y dinámica y han tenido una gran idea, mandaran hacer una aplicación que les convierta cada línea del censo en una etiqueta con el formato correcto para poder mandar sus cartas por correo ordinario y solo para aquellos que sean mayores de edad. El censo tiene este formato en cada línea:

Nombre y apellidos;fecha de nacimiento;dirección;cp;localidad;provincia El carácter separador será el punto y coma (“;”). La aplicación leerá el censo línea a línea y generará, por cada registro de este, una etiqueta con el nombre de la persona SIEMPRE QUE ESA PERSONA SER MAYOR DE EDAD. El contenido de la etiqueta tendrá el siguiente formato:

######################### Nombre y Apellidos (Nacimiento) Dirección CP – Localidad (Provincia) #########################

En caso de detectar una persona menor de edad se mostrará el mensaje: “Esta persona es menor de edad.” (Sin las comillas, claro) Nota: Las líneas separadoras tienen 30 caracteres “#”. Nota 2: Los Campos de entrada podrían tener espacios en blanco antes y después de cada punto y coma. Dichos espacios deberán ser eliminados.

Test Cases Entrada JUAN FERNANDEZ RODRIGUEZ; 12/04/1979; C:\CAMPANILLAS Nº7 – 3ºC; 24008; TROBAJO DEL CAMINO; LEON Salida ##################################### JUAN FERNANDEZ RODRIGUEZ(12/04/1979) C\CAMPANILLAS Nº7–3ºC 24008–TROBAJO DEL CAMINO (LEON) #####################################

Entrada MARTA GOMEZ GONZALEZ; 11/08/2001 ; C\EL CAINEJO Nº20 – BAJO C; 24001 ; LEON; LEON Salida ##################################### MARTA GOMEZ GONZALEZ(11/08/2001) C\EL CAINEJO Nº20–BAJO C 24001–LEON (LEON) ##################################### Entrada JAIME MARTIN GUTIERREZ; 24/05/2013 ; C\PELAEZ Nº20 ; 24001 ; LEON; LEON Salida Esta persona es menor de edad

Solución (Java)

import java.io.*;

import java.util.Calendar;

import java.util.GregorianCalendar;

import java.util.Scanner;

public class Main {

public static void main(String [] arg) {

Scanner read = new Scanner(System.in);

String linea;

linea = read.nextLine();

boolean esAdulto=false;

String[] datos = linea.split(";");

String[] fechaNac = datos[1].trim().split("/");

esAdulto = esMayorDeEdad(fechaNac);

if (esAdulto)

{

generaEtiqueta(datos);

}

else

{

System.out.println("Esta persona es menor de edad");

}

read.close();

}

public static boolean esMayorDeEdad(String[] fNac) {

Calendar fechaNac= new

GregorianCalendar(Integer.parseInt(fNac[2]),

Integer.parseInt(fNac[1]),Integer.parseInt(fNac[0]));

Calendar fechaActual = Calendar.getInstance();

int years = fechaActual.get(Calendar.YEAR) -

fechaNac.get(Calendar.YEAR);

int months = fechaActual.get(Calendar.MONTH) -

fechaNac.get(Calendar.MONTH);

int days = fechaActual.get(Calendar.DAY_OF_MONTH) -

fechaNac.get(Calendar.DAY_OF_MONTH);

if(months < 0 || (months==0 && days < 0))

{

years--;

}

if (years >= 18)

return true;

else

return false;

}

public static void generaEtiqueta(String[] datos)

{

System.out.println("################################");

System.out.println(datos[0].trim()+"("+datos[1].trim()+")");

System.out.println(datos[2].trim());

System.out.println(datos[3].trim() + "-

"+datos[4].trim()+"("+datos[5].trim()+")");

System.out.println("################################");

}

}

Ejercicio 15. C(n) – 8 Puntos

Enunciado El profesor nos ha explicado una ecuación por la cual la propia ecuación está integrada en la parte derecha de la ecuación. La ecuación es la siguiente:

𝐶(𝑛) = √(𝐶(𝑛 − 1) + 1) ∗ 𝑛 Sabiendo que C(0)=12

¿Y esto que quiere decir? Pues que 𝐶(3) = √(𝐶(2) + 3) ∗ 3.

Ya pero, ¿qué es C(2)? Pues muy fácil: 𝐶(2) = √(𝐶(1) + 3) ∗ 2 Pues nos quedamos igual, ¿no? Y ahora que es C(1)?. Os dejo a vosotros que lo calculéis. Se pide realizar un programa que calcule C(n) para cualquier número n positivo. El programa deberá recibir un numero entero positivo no superior a 20 y mostrará el valor de C(n) con tres números decimales. En caso de que el valor de n sea menor que 0 o mayor que 20 se deberá simplemente mostrar el siguiente mensaje: “Numero de entrada invalido”

Test cases Entrada 3 Salida 4.486 Entrada

23

Salida

Numero de entrada invalido


#include <cmath>

#include <math.h>

float calculaC(int n)

{

if (n==0)

{

return 12.0;

}

else

{

return sqrt( (calculaC(n-1)+3)*n);

}

}

int main()

{

int n;

std::cin>>n;

if (n<0 || n>20)

{

std::cout >> “Numero de entrada invalido”

}

double f=calculaC(n);

printf("%.3f", f);

}

Ejercicio 16. ¡No me cabe la tele! – 8 Puntos Introducción Aunque HP no fabrica televisores, en ocasiones el problema que nos encontramos a la hora de saber si una imagen va a caber en el papel es parecido al que nos encontramos con las TV. Cuando se quiere comprar una TV, la información que proporciona el fabricante es:

- Pulgadas de la pantalla (en diagonal). Ojo, en pulgadas. - Aspect ratio (Relación entre el ancho y el alto de la TV) (Ej: 4:3 o 16:9). Los dos números siempre

vienen separados por un simbolos de dos puntos. Por ejemplo, un aspecto ratio de 16:9 significa que 16*Alto=9*Ancho.

- El ancho del borde (lo que en la printer serían los márgenes) en centímetros.

Enunciado Se pide realizar un programa que reciba tres valores (los antes indicados) y nos indique las medidas reales del hueco que necesitamos. La salida se escribirá con el siguiente formato: <CentimetrosDeAncho>x<CentimetrosDeAlto>cm Sin espacios. Nota 1: 1 pulgada = 2.54cm Nota 2: Se redondearán los valores a un solo decimal Nota 3: En caso de que alguno de los valores de entrada sea menor que cero, se escribirá la palabra ERROR y nada más. Nota 4: El primer parámetro será un entero. El segundo, un string. Y el tercero, un flotante.

Test cases Entrada 55 16:9 1.5 Salida 124.8x71.5cm Entrada 55 16:9 -2 Salida ERROR


#include <iostream>

#include <sstream>

#include <vector>

#include <iomanip>

#include <string>

#include <stdlib.h>

#include <cmath>

int main()

{

int pulgadas=0;

std::string aspectRatio;

float bordeEnCm=0;

std::cin >> pulgadas;

std::cin >> aspectRatio;

std::cin >> bordeEnCm;

std::vector<int> array;

std::stringstream ss(aspectRatio);

std::string tmp;

while (std::getline(ss, tmp, ':'))

{

array.push_back(atoi(tmp.c_str()));

}

int x=array.at(0);

int y=array.at(1);

if (pulgadas<=0||x<=0||y<=0)

{

std::cout << "ERROR";

return -1;

}

const float CmsPorPulgada=2.54;

float anguloEnRadianes=atan((float)y/(float)x);

float hipotenusa=CmsPorPulgada*pulgadas;

float altura=sin(anguloEnRadianes)*hipotenusa + bordeEnCm*2;

float anchura=cos(anguloEnRadianes)*hipotenusa + bordeEnCm*2;

printf("%.1fx%.1fcm\n", anchura,altura);

return 0;

}

Ejercicio 17. Matricial printer simulator – 9 Puntos Introducción En 1957 apareció la primera impresora matricial. En este tipo de impresoras no permitía escribir más que textos y cada letra era una matriz de 6x6 puntos y cuando la impresora recibía una letra, ésta solo tenía que convertirlo a una determinada combinación de puntos. La siguiente es una imagen del resultado obtenido por una impresora matricial (¡¡Gracias Wikipedia!!):

La siguiente fue una de las ultimas impresoras matriciales fabricadas por HP:

Enunciado Se pide un programa que simule el funcionamiento de una impresora matricial. Para facilitar el trabajo, nuestra impresora solo escribirá vocales en minúsculas y espacios en blanco. Las matrices de las vocales (de 6x6) serán las siguientes: ______ _XXX__ ____X_ _XXX__ X___X_ _XXX_X ______ _XXXX_ X____X XXXXX_ X_____ _XXXX_ ___X__ ______ __XX__ ___X__

___X__ _XXXXX ______ _XXXX_ X____X X____X X____X _XXXX_ ______ X___X_ X___X_ X___X_ X___X_ _XXX_X Se pide un programa que reciba no más de 8 caracteres de entrada y los imprima como si de una impresora matricial se tratara. Para ello cada espacio de la matriz con un punto se escribirá una “X” en nuestro ejercicio y cada espacio que no tenga un punto se imprimirá como un subrayado. Entre carácter y carácter se emitirá una columna de espacios en blanco. En caso de que alguno de los caracteres sea diferente a una vocal o el número de caracteres sea mayor que 8, se deberá sacar por pantalla el mensaje “ERROR”.

Test cases Entrada aio Salida __________X__________ _XXX___________XXXX__ ____X____XX___X____X_ _XXX______X___X____X_ X___X_____X___X____X_ _XXX_X__XXXXX__XXXX__


#include <iostream>

#include <string>

#include <cstdlib>


int main()

{

char letraA[6][6]={

{'_','_','_','_','_','_'} ,

{'_','x','x','x','_','_'} ,

{'_','_','_','_','x','_'} ,

{'_','x','x','x','_','_'} ,

{'x','_','_','_','x','_'} ,

{'_','x','x','x','_','x'}, };

char letraE[6][6]={

{'_','_','_','_','_','_',} ,

{'_','x','x','x','x','_',} ,

{'x','_','_','_','_','x',} ,

{'x','x','x','x','x','_',} ,

{'x','_','_','_','_','_',} ,

{'_','x','x','x','x','_',} };

char letraI[6][6]={

{'_','_','_','x','_','_',} ,

{'_','_','x','x','_','_',} ,

{'_','_','_','x','_','_',} ,

{'_','_','_','x','_','_',} ,

{'_','_','_','x','_','_',} ,

{'_','x','x','x','x','x',} };

char letraO[6][6]={

{'_','_','_','_','_','_',} ,

{'_','x','x','x','x','_'} ,

{'x','_','_','_','_','x',} ,

{'x','_','_','_','_','x',} ,

{'x','_','_','_','_','x',} ,

{'_','x','x','x','x','_',} };

char letraU[6][6]={

{'_','_','_','_','_','_',} ,

{'x','_','_','_','x','_'} ,

{'x','_','_','_','x','_',} ,

{'x','_','_','_','x','_',} ,

{'x','_','_','_','x','_',} ,

{'_','x','x','x','_','x',} };

std::string cadena;

cin >> cadena;

char letter;

bool error=false;


{

letter=cadena[i];

if (letter!='a' && letter !='e' && letter !='i' && letter !='o'

&& letter !='u')

{

std::cout << "ERROR";

error=true;

break;

}

}

char letraactual[6][6];

if (!error)

{

for (int fila=0; fila<6; fila++)

{


{

letter=cadena[i];

switch (letter)

{

case 'a':

// cout << "es una a";

for (int x=0;x<6;x++) for (int

y=0;y<6;y++) letraactual[x][y]=letraA[x][y];

break;

case 'e':

//cout << "es una e";


y=0;y<6;y++) letraactual[x][y]=letraE[x][y];

break;

case 'i':


y=0;y<6;y++) letraactual[x][y]=letraI[x][y];

break;

case 'o':


y=0;y<6;y++) letraactual[x][y]=letraO[x][y];

break;

case 'u':


y=0;y<6;y++) letraactual[x][y]=letraU[x][y];

break;

}

for (int columna=0; columna<6; columna++)

{

std::cout << letraactual[fila][columna];

}

std::cout << "_";

}


}

}

}

Ejercicio 18. The HP Ring – 10 Puntos Enunciado La liga de baloncesto *THE HP RING* entra en su fase final con los ocho mejores equipos luchando por el anillo que se otorga al equipo número 1 de la liga interna de baloncesto de HP. En esta fase, cuartos de final, se enfrentarán equipos de diferente conferencia (Oeste y Este), existiendo cuatro equipos en cada conferencia. Desde la organización se solicita la colaboración de los equipos participantes en el torneo HP CodeWars para identificar qué equipos pertenecen a cada conferencia y así proceder al sorteo. Conoceréis el método tradicional de un sorteo donde al azar se emparejan los equipos. Sin embargo, en la liga *THE HP RING* se aplica otro método: emparejar aquellos equipos de diferente conferencia que comiencen con la misma letra. Por tanto, el primer paso necesario es identificar qué equipos pertenecen a cada conferencia y en base a ello emparejar aquellos equipos que comiencen con la misma letra y sean de diferente conferencia. Sin embargo, todavía falta un único paso: asociar una fecha para cada encuentro. La fase de cuartos de final se jugará durante cuatro días: Lunes, Martes, Jueves y Viernes (Ojo: Los Miércoles no se juega). Un encuentro cada día donde el emparejamiento de cada encuentro con su día se hará en función de la posición en el alfabeto de la primera letra de los equipos de un encuentro (¡recordad!: ambos equipos de un encuentro comienzan con la misma letra). De tal forma que el encuentro que se jugará el lunes será el de aquellos equipos cuya primera letra del nombre sea la más cercana al principio del alfabeto. Los que posean la primera letra en segunda posición jugarán el martes y así sucesivamente para la tercera y cuarta posición los cuales jugarán el jueves y viernes respectivamente. Nota: Nunca habrá más de cuatro emparejamientos por semana. Si hubiera equipos que no encajan con otros equipos que empiezan por la misma letra simplemente no jugarán esa semana. Debéis desarrollar un programa que reciba la lista de los ocho equipos participantes junto con su conferencia y sea capaz de formalizar el sorteo de cuartos de final. La entrada de datos estará compuesta por:

• Nombre del equipo.

• Conferencia a la que pertenece.

Ejemplo: _Equipo1-Conf1 Equipo2-Conf2 Equipo3-Conf1..._

La salida estará formada por tres líneas con el siguiente mensaje:

• Conferencia Oeste: _[lista de equipos que pertenecen a la conferencia Oeste, separados por comas y un espacio]_

• Conferencia Este: _[lista de equipos que pertenecen a la conferencia Este, separados por comas y un espacio]_

• Emparejamientos: _[lista ordenada -alfabéticamente- de emparejamientos (día de partido) separados por comas y un espacio]_

El último equipo y emparejamiento mostrado no deberá incluir al final el carácter ",".

Test Cases Entrada Raptors-Este Nuggets-Oeste Wizards-Este Warriors-Oeste Clippers-Oeste Nets-Este Rockets-Oeste Celtics-Este

Salida Conferencia Oeste: Nuggets, Warriors, Clippers, Rockets Conferencia Este: Raptors, Wizards, Nets, Celtics Emparejamientos con fecha: Clippers – Celtics (Lunes), Nuggets - Nets (Martes), Rockets - Raptors (Jueves), Warriors - Wizards (Viernes) Entrada GUnix-Oeste HackersLove-Oeste GigabyteTM-Este Anonymous-Oeste HPDevelopers-Este ErrorsTeam-Este Espartian-Oeste AngelsLakers-Este Salida Conferencia Oeste: GUnix, HackersLove, Anonymous, Espartian Conferencia Este: GigabyteTM, HPDevelopers, ErrorsTeam, AngelsLakers Emparejamientos con fecha: Anonymous - AngelsLakers (Lunes), Espartian - ErrorsTeam (Martes), GUnix - GigabyteTM (Jueves), HackersLove - HPDevelopers (Viernes)

Solución (Python)

#!/usr/bin/python

# -*- coding: utf-8 -*-

#

=====================================================================#

#

#

# __ __ _______ ______ _______

______ ______ #

# | | | | | __ | | ___| | _____|

| __ \ | ___| #

# | |__| | | |__| | | |___ | |

| | \ | | |___ #

# | __ | | ____| |____ | | |

| | | | |____ | #

# | | | | | | ____| | | |____

| |__/ | ____| | #

# |__| |__| |__| |______| |_______|

|______/ |______| #

#

#

#

#

# FILE: the_hp_ring.py

#

#

#

# USAGE: python the_hp_ring.py < input.txt

#

#

#

# DESCRIPTION: ---

#

#

#

# REQUIREMENTS: ---

#

# AUTHOR: Jesús Iglesias García <[email protected]>

#

# ORGANIZATION: HP SCDS

#

# EVENT: CODE WARS 2020 - León

#

#

======================================================================

==========================#

########################################

# IMPORTS #

########################################

try:

import sys # System-specific

parameters and functions

import fileinput # Iterate over lines

from multiple input streams

import string # Common string

operations

except ImportError as importError:

print("Error to import: " + importError.message.lower() + ".")

sys.exit(1)

########################################

# CONSTANTS #

########################################

WEST = "Oeste"

EAST = "Este"

########################################

# GLOBAL VARIABLES #

########################################

west_teams = []

east_teams = []

matches = []

matches_sorted = []

days = ["Lunes", "Martes", "Jueves", "Viernes"]

########################################

# FUNCTIONS #

########################################

def reset():

"""Resets the value of the variables"""

global west_teams, east_teams, matches, matches_sorted

west_teams = []

east_teams = []

matches = []

matches_sorted = []

def obtain_conference(line):

"""Obtains the conference of each team"""

global west_teams, east_teams

# Obtains each pair team_name-conf_name

for team in line.split():

team_name, conf_name = team.split("-")

# Checks if the team belongs to the west or east conference

if conf_name.strip() == WEST:

west_teams.append(team_name)

elif conf_name.strip() == EAST:

east_teams.append(team_name)

def match_teams():

"""Matches the teams of different conferences that start with the

same letter"""

global west_teams, east_teams, matches

for west_team in west_teams:

for index, east_team in enumerate(east_teams):

# If both teams start with the same letter, they are matched

if east_team.startswith(west_team[:1], 0, 1):

matches.append([west_team, east_team])

# Deletes the item of the list

east_teams.pop(index)

def getKey(item):

"""Returns the element that indicates the position in the alphabet"""

return item[2]

def match_days():

"""Matches the day of the match for each one based on the position

of the first letter in the alphabet"""

global matches, matches_sorted

# Extracts the first letter for each match (both teams start with

the same letter) and checks

# the position in the alphabet

for item in matches:

item.append(string.lowercase.index(item[0][:1].lower()))

# Sorts the list

matches_sorted = sorted(matches, key=getKey)

# Matches each day with each match based on the position of the first

letter in the alphabet

for index, day in enumerate(days):

matches_sorted[index].append(day)

def main():

"""Main function"""

global west_teams, east_teams, matches_sorted

# Reads each line of the input file

for line in fileinput.input():

# Reads each line

line = line.rstrip("\n")

# Matches the teams in each conference

obtain_conference(line)

# Prints the result - Conferences

print "Conferencia Oeste: %s" % ", ".join(map(str, west_teams))

print "Conferencia Este: %s" % ", ".join(map(str, east_teams))

# Matches the teams of different conferences that start with the

same letter

match_teams()

# Matches the day of the match for each one based on the position

of the first letter in the alphabet

match_days()

# Prints the result - Date of each match

print ("Emparejamientos con fecha: "),

for index, element in enumerate(matches_sorted):

if (index + 1 != len(matches)):

print (element[0] + " - " + element [1] + " (" +

element[3] + ")"+ ", "),

else:

print (element[0] + " - " + element [1] + " (" +

element[3] + ")" + "\n")

# Resets the value of the variables

reset()

########################################

# MAIN PROGRAM #

########################################

if __name__ == '__main__':

main() # Main function

Ejercicio 19. Todos los números quieren ser felices – 12 Puntos

Enunciado Algunos números son felices. Por desgracia no todos. Para los que no lo sepáis, un numero feliz es un número en el que, si vamos sumando de forma repetida la suma de los cuadrados de sus dígitos, al final nos sale uno (1). Por ejemplo, el 68 es un número feliz. ¿Por qué? Porque 6² + 8² = 36 + 64 = 100, y luego 1² + 0² + 0² = 1. El 28 es un número feliz, porque 2² + 8² = 4 + 64 = 68. Y luego 68, como hemos visto, es feliz y al final suma 1. El 23 es un número feliz, porque 2² + 3² = 4 + 9 = 13. Y luego 13, es 1² + 3² = 10. El número 11, en cambio, no es feliz porque 1² + 1² = 2. Recientemente se ha descubierto que los números NO felices pueden pasar a ser felices uniéndose entre ellos (sumándose). Nosotros queremos que todos los números posibles sean felices y por eso se pide realizar un programa que, dada una serie de números positivos, obtenga las agrupaciones que hacen que un mayor número de ellos sean felices. Por ejemplo: 34 50 50 -1 Nota: El ultimo -1 es para indicar donde acaba el listado, no se debe tomar en consideración. Con la anterior entrada, el programa nos indicará los números que son felices de la entrada y si es mediante una unión, indicará que hay una unión de números que los hacen felices: 50+50 Nota: La salida deberá será ser así, separados por el símbolo “+”. Si alguno de los números de la entrada ya es feliz, simplemente se trasladará a la salida. Se pide desarrollar un programa para que la cantidad de números no felices sea la mínima posible.

Test Cases Entrada 100 34 50 -1 Salida 100 Entrada 100 100 50 50 -1 Salida 100

100 50+50 Entrada 25 25 25 25 25 -1 Salida 25+25+25+25


#include <cmath>

#include <math.h>

#include <vector>

#include <iterator>

#include <algorithm>

std::vector<int> solucion;

std::vector<int> sumas;

int numSquareSum(int n)

{

int squareSum = 0;

while (n)

{

squareSum += (n % 10) * (n % 10);

n /= 10;

}

return squareSum;

}

// method return true if n is Happy number

bool isHappynumber(int n)

{

int slow, fast;

// initialize slow and fast by n

slow = fast = n;

do

{

// move slow number by one iteration

slow = numSquareSum(slow);

// move fast number by two iteration

fast = numSquareSum(numSquareSum(fast));

}

while (slow != fast);

// if both number meet at 1, then return true

return (slow == 1);

}

void subsetSums(int arr[], int l, int r, int sum=0)

{

// Print current subset

if (l > r)

{

if (isHappynumber(sum))

{

if (sumas.size() > solucion.size())

{

solucion.clear();

for (int i=0; i<sumas.size(); i++)

{

//std::cout << sumas.at(i) << "+";

solucion.push_back(sumas.at(i));

}

}

}

return;

}

// Subset including arr[l]

sumas.push_back(arr[l]);

subsetSums(arr, l+1, r, sum+arr[l]);

// Subset excluding arr[l]

sumas.pop_back();

subsetSums(arr, l+1, r, sum);

}

int main()

{

int n=0;

int length=0;

std::vector<int> numbers;

std::vector<int> tmp;

//read numbers

while (n!=-1)

{

std::cin>>n;

if (n!=-1)

{

length++;

numbers.push_back(n);

}

}

//remove already happy numbers

int array[length];

//n2 is the number of non-happy numbers

int n2=0;

for (int i=0; i<length; i++)

{

array[i]=0;

if (isHappynumber(numbers.at(i)))

{

std::cout << numbers.at(i) << std::endl;

}

else

{

array[n2]=numbers.at(i);

n2++;

}

}

//if there exists more than one non-happy number...

if (n>1)

{

subsetSums(array, 0, n2-1);

//show solutions

for (int i=0; i<solucion.size()-1; i++)

{

std::cout << solucion.at(i) << "+";

}

std::cout << solucion.at(solucion.size()-1) << std::endl;

}

}

ejercicio 0. - hp scds · entrada no se requiere salida welcome to codewars! ejercicio 1....

Documents