3

#PlatziCodingChallenge Dia #28 Código Morse y #29 Teléfono

  1. Código Morse
    El código morse te permite mandar señales mediante cualquier medio que pueda ser intermitente. Esto significa que puedes mandar señales a través de pulsos eléctricos (como en el telégrafo), audio, luz, etc. El reto del día de hoy es crear un decodificador de código morse. Por ejemplo:

hola mundo -> .... --- .-.. .- -- ..- -. -.. ---

  1. Teléfono
    Los botones de un teléfono también representan letras. Por ejemplo, en un teléfono podemos decir que:

2 ABC
3 DEF
4 GHI
5 JKL
6 MNO
7 PRS
8 TUV
9 WXY

Dado un teléfono de 7 dígitos, crea un programa que calcule todas las palabras posibles.

Escribe tu comentario
+ 2
Ordenar por:
1
17607Puntos

Reto 29: Teléfono
Repositorio del reto: PlatziCodingChallengeRepo
GitHub pages: PlatziCodingChallengePages

<!DOCTYPE html><htmllang="en"><head><metacharset="UTF-8"><metahttp-equiv="X-UA-Compatible"content="IE=edge"><metaname="viewport"content="width=device-width, initial-scale=1.0"><title>Reto 29: Teléfono</title></head><style>body {
		display: flex;
		flex-direction: column;
		align-items: center;
	}
</style><body><h1>Teléfono</h1><labelfor="phone">Ingrese teléfono</label><inputtype="phone"name="phone"id="phone"><buttontype="button"onclick="handleGenerate()">Generar</button><h2id="result"></h2><script>let dataNumbers = { '0': ' ', '1': ' ', '2': 'ABC', '3': 'DEF', '4': 'GHI', '5': 'JKL', '6': 'MNO', '7': 'PQRS', '8': 'TUV', '9': 'WXYZ' };
		functiongenerateLetters(number) {
			let letters = [];
			for (let i = 0; i < number.length; i++) {
				let value = dataNumbers[number.charAt(i)];
				let lettersItem = {
					'number': number.charAt(i) + "i" + i,
					'letters': [],
					'index': 0,
					'completed': false
				};
				for (let j = 0; j < value.length; j++) {
					lettersItem.letters.push({
						'letter': value.charAt(j),
					});
				}
				letters.push(lettersItem);
			}
			return letters;
		}
		functiongenerateWords(number, data) {
			let words = "";
			let word = "", aux = "";
			let i = 0;
			while (true) {
				if (i < 0) {
					break;
				}
				let item;
				let band = false;
				let value;
				if ((i + 1) < number.length) {
					value = number.charAt(i + 1) + "i" + (i + 1);
					item = data.find(item => item.number === value);
					if (item.completed) {
						value = number.charAt(i) + "i" + i;
						item = data.find(item => item.number === value);
						word = aux.substr(0, i);

						item.index += 1;
						if (item.index >= item.letters.length && item.index > 0) {
							item.completed = true;
							item.index = -1;
							i -= 1;
							continue;
						} else {
							item.completed = false;
						}
					}
				} else {
					word = aux;
					band = true;
				}
				value = number.charAt(i) + "i" + i;
				item = data.find(item => item.number === value);
				if (item.letters.length > 0) {
					word += item.letters[item.index].letter;
				}
				if (band) {
					item.index += 1;
					words += word + "<br />";
					if (item.index >= item.letters.length) {
						item.completed = true;
						item.index = 0;
						i -= 1;
					} else {
						item.completed = false;
					}
				} else {
					aux = word;
					i += 1;
				}
			}
			return words.replaceAll(' ', '');
		}

		functionhandleGenerate() {
			let phone = document.getElementById("phone").value;
			if (phone.length !== 7 || isNaN(phone)) {
				alert("Debe ingresar un teléfono de 7 digitos");
				return;
			}
			let result = document.getElementById("result");
			let data = generateLetters(phone);
			result.innerHTML = generateWords(phone, data);
		}
	</script></body></html>
1
6327Puntos

Código Morse en Java ☕️

publicclass CodigoMorse {
    publicstaticvoid main(String[] args) {
        //Map clave y valor
        Map<Character, String> alphabetMorse = new HashMap<Character, String>();
        alphabetMorse.put('A', ".-");
        alphabetMorse.put('B', "-...");
        alphabetMorse.put('C', "-.-.");
        alphabetMorse.put('D', "-..");
        alphabetMorse.put('E', "-.");
        alphabetMorse.put('F', "..-.");
        alphabetMorse.put('G', "- -.");
        alphabetMorse.put('H', "....");
        alphabetMorse.put('I', "..");
        alphabetMorse.put('J', ".- - -");
        alphabetMorse.put('K', "-.-");
        alphabetMorse.put('L', ".-..");
        alphabetMorse.put('M', "- -");
        alphabetMorse.put('N', "-.");
        alphabetMorse.put('O', "- - -");
        alphabetMorse.put('P', ".- -.");
        alphabetMorse.put('Q', "- - .-");
        alphabetMorse.put('R', ".-.");
        alphabetMorse.put('S', "...");
        alphabetMorse.put('T', "-");
        alphabetMorse.put('U', "..-");
        alphabetMorse.put('V', "...-");
        alphabetMorse.put('W', ".- -");
        alphabetMorse.put('X', "-..-");
        alphabetMorse.put('Y', "-.- -");
        alphabetMorse.put('Z', "- -..");
        alphabetMorse.put(' ', "/");
        alphabetMorse.put('0', "- - - - -");
        alphabetMorse.put('1', ".- - - -");
        alphabetMorse.put('2', "..- - -");
        alphabetMorse.put('3', "...- -");
        alphabetMorse.put('4', "....-");
        alphabetMorse.put('5', ".....");
        alphabetMorse.put('6', "-....");
        alphabetMorse.put('7', "- -...");
        alphabetMorse.put('8', "- - -..");
        alphabetMorse.put('9', "- - - -.");

        System.out.println("Ingresa el texto a traducir :)");
        Scanner scanner = new Scanner(System.in);
        String texto = scanner.nextLine();
        String textoMayus = texto.toUpperCase().trim(); // convierte el texto a mayusculas y le quita espacios final e inicialchar[] arrayTexto = textoMayus.toCharArray();
        StringBuilder traduccion = new StringBuilder();

   for (int i = 0; i < arrayTexto.length; i++) {
            traduccion.append(alphabetMorse.get(arrayTexto[i])).append(" "); //se construye el string con cada resultado de la busqueda del caracter a morse y le agrega un punto al final
        }

        System.out.println(texto + " -> " + traduccion);
	}
}

Resultado del programa

1

En Python:

  1. Código morse
""" Programa para codificar un texto ingresado a código morse.
Program to encode a text entered in morse code. """

morse_code = {
    "a": ".-", "b": "-...", "c": "-.-.", "d": "-..", "e": ".", "f": "..-.", 
    "g": "--.", "h": "....", "i": "..", "j": "·---", "k": "-.-", "l": ".-..", 
    "m": "--", "n": "-.", "ñ": "--.--", "o": "---", "p": ".__.", "q": "--.-",
    "r": ".-.", "s": "...", "t": "-", "u": "..-", "v": "...-", "w": ".--",
    "x": "-..-", "y": "-.--", "z": "--..",
    "0": "-----", "1": ".----", "2": "..---", "3": "...--", "4": "....-", 
    "5": ".....", "6": "-....", "7": "--...", "8": "---..", "9": "----.",  
    ".": ".-.-.-", ",": "-.-.--", "?": "..--..", "!": "-.-.--", "´": ".----.", 
    "\"": ".-..-.", "(": "-.--.", ")": "-.--.-", "&": ".-...", ":": "---...",
    ";": "-.-.-.", "/": "-..-.", "_": "..--.-", "=": "-...-", "+": ".-.-.",
    "-": "-....-", "$": "...-..-", "@": ".--.-." 
}
    
defencode_to_morse(text):
    text_list = text.split(' ') 
    morse_list = [] 
    for word in text_list:
        morse_word = ''for letter in word:
            morse_word += morse_code[letter] + ' ' 
        morse_list.append(morse_word) 
        morse_text = '  '.join(morse_list) 
    return morse_text
    
defget_text():
    right_text = 0
    text = input('Please enter the text you want to encode to morse code (a-z, 0-9, .,?!´"()&:;/[email protected]):\n' )
    while right_text == 0:
        for letter in text:
            ifnot letter in morse_code:
                text = input('Invalid entry. Please enter the text you want to encode to morse code using valid characters (a-z, 0-9, .,?!´"()&:;/[email protected]):\n' )
                right_text = 0breakelse:
                right_text = 1return text
    

if __name__ == "__main__":
    print('Code morse encoder!!!')
    print('Your text in code morse is:\n{}' .format(encode_to_morse(get_text())))
1
7 meses

En Python:

  1. Teléfono (teniendo en cuenta que 0 y 1 no representan ninguna letra e incluyendo la “Q” en el número 7)
""" Programa para calcular todas las palabras posibles dado un número de teléfono de 7 dígitos.
Program to calculate all possible words with a 7 digit phone number. """import re

if __name__ == "__main__":
    print('Telephone!!!')
    print('| 1      2 ABC  3 DEF |\n| 4 GHI  5 JKL  6 MNO |\n| 7 PQRS 8 TUV  9 WXY |')
    
    number = input('Please insert a 7 digits number: ')
    number_pattern = re.compile(r'[0-9]{7}')
    whilenot number_pattern.fullmatch(number):
        number = input('Invalid entry. Please insert a 7 digits number: ')
    
    numbers_of_sevens = 0
    no_letter_numbers = 0for num in number:
        if num == '7':
            numbers_of_sevens += 1elif num == '0'or num == '1':
            no_letter_numbers += 1
    
    posibly_words = (3**(7-numbers_of_sevens-no_letter_numbers))*(4**(numbers_of_sevens))
    if posibly_words == 1: posibly_words = 0
    
    print('The posibly number of words with your number ({}) is: {}' .format(number, posibly_words))
1
19943Puntos

Telefono en JavaScript, a mi parecer el reto más difícil hasta ahora:

//Telefono en JavaScriptconst TELEPHONE = newMap([
    [2, ['A', 'B', 'C']],
    [3, ['D', 'E', 'F']],
    [4, ['G', 'H', 'I']],
    [5, ['J', 'K', 'L']],
    [6, ['M', 'N', 'O']],
    [7, ['P', 'R', 'S']],
    [8, ['T', 'U', 'V']],
    [9, ['W', 'X', 'Y']],
])

functiontelephoneWords(phone) { //'7778899'let numbers = phone.split('').map(el => parseInt(el)) //[7, 7, 7, 8, 8, 9, 9]//Verificando que solo hayan números entre 2 - 9if (!numbers.every(num => num != NaN && num >= 2 && num <= 9)) {
        return'El teléfono solo puede tener números entre 2 y 9'
    }
    let numbersWithTimes = listWithTimes(numbers) //[[7, 3], [8, 2], [9, 2]]let combinations = numbersWithTimes.map(el => {
        let number = el[0]
        let times = el[1]
        return lettersCombinations(number, times)
    })
    let listWords = combineElements(combinations)
    return listWords
}

//[7, 7, 7, 8, 8, 9, 9] => [ [7, 3], [8, 2], [9, 2] ]functionlistWithTimes(list) {
    let timesList = newArray()
    for (let i = 0; i <= list.length; i++) {
        if (list[i] == list[i - 1]) {
            times++
        } else {
            if (list[i - 1] != undefined) {
                timesList.push([list[i - 1], times])
            }
            times = 1
        }
    }
    return timesList
}

//[7, 3] => ["PPP", "PR", "RP", "S"]functionlettersCombinations(number, times) {
    return addendsList(times).map(sum => {
        return sum.map(n => {
            return TELEPHONE.get(number)[(n - 1) % 3]
        }).join('')
    })
}

/* Esta función toma un número "n" y devuelve un array
donde cada elemento es otro array
donde los elementos de ese array hijo sumados dan el número "n" */functionaddendsList(n) {
    if (n == 1) {
        return [[1]]
    } else {
        let list = newArray()
        for (let i = 1; i < n; i++) {
            let r = n - i
            addendsList(r).forEach(el => {
                list.push([i].concat(el))
            })
        }
        list.push([n])
        return list
    }
}

/* [ ["PP", "R"], ["TT", "U"], ["WW", "X"] ] (listOfLists)
=> ["PPTTWW", "PPTTX", "PPUWW", "PPUX", "RTTWW", "RTTX", "RUWW", "RUX"] (superlist) */functioncombineElements(listOfLists) {
    let superlist = newArray()
    let firstList, secondList
    if (listOfLists.length == 2) {
        firstList = listOfLists[0]
        secondList = listOfLists[1]
    } else {
        firstList = listOfLists.shift()
        secondList = combineElements(listOfLists)
    }
    firstList.forEach(el1 => {
        secondList.forEach(el2 => {
            superlist.push(`${el1}${el2}`)
        })
    })
    return superlist
}

console.log(telephoneWords('7788997'))
//["PPTTWWP", "PPTTXP", "PPUWWP", "PPUXP", "RTTWWP", "RTTXP", "RUWWP", "RUXP"]console.log(telephoneWords('2345678')) //["ADGJMPT"]console.log(telephoneWords('7508456')) //"El teléfono solo puede tener números entre 2 y 9"console.log(telephoneWords('5556555')) //16 palabras posibles/* [ ["JJJMJJJ", "JJJMJK", "JJJMKJ", "JJJML",
"JKMJJJ", "JKMJK", "JKMKJ", "JKML",
"KJMJJJ", "KJMJK", "KJMKJ", "KJML",
"LMJJJ", "LMJK", "LMKJ", "LML"] ] */
1
7689Puntos

Reto 28: Le agregué también la funcionalidad de transformar a morse

<!DOCTYPE html><htmllang="en"><head><metacharset="UTF-8"><metaname="viewport"content="width=device-width, initial-scale=1.0"><title>Ahorros en otros periodos</title></head><style>
  * {
    margin: 0;
  }

  .contenedor {
    display: flex;
    flex-direction: column;
    align-items: center;
    justify-content: center;
    height: 100vh;
  }

  .section {
    padding: 2rem;
  }

  .inputs {
    display: inherit;
    flex-direction: column;
    justify-content: center;
    align-items: center;
  }

  .btn {
    border: 2px solid black;
    border-radius: 6px;
    cursor: pointer;
    height: 50%;
  }

  #newFrase {
    padding: 020px;
    text-align: justify;
  }
</style><body><divclass="contenedor"><h1style="margin-bottom: 10px;">Morse a ABC y viceversa</h1><h5>(Usa / para especificar un espacio)</h5><divclass="inputs"><divstyle="display: flex; flex-direction: row; justify-content: center; align-items: center;"><sectionclass="section">
          Morse: <inputid="morse"/></section><buttononclick="descifrar()"class="btn">Descifrar...</button></div><h4style="margin-bottom: 16px;">Esto significa: <spanid='descifrado'></span></h4><divstyle="display: flex; flex-direction: row; justify-content: center; align-items: center;"><sectionclass="section">
          Frase: <inputid="frase"/></section><buttononclick="cifrar()"class="btn">Cifrar...</button></div><h4style="margin-bottom: 16px;">Cifrado sería: <spanid='cifrado'></span></h4></div></div><script>const parser = {
      'a': '.-', 'b': '-...', 'c': '-.-.', 'd': '-..', 'e': '.', 'f': '..-.', 'g': '--.', 'h': '....', 'i': '..', 'j': '.---', 
      'k': '-.-', 'l': '.-..', 'm': '--', 'n': '-.', 'o': '---', 'p': '.--.', 'q': '--.-', 'r': '.-.', 's': '...', 't': '-', 
      'u': '..-', 'v': '...-', 'w': '.--', 'x': '-..-', 'y': '-.--', 'z': '--..', '/': '/',
    }
    const abc = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '/']

    functiondescifrar(){
      let morse = document.getElementById('morse').value
      let mensaje = []
      morse = morse.split(' ')
      morse.map( index => {
        abc.map( letter => {
          if (parser[letter] === index){
            mensaje.push(letter)
          }
        })
      })
      document.getElementById('descifrado').innerHTML = mensaje.join('').replace(/[/]/g, ' ')
    }

    functioncifrar(){
      let frase = document.getElementById('frase').value
      let mensaje = []
      frase = frase.toLowerCase().replace(/[ ]/g, '/').split('')
      frase.map( index => {
        console.log(frase)
        abc.map( letter => {
          if (letter === index){
            mensaje.push(parser[letter])
          }
        })
      })
      document.getElementById('cifrado').innerHTML = mensaje.join(' ')
    }
  </script></body></html>
2
7689Puntos
7 meses

Reto 29: No comprendí bien este reto, ya que siempre será una sola respuesta, siempre será 2187, ya que el número siempre constará de 7 dígitos (Aunque yo hice este programa para que me reciba hasta un max de 7 dígitos) los cuales tendrán solamente 3 distintas posibilidades, porque la instrucción dice “Dado un teléfono de 7 dígitos, crea un programa que calcule todas las palabras posibles” por ende todos los números solo tienen 3 distintas letras c/u, ejemplo 2 ABC y 7 PRS o 9 WXY, y así solamente tenemos que poner las posibilidades (al ser todas 3) elevado a la longitud del número, o 3 * 3 * 3 * 3 * 3 * 3 * 3, si alguien entendió diferente el reto, agradecería que me lo explicara.

<!DOCTYPE html><htmllang="en"><head><metacharset="UTF-8"><metaname="viewport"content="width=device-width, initial-scale=1.0"><title>Ahorros en otros periodos</title></head><style>
  * {
    margin: 0;
  }

  .contenedor {
    display: flex;
    flex-direction: column;
    align-items: center;
    justify-content: center;
    height: 100vh;
  }

  .section {
    padding: 2rem;
  }

  .inputs {
    display: inherit;
    flex-direction: column;
    justify-content: center;
    align-items: center;
  }

  .btn {
    border: 2px solid black;
    border-radius: 6px;
    cursor: pointer;
    height: 50%;
  }

  #newFrase {
    padding: 020px;
    text-align: justify;
  }
</style><body><divclass="contenedor"><h1>Telefono</h1><divclass="inputs"><divstyle="display: flex; flex-direction: row; justify-content: center; align-items: center;"><sectionclass="section">
          Número de celular: <inputmaxlength="7"id="number"placeholder="xxxxxxx 7 DIGITS MAX"/></section><buttononclick="calcular()"class="btn">calcular...</button></div><h4style="margin-bottom: 16px;">Se pueden hacer un total de <spanid='combinaciones'>0</span> combinaciones con este número</h4></div></div><script>// No comprendí bien este reto, ya que siempre será una sola respuesta, siempre será 2187, ya que el número siempre constará de 7 dígitos (Aunque yo hice este programa para que me reciba hasta un max de 7 dígitos) los cuales tendrán solamente 3 distintas posibilidades, porque la instrucción dice "Dado un teléfono de 7 dígitos, crea un programa que calcule todas las palabras posibles" por ende todos los números solo tienen 3 distintas letras c/u, ejemplo 2 ABC y 7 PRS o 9 WXY, y así solamente tenemos que poner las posibilidades (al ser todas 3) elevado a la longitud del número, o 3 * 3 * 3 * 3 * 3 * 3 * 3, si alguien entendió diferente el reto, agradecería que me lo explicara.functioncalcular(){
      const long = document.getElementById('number').value.length
      let resultado = 3 ** long
      document.getElementById('combinaciones').innerHTML = resultado
    }
  </script></body></html>
1
19943Puntos
7 meses

Yo entendí el reto de esta manera:
Cuando en un teléfono digitamos un numero (por ejemplo el 7) y lo hacemos varias veces, las letras aparecerán dependiendo de cuantas veces digitamos ese numero y de COMO digitamos ese numero.
Es decir si presionamos 7 dos veces hay 2 posibilidades:

  • Si presionamos muy lento escribimos PP
  • Si presionamos muy rápido escribimos R
    Esto se complica más si presionamos 7 3 veces (podemos presionar las dos primeras veces rápido y la ultima no tan rápido obteniendo RP o presionar la primera vez lento y las dos ultimas veces rápido obteniendo PR, o presionar las 3 veces rápido obteniendo una S o las tres veces lento obteniendo PPP)
    Y se complica más si presionamos el mismo numero mas veces
    Y se complica mucho mas cuando presionamos varios números obteniendo varias combinaciones de letras.
    El reto seria hallar todas esas combinaciones de letras en base a las distintas combinaciones de números que podemos usar.
1
7689Puntos
7 meses

Joder jajajaja, el reto que dices tu esta totalmente diferente a lo que yo entendí y muchísimo más complicado, ya que en el reto nunca se estipula los temas que hablas, la directiva es “Dado un teléfono de 7 dígitos, crea un programa que calcule todas las palabras posibles.” pero si logras hacer ese programa, por favor cuéntalo para verlo por que suena bastaaante complicado.

1
26494Puntos

Reto 28 en Python. 🐍

MORSE_CODE = {
    'a': '· —',
    'b': '— · · ·',
    'c': '— · — ·',
    'd': '— · ·',
    'e': '· · — ·',
    'f': '· · — ·',
    'g': '— — ·',
    'h': '· · · ·',
    'i': '· .',
    'j': '· — — —',
    'k': '— · —',
    'l': '· — · ·',
    'm': '— —',
    'n': '— ·',
    'ñ': '— — · — —',
    'o': '— — —',
    'p': '· — — ·',
    'q': '— — · —',
    'r': '· — ·',
    's': '· · ·',
    't': '—',
    'u': '· · —',
    'v': '· · · —',
    'w': '· — —',
    'x': '— · · —',
    'y': '— · — —',
    'z': '— — · ·',
    '0': '— — — — —',
    '1': '· — — — —',
    '2': '· · — — —',
    '3': '· · · — —',
    '4': '· · · · —',
    '5': '· · · · ·',
    '6': '— · · · ·',
    '7': '— — · · ·',
    '8': '— — — · ·',
    '9': '— — — — ·',
    '.': '· — · — · —',
    ',': '— · — · — —',
    '?': '· · — — · ·',
    '"': '· — · · — ·',
    '!': '— — · · — —',
    ' ': ' '
}


defrun():
    print('DECODIFICADOR DE CÓDIGO MORSE\n')
    phrase = input('Ingresa una frase: ')

    phrase_morse = ''for letter in phrase:
        phrase_morse += MORSE_CODE[letter] + ' '

    print(phrase)
    print(f'Codificación en morse: {phrase_morse}')


if __name__ == "__main__":
    run()



1
13595Puntos
<h1>28 en -JS</h1>
const morseCode =[
    ".-",
    "-...",
    "-.-.",
    "-..",
    ".",
    "..-.",
    "--.",
    "....",
    "..",
    ".---",
    "-.-",
    ".-..",
    "--",
    "-.",
    "---",
    ".--.",
    "--.-",
    ".-.",
    "...",
    "-",
    "..-",
    "...-",
    ".--",
    "-..-",
    "-.--",
    "--.."
];

function decode(str) {
    let codedMessage = "";for (let i = 0; i < str.length; i++) {
        const charPos = str.toLowerCase().charCodeAt(i)-97;
        codedMessage += morseCode[charPos] + " ";
    }
    
    console.log(codedMessage);
}

1

28 en Python 😃

codigo = {'A': '.-','B': '-...','C': '-.-.','D': '-..','E': '.','F': '..-.','G': '--.','H': '....','I': '..','J': '.---','K': '-.-','L': '.-..','M': '--','N': '-.','O': '---','P': '.--.','Q':'--.-','R': '.-.','S':'...','T': '-','U': '..-','V':'...-','W':'.--','X': '-..-','Y': '-.--','Z': '--..','1': '.----','2':'..---','3': '...--','4': '....-','5':'.....','6': '-....','7': '--...','8':'---..','9':'----.','0': '-----','.':'.-.-.-',',':'--..--',':': '---...',';':'-.-.-.','?':'..--..','!': '-.-.--','"':'.-..-.',"'": '.----.','+': '.-.-.','-':'-....-','/': '-..-.','=': '-...-','_': '..--.-','$': '...-..-','@': '.--.-.','&': '.-...','(': '-.--.',')': '-.--.-'
}
frase=input('ingresa tu frase a traducir: ')
frase=frase.upper()
traducido=[]
for letra in frase:
    valor=codigo.get(letra)
    traducido.append(valor)
traducido=" ".join(traducido)
print(traducido)```
1

29 En Python 😃 Estuvo un poco confuso en mi interpretación se pregunta al usuario que tecla pulsar del 1 al 9 y luego preguntar cuantas veces teclea para ver que letra le sale y posterior preguntar si desea añadir mas letras hasta tener la palabra deseada por el usuario:

mensaje='''Ingresa tu texto de acuerdo al siguiente diccioario:
2 ABC
3 DEF
4 GHI
5 JKL
6 MNO
7 PRS
8 TUV
9 WXY
Donde si desea escribir Ej S debe ingresar el número 7 y
las veces de tecleado será igual 3 '''
sms=[]
numero2=['A','B','C']
numero3=['D','E','F']
numero4=['G','H','I']
numero5=['J','K','L']
numero6=['M','N','O']
numero7=['P','R','S']
numero8=['U','T','V']
numero9=['W','X','Y']
numeros=[numero2,numero3,numero4,numero5,numero6,numero7,numero8,numero9]
print(mensaje)
pregunta='y'while pregunta=='y':
    entrada_teclado=int(input('Ingrese un número del 2 al 9: '))
    veces_tecla=int(input('Ingrese cuantas veces presionar esa tecla: '))
    pregunta=input('Desea ingresar más letras a tu palabra? Y/N ')
    tecla=numeros[entrada_teclado-2]
    letrasms=tecla[veces_tecla-1]
    sms.append(letrasms)
sms="".join(sms)
print(sms)```
1
19943Puntos

Codigo Morse en JavaScript

//Codigo Morse en JavaScriptconst CODIGO_MORSE = newMap([
    ['a', '.-'], ['b', '-...'], ['c', '-.-.'], ['ch', '----'],
    ['d', '-..'], ['e', '.'], ['f', '..-.'], ['g', '--.'],
    ['h', '....'], ['i', '..'], ['j', '.---'], ['k', '-.-'],
    ['l', '.-..'], ['m', '--'], ['n', '-.'], ['ñ', '--.--'],
    ['o', '---'], ['p', '.--.'], ['q', '--.-'], ['r', '.-.'],
    ['s', '...'], ['t', '-'], ['u', '..-'], ['v', '...-'],
    ['w', '.--'], ['x', '-..-'], ['y', '-.--'], ['z', '--..'],
    ['0', '-----'], ['1', '.----'], ['2', '..---'], ['3', '...--'],
    ['4', '....-'], ['5', '.....'], ['6', '-....'], ['7', '--...'],
    ['8', '---..'], ['9', '----.'], ['.', '.-.-.-'], [',', '-.-.--'],
    ['?', '..--..'], ['"', '.-..-.'], ['!', '--..--']
])

functioncodificar(texto) {
    let caracteres = texto.toLowerCase().split('')
    let codigos = caracteres.map(char => CODIGO_MORSE.get(char))
    return codigos.join(' ')
}

console.log(codificar('Hola Mundo'))
//.... --- .-.. .-  -- ..- -. -.. ---
0
17607Puntos

Reto 28: Código Morse
Repositorio del reto: PlatziCodingChallengeRepo
GitHub pages: PlatziCodingChallengePages
reto28.png

<script>
		let morse = {
			"a": ".-",
			"b": "-...",
			"c": "-.-.",
			"d": "-..",
			"e": ".",
			"f": "..-.",
			"g": "--.",
			"h": "....",
			"i": ".. ",
			"j": ".---",
			"k": "-.-",
			"l": ".-..",
			"m": "--",
			"n": "-.",
			"o": "---",
			"p": ".--.",
			"q": "--.-",
			"r": ".-.",
			"s": "...",
			"t": "-",
			"u": "..-",
			"v": "...-",
			"w": ".--",
			"x": "-..-",
			"y": "-.--",
			"z": "--..",
		}
		function translate(words) {
			let words_translate = "";
			for (let i = 0; i < words.length; i++) {
				if (morse[words[i]])
					words_translate += morse[words[i]] + " ";
			}
			return words_translate;
		}
		function handleTranslate() {
			let words = document.getElementById("word").value;
			letresult = document.getElementById("result");
			result.innerHTML = translate(words);
		}
	</script>