Introducción a C#
¿Por qué aprender C#? ¿Para qué sirve?
Instalación de Visual Studio Community
Conoce .NET 6
Introducción a Visual Studio y nuestro primer "Hola, mundo" en consola
¡Nuestro primer "Hola, mundo" en una aplicación gráfica!
¿Cómo funcionan los Namespaces en C#?
Lógica de programación
Tipos de datos
Variables
Manejo de strings
Trabajando con números y operadores aritméticos
Operadores lógicos
Operadores relacionales
Cómo leer datos de un usuario en C#
Arreglos en C#
Listas
Métodos o methods
Métodos de strings
Cómo crear tus propios métodos
Bucles y estructuras de control en C#
La sentencia if
La sentencia switch
Ciclo for
Ciclo while
Proyecto
Introducción del proyecto: sistema de registros de usuarios
Creando la búsqueda y el registro de usuarios
Finalizado del proyecto: mostrando la lista de usuarios registrados
Tus siguientes pasos con C#
POO: tu siguiente paso con C#
Bienvenida o bienvenido a esta clase donde profundizaremos en los métodos de C#, específicamente en los métodos de strings.
...
Regístrate o inicia sesión para leer el resto del contenido.
Aportes 74
Preguntas 6
Dada una fecha como un string, y tomando en cuenta el símbolo “/”, se obtienen el día, el mes y el año, de la siguiente forma:
string fecha = “27/12/2021”;
string[] split = fecha.Split(new char[] { ‘/’ });
Console.WriteLine($“Día: {split[0]}”);
Console.WriteLine($“Mes: {split[1]}”);
Console.WriteLine($“Año: {split[2]}”);
El metodo de split está medio raro jaja
Me parece extraño el método CompareTo, es decir, retorna 0 para true y 1 para false, cuando normalmente se asocia al 0 con false y 1 con true
Un aporte, cuando se utiliza el método Split(), si queremos separar por un caracter, podemos pasar el caracter directamente con comillas simples, de esta manera:
string information = "Gonzalo,21,Chile";
string[] split = information.split(',');
Console.WriteLine(split[0]);
Console.WriteLine(split[1]);
Console.WriteLine(split[2]);
Hola , hay un detalle con la lectura ,no se muestra la lectura solo su icono
Es verdad, la lectura no esta colocada, aparece vacia
Clone
string food = "La comida menxicana es la mejor";
string cloneString = food.Clone().ToString();
Console.WriteLine(cloneString);
string s = "You lose your keys. You lose your pass in.";
string[] subs = s.Split(' ', '.'); //Omitiendo los puntos, caracter delimitador
foreach(var sub in subs)
{
Console.WriteLine($"Substring: " + sub);
}
//Omitiendo las cadenas vacias
char[] separators = new char[] {' ', '.'};
string[] subsClean = s.Split(separators, StringSplitOptions.RemoveEmptyEntries);
foreach(var sub in subsClean)
{
Console.WriteLine($"Substrins with remove empty entries: " + sub);
}
char[] arrayChar = food.ToCharArray();
Console.WriteLine(arrayChar);
int cont = 0;
for(int i = 0; i < arrayChar.Length; i++)
{
if(arrayChar[i] == 'a')
{
cont++;
}
}
Console.WriteLine($"The word 'a' is repeat : " + cont);
//String normal
string ClassTopic = "Metodos de Strings";
string School = "Platzi";
//Clone
string SchoolClone = School.Clone().ToString();
//Split
string student = "Laura Valentina Bernate Gordillo";
string[] subs = student.Split(' ');
Console.WriteLine("*----------- 1 String normal: --------------*");
Console.WriteLine("Estoy aprendiendo "+ClassTopic+" en "+ School+".");
Console.WriteLine();
Console.WriteLine("*-------------- 2 Clone() ------------------*");
Console.WriteLine("Se hace un clon de la palabra Platzi: "+SchoolClone);
Console.WriteLine();
Console.WriteLine("*---- 3 CompareTo() True = 0, False = 1 ----*");
Console.WriteLine("Compara ´Metodos de Platzi´ con ´Platzi´ Resultado es : "+ClassTopic.CompareTo(School));
Console.WriteLine("Compara ´Platzi´ con el con de ´Platzi´ Resultado es : " + School.CompareTo(SchoolClone));
Console.WriteLine();
Console.WriteLine(" 4 Contains() ");
Console.WriteLine("Retorna true si el string contiene los caracteres: ");
Console.WriteLine("La string School = Platzi contiene la palabra Pla : " + School.Contains("Pla"));
Console.WriteLine("La string School = Platzi contiene la palabra Ga : " + School.Contains("Ga"));
Console.WriteLine();
Console.WriteLine(" 5 EndWith() - 6 StartsWith() ");
Console.WriteLine("Platzi termina con zi: " + School.EndsWith("zi"));
Console.WriteLine("Platzi empieza con Pl: " + School.StartsWith("Pl"));
Console.WriteLine("Platzi empieza con Ga: " + School.StartsWith("Ga"));
Console.WriteLine();
Console.WriteLine(" 7 IndexOf ");
Console.WriteLine("La posicion dentro del string en el caracter Platzi es : "+School.IndexOf("a"));
Console.WriteLine();
Console.WriteLine(" 8 ToLower() - ToUpper() ");
Console.WriteLine("Letras en minusculas : "+ClassTopic.ToLower());
Console.WriteLine("Letras en mayusculas : "+ClassTopic.ToUpper());
Console.WriteLine();
Console.WriteLine(" 9 Insert() ");
Console.WriteLine(School.Insert(6," Es una educación virtual "));
Console.WriteLine();
Console.WriteLine(" 13 Slipt() ");
Console.WriteLine("Nombre del estudiante = "+student);
foreach (var sub in subs)
{
Console.WriteLine($"Substring: {sub}");
}
Este es el código de los diferentes ejemplos de los métodos string de la lectura.
Nota: Para el ejemplo de ToCharArray() se necesito un ejemplo mejor que el que se muestra. Ahí lo modifique un poco , chéquenlo y me dicen que opinan.
static void Main(string[] args)
{
//En la pieza de código anterior puedes ver un pequeño programa con dos variables tipo string y su impresión.
//Para este tipo de variables podemos utilizar una gran cantidad de métodos predefinidos dentro de la biblioteca estándar de C#.
//Utilicemos estas dos variables strings para conocer algunos de ellos.
string ClassTopic = "Métodos de strings";
string School = "Platzi";
Console.WriteLine("Estoy aprendiendo de " + ClassTopic + " en " + School + ".");
//Clone()
//El método Clone() crea un clon exacto de un string en una variable de tipo objeto. Por ello es necesario convertirlo a string utilizando ToString().
Console.WriteLine("\n-----------------");
Console.WriteLine("Clone() \n");
string SchoolClone = School.Clone().ToString();
Console.WriteLine(SchoolClone);
Console.WriteLine("-----------------");
//CompareTo()
//Sirve para comparar el contenido de dos strings.
//Si son iguales devuelve 0 para true y si son diferentes retorna 1 para false. En este caso como School y SchoolClone son strings idénticos devolverá un 0.
//¿Qué crees que se imprima en la primera línea?
Console.WriteLine("-----------------");
Console.WriteLine("CompareTo() \n");
Console.WriteLine(ClassTopic.CompareTo(School));
Console.WriteLine(School.CompareTo(SchoolClone));
Console.WriteLine("-----------------");
//Contains()
//Retorna True si el string contiene los caracteres que se pongan en los argumentos del método.
Console.WriteLine("-----------------");
Console.WriteLine("Contains() \n");
Console.WriteLine(School.Contains("lat"));
Console.WriteLine("-----------------");
//EndsWith()
//Similar a Contains(), pero para comparar si los caracteres están al final del string.
Console.WriteLine("-----------------");
Console.WriteLine("EndsWith() \n");
Console.WriteLine(School.EndsWith("zi"));
Console.WriteLine("-----------------");
//StartsWith()
//Funciona de la misma manera que EndsWith(), pero en este caso comprueba si empieza con una serie de caracteres indicados.
Console.WriteLine("-----------------");
Console.WriteLine("StartsWith() \n");
Console.WriteLine(School.StartsWith("Pl"));
Console.WriteLine("-----------------");
//Equals()
//Funciona de forma parecida a CompareTo(), pero para indicar si el contenido de ambos strings retorna True o False.
Console.WriteLine("-----------------");
Console.WriteLine("Equals() \n");
Console.WriteLine(School.Equals(SchoolClone));
Console.WriteLine("-----------------");
//IndexOf()
//Regresa la posición dentro del string del carácter indicado en el argumento.
Console.WriteLine("-----------------");
Console.WriteLine("IndexOf() \n");
Console.WriteLine(School.IndexOf("a"));
Console.WriteLine("-----------------");
//ToLower() y ToUpper()
//Convierten el string en todas letras minúsculas o mayúsculas.
Console.WriteLine("-----------------");
Console.WriteLine("ToLower() y ToUpper() \n");
Console.WriteLine(ClassTopic.ToLower());
Console.WriteLine(ClassTopic.ToUpper());
Console.WriteLine("-----------------");
//Insert()
//Inserta un nuevo string dentro de otro en la posición indicada dentro de los argumentos.
//En este caso es en 6 que es la posición después de la última letra de “Platzi”.
Console.WriteLine("-----------------");
Console.WriteLine("Insert() \n");
Console.WriteLine(School.Insert(6, " es educación online efectiva"));
Console.WriteLine("-----------------");
//LastIndexOf()
//Regresa la posición de la última vez que aparece el carácter.
//En este caso la letra “s” aparece varias veces en el string y así podemos notar cómo devuelve la última posición en la que aparece.
Console.WriteLine("-----------------");
Console.WriteLine("LastIndexOf() \n");
Console.WriteLine(ClassTopic.LastIndexOf("s"));
Console.WriteLine("-----------------");
//Remove()
//Elimina los caracteres del string a partir de la posición que le indiquemos hasta el final.
Console.WriteLine("-----------------");
Console.WriteLine("Remove() \n");
Console.WriteLine(ClassTopic.Remove(6));
Console.WriteLine("-----------------");
//Replace()
//Reemplaza todos los caracteres por otro indicado. En este caso todas las “s” serán cambiadas por “z”.
Console.WriteLine("-----------------");
Console.WriteLine("Replace() \n");
Console.WriteLine(ClassTopic.Replace("s", "z"));
Console.WriteLine("-----------------");
//Split()
//Este es un caso especial donde creamos un nuevo string donde guardamos el string separado en trozos por la letra indicada en los argumentos del método.
//Para este caso se separa por la letra “s” en 3 trozos que son los que imprimimos.
Console.WriteLine("-----------------");
Console.WriteLine("Split() \n");
string[] split = ClassTopic.Split(new char[] { 's' });
Console.WriteLine(split[0]);
Console.WriteLine(split[1]);
Console.WriteLine(split[2]);
Console.WriteLine("-----------------");
//Substring()
//Devuelve un substring o trozo de string de acuerdo a las posiciones indicadas en los argumentos.
Console.WriteLine("-----------------");
Console.WriteLine("Substring() \n");
Console.WriteLine(ClassTopic.Substring(2, 10));
Console.WriteLine("-----------------");
//ToCharArray()
//Convierte el string en un arreglo de caracteres.
Console.WriteLine("-----------------");
Console.WriteLine("ToCharArray() \n");
char[] arreglo;
arreglo =School.ToCharArray();
Console.WriteLine(arreglo[0]);
Console.WriteLine(arreglo[1]);
Console.WriteLine(arreglo[2]);
Console.WriteLine(arreglo[3]);
Console.WriteLine(arreglo[4]);
Console.WriteLine(arreglo[5]);
Console.WriteLine("-----------------");
//Trim()
//Elimina espacios al principio y al final de un string.
Console.WriteLine("-----------------");
Console.WriteLine("Trim() \n");
string TextWithSpaces = " hola, había espacios al principio y al final ";
Console.WriteLine(TextWithSpaces.Trim());
Console.WriteLine("-----------------");
}
Consola:
Para que el ToCharArray() se ejecute debemos usar un for.
<Console.WriteLine("\nToCharArray()");
char[] chars = School.ToCharArray();
for(int i = 0; i < chars.Length; i++)
Console.WriteLine(chars[i]);>
public class Program
{
public static void Main()// este codigo separa frases delimitadas por -
{
Console.WriteLine(“Ingrese dos frases separadas por -”);
string textPhrase = Console.ReadLine();
Console.WriteLine(“Su frase es: “+textPhrase);
Console.WriteLine(“Ahora vamos a separar su frase si contiene un -”);
int Index = textPhrase.IndexOf(”-”);
if (Index != -1)
{
Console.WriteLine("procesando su cadena de frases");
string[] textPhraseArray = textPhrase.Split('-');
Console.WriteLine("Su frase separada es:");
foreach (string text in textPhraseArray)
{
Console.WriteLine(text.Trim());
}
Console.WriteLine("Tiene un largo de " + textPhrase.Length);
Console.WriteLine("---------------------------------------------");
Console.WriteLine("Ahora vamos a convertir su frase a mayusculas");
foreach (string text in textPhraseArray)
{
Console.WriteLine(text.ToUpper().Trim());
}
Console.WriteLine("---------------------------------------------");
Console.WriteLine("Ahora vamos a convertir su frase a minusculas");
foreach (string text in textPhraseArray)
{
Console.WriteLine(text.ToLower().Trim());
}
}
else
{ Console.WriteLine("No con tiene ningun -"); }
}
}
El siguiente código permite al usuario corregir una palabra de una frase que ingrese por teclado.
using System;
namespace CorrectorOrtograficoManual
{
internal class Program
{
static void Main(string[] args)
{
bool exit = false;
string exitToGo = “”;
string phrase = “”;
string toFix = “”;
string wordToChange = “”;
string wordChange = “”;
while (!exit)
{
phrase = ReadPhrase();
Console.WriteLine("Is there a word that need a correction? Y/N\n");
toFix = Console.ReadLine();
if (toFix.ToUpper().Equals("N"))
{
exitToGo = KeepGoing();
if (exitToGo.ToUpper().Equals("Y"))
{
exit = true;
}
}
else if(toFix.ToUpper().Equals("Y"))
{
Console.WriteLine("\nType the word that you want to change:");
wordToChange = Console.ReadLine();
Console.WriteLine("\nWith what word you want to change: ");
wordChange = Console.ReadLine();
changeThePhrase(phrase, wordToChange, wordChange);
}
else
{
Console.WriteLine("\nYou must choice between Y or N\n");
}
}
Console.Clear();
Console.WriteLine("\n\n\n\nThank you for participate.\nWe wait for another try.");
}
public static string ReadPhrase()
{
Console.WriteLine("\nType a phrase for to analyse if it is correct.\n");
string phrase = Console.ReadLine();
return phrase;
}
public static string KeepGoing()
{
Console.WriteLine("\nDo you want to exit the program? (Y/N)");
string exitToGo = Console.ReadLine();
return exitToGo;
}
public static void changeThePhrase(string phrase, string wordToChange, string wordChange)
{
if(phrase.Contains(wordToChange))
{
string[] arrayPhrase = phrase.Split(" ");
for(int i = 0; i < arrayPhrase.Length; i++)
{
if (arrayPhrase[i].Equals(wordToChange))
{
arrayPhrase[i] = wordChange;
}
}
Console.WriteLine("\n\nThe phrase changed is:\n");
for(int i = 0; i < arrayPhrase.Length; i++)
{
Console.Write(arrayPhrase[i]+" ");
}
Console.WriteLine("\n\n");
}
}
}
}
Hice 2 en 1 que les parece?
using System.Text;
using System.Threading.Tasks;
namespace Empleados
{
class Program
{
public static object School { get; private set; }
static void Main(string[] args)
{
string School = "UDN";
string SchoolClone = School.Clone().ToString();
Console.WriteLine("Voy a empezar a estudiar en la " + School);
Console.WriteLine(SchoolClone);
Console.WriteLine(School.Contains("U"));
Console.WriteLine(School.EndsWith("N"));
/*
string Names = ("Carlos,Clara,Patricio,Daniel,Nataniel,Maria");
string team = (" 6 miembros");
Console.WriteLine("El equipo 5 de la empresa DDM esta compuesto por" + team + " que son " + Names);
string[] split = Names.Split(',');
Console.WriteLine(split[0]);
Console.WriteLine(split[1]);
Console.WriteLine(split[2]);
Console.WriteLine(split[3]);
Console.WriteLine(split[4]);
Console.WriteLine(split[5]);*/
}
}
}
string ClassTopic = "Métodos de strings";
string School = "Platzi";
Console.WriteLine("Estoy aprendiendo de " + ClassTopic + " en " + School + ".");
// Clone()
string SchoolClone = School.Clone().ToString();
Console.WriteLine(SchoolClone);
// CompareTo()
Console.WriteLine(ClassTopic.CompareTo(School));
Console.WriteLine(School.CompareTo(SchoolClone));
// Contains()
Console.WriteLine(School.Contains("Pla"));
// EndsWith()
Console.WriteLine(School.EndsWith("zi"));
// StartsWith()
Console.WriteLine(School.StartsWith("Pl"));
// Equals()
Console.WriteLine(School.Equals(SchoolClone));
// IndexOf()
Console.WriteLine(School.IndexOf("a"));
// ToLower() y ToUpper()
Console.WriteLine(ClassTopic.ToLower());
Console.WriteLine(ClassTopic.ToUpper());
// Insert()
Console.WriteLine(School.Insert(6, " es educación online efectiva"));
// LastIndexOf()
Console.WriteLine(ClassTopic.LastIndexOf("s"));
// Remove()
Console.WriteLine(ClassTopic.Remove(6));
// Replace()
Console.WriteLine(ClassTopic.Replace("s", "z"));
// Split()
string[] split = ClassTopic.Split(new char[] { 's' });
Console.WriteLine(split[0]);
Console.WriteLine(split[1]);
Console.WriteLine(split[2]);
// Substring()
Console.WriteLine(ClassTopic.Substring(2, 10));
// ToCharArray()
School.ToCharArray();
// Trim()
string TextWithSpaces = " hola, había espacios al principio y al final ";
Console.WriteLine(TextWithSpaces.Trim());
using System;
namespace Arrays
{
internal class Program
{
static void Main(string[] args)
{
for (int i = 0; i < 5; i++)
{
// Pedir al usuario que ingrese una palabra
Console.WriteLine("Ingrese una palabra:");
string palabra = Console.ReadLine();
// Convertir la palabra en un array de caracteres
char[] caracteres = palabra.ToCharArray();
// Invertir el orden de los caracteres en el array
Array.Reverse(caracteres);
// Unir los caracteres del array en una nueva cadena
string invertida = String.Join("", caracteres);
// Mostrar la palabra invertida en la consola
Console.WriteLine("La palabra invertida es: "
+ invertida);
Console.ReadLine();
}
}
}
}
Algunos métodos String
CompareTo() devuelve un numero -1, 0 o +1. Cero si son iguales.
Equals() devuelve true o false según sean iguales o diferentes los strings.
Un sencillo programa para limpiar y estandarizar nombres introducidos.
En su momento aprendi algunos de estos metodos con java, luego agregue algunos otros con javascript y luego se repiten mucho en otros lenguajes, los cambios en la forma de usarlos son minimos asi que se recicla ese conocimiento
Esta es una manera de hacer un contador de carácteres utilizando la función ToCharArray(), en este caso quise buscar cuantas veces está repetido el caracter ‘e’ en la oración “educación online efectiva”.
using System;
namespace Contador_de_carácteres
{
internal class ContadorDeCaracteres
{
static void Main(string[] args)
{
string sentence = "educación online efectiva";
char[] array = sentence.ToCharArray();
int counter = 0;
//cuenta cuantas veces está un caracter en un string, en este caso, e
for (int i = 0; i < array.Length; i++)
{
if (array[i] == 'e')
{
counter++;
}
}
Console.WriteLine(counter);
}
}
}
Hola, bueno mi codigo es un juego de ahorcado donde pueden colocar la palabra que quieran y comenzar a jugar!
no es mucho pero es trabajo honesto
//------------------------------------------------------------------Ahorcado--------------------------------------------------------------
//Hecho por: Juan Leal
//Primer reto en el que se usan 5 tipos de metodos de edicion de arrays
//Usando:
//ToLower; LastIndex; Equals ; replace ;toCharArray
string palabra = "juan";
char[] temp;
char[] VectorPalabra=palabra.ToCharArray();
int TamanoPalabra = palabra.Length;
string[] VectorEncontrar = new string[TamanoPalabra];
int Vidas = 5;
int aciertos = 0;
bool gano = false;
string entrada_usuario = " ";
int index_cambio = 0;
Console.WriteLine("Bienvenido, ahora jugaras al ahorcado" +
"\npara comenzar debes saber que tienes :"+Vidas+" para poder completar la plabra\n"+
"podras ver tu avance a medida que vas acertando"+
"la palabra que debes encontrar tiene " + TamanoPalabra + " letras"+
"buena suerte!");
for (int i = 0; i < VectorPalabra.Length; i++)
{
temp= (palabra.Replace(VectorPalabra[i], '_')).ToCharArray();
VectorEncontrar[i]=temp[i].ToString();
Console.WriteLine(VectorEncontrar[i]);
}
while (Vidas!=0 && gano==false)
{
Console.WriteLine("\t\t\t\t\t\t\tVidas: "+Vidas);
Console.WriteLine("\t\t\t\t\t\t\tLetras restantes: " + (TamanoPalabra-aciertos));
Console.WriteLine("Ingresa la letra");
entrada_usuario = Console.ReadLine().ToLower();
index_cambio = palabra.LastIndexOf(entrada_usuario);
if (index_cambio != -1)
{
if ((VectorEncontrar[index_cambio].Equals(entrada_usuario))==false)
{
aciertos++;
if (aciertos != TamanoPalabra)
{
Mostrar(index_cambio);
}
else
{
gano = true;
Mostrar(index_cambio);
Console.WriteLine("\n\tFELICIDADES GANASTE :D");
}
}
else
{
Console.WriteLine("Esa ya la elegiste ... sigue adelante");
}
}
else
{
Vidas--;
Mostrar(0);
Console.WriteLine("Mejor suerte a la proxima");
if(Vidas==0) { Console.WriteLine("Bueno parece que no hay una proxima"); }
}
}
void Mostrar(int ind)
{
Console.WriteLine("\n\n");
VectorEncontrar[ind] = entrada_usuario;
for (int i = 0; i < TamanoPalabra; i++)
{
Console.WriteLine(VectorEncontrar[i]);
}
}
using System;
class Program {
public static void Main (string[] args) {
Console.WriteLine ("Hello World");
Console.WriteLine("Enter the name user");
string nameUser = (Console.ReadLine());
if (nameUser == "Juan"){
Console.WriteLine("Enter the password");
string password = (Console.ReadLine());
if(password == "platzi"){
Console.WriteLine("correct password");
}
else{
Console.WriteLine("incorret password");
}
}
else{
Console.WriteLine($"The text {nameUser} is not a name user check the text.");
}
}
}
hice este código para contraseña y usuario pruébenlo
Contraseña: platzi
Usuario: Juan
posdata usuario en mayúscula
Un pequeño programa que me imprime todos los ejemplos de las funciones de cada método, me fue útil para comprender mejor su función y aplicación.
string sampleText = " Esta, es,una,CAdena,de , Ejamplo , ";
string finalText = "";
Console.WriteLine(sampleText);
//LastIndexOf para identificar la ultima posicion de un caracter o caracteres
int position = sampleText.LastIndexOf(',');
//Metodo Remove para quitar las posiciones indicadas en la cadena de texto
sampleText = sampleText.Remove(position, 1);
//Console.WriteLine(sampleText);
//Metodo Tolower para convertir en minusculas
sampleText = sampleText.ToLower();
//Metodo Replace para reemplazar una parte especifica de la cadena de texto
sampleText = sampleText.Replace(" ", ""); //se puede usar si se quieren quitar todos los espacios en blanco
sampleText = sampleText.Replace("ja", "je");
// Metodo Split para separar el texto
string[] arrayText = sampleText.Split(',');
for(int i=0; i < arrayText.Length; i++)
{
finalText += arrayText[i] + " ";
}
//Metodo Trim para quitar los espacios del inicio y final solamente
finalText = finalText.Trim();
Console.WriteLine(finalText);
input: Esta, es,una,CAdena,de , Ejamplo ,
output: esta es una cadena de ejemplo
Hola este es mi código para extraer de tu nombre completo tus apellidos y nombres por separado. No está optimizado aún para apellidos que contienen más de una palabra como: …de la cruz, …de Jesús, etc.
//_____________________________________MI RETO____________________________________________
Console.WriteLine("");
Console.WriteLine("Escribe tu nombre completo");
string userName = Console.ReadLine();
userName = userName.Trim();
//Extraer Apellido Materno
int indexApellidoMaterno = userName.LastIndexOf(" ");
indexApellidoMaterno++;
int apellidoMaternoLenght = userName.Length - indexApellidoMaterno;
string apellidoMaterno = userName.Substring(indexApellidoMaterno, apellidoMaternoLenght);
//Extraer Apellido Paterno
string userName2 = userName.Remove(indexApellidoMaterno);
userName2= userName2.Trim();
int indexApellidoPaterno = userName2.LastIndexOf(" ");
indexApellidoPaterno++;
int apellidoPaternoLenght = userName2.Length - indexApellidoPaterno;
string apellidoPaterno = userName2.Substring(indexApellidoPaterno,apellidoPaternoLenght);
//Extraer Nombre(s)
string userName3 = userName.Remove(indexApellidoPaterno);
userName3= userName3.Trim();
//Imprimir Resultados
Console.WriteLine("\nTu nombre(s) es: " + userName3.ToUpper());
Console.WriteLine("Tu apellido Paterno es: " + apellidoPaterno.ToUpper());
Console.WriteLine("Tu apellido Materno es: " + apellidoMaterno.ToUpper());
Este es un juego que consiste en adivinar una palabra en 7 intentos.
Para jugarlo se necesitan dos personas, una para escribir la palabra a adivinar (jugador 1) y otra para adivinarla (Jugador 2) .
Al ejecutar el programa aparecerá el siguiente mensaje: “Escribe una palabra de 7 letras y sin espacios”
Entonces el jugador 1 escribe la palabra sin que la vea el jugador 2 y hace Enter
Aparecerá el siguiente mensaje:
“Adivina la palabra de 7 letras y escríbela”
Después el jugador 2 adivina la palabra y la escribe en la consola y hace Enter.
Si no es la palabra correcta entonces aparecerá una lista numerada del 1 al 7 en el que aparecerán las letras que coincidan con la palabra correcta y el mensaje:
“Vuelve a escribir una palabra pero con las letras anteriores y en sus posiciones indicadas”.
Entonces el jugador 2 escribe una nueva palabra que incluya las letras de la lista y en sus posiciones indicadas y hace Enter.
Si no es la palabra correcta entonces se repiten los pasos 3 y 4 , pero solo tiene 7 intentos.
Si el jugador 2 no adivina la palabra correcta entonces aparecerá el siguiente mensaje:
“Perdiste el juego”
"La palabra correcta es: "
Para salir del juego haces Enter y vuelves a ejecutar el programa para empezar una nueva partida.
Pero si el jugador 2 adivina la palabra correcta entonces aparecerá el siguiente mensaje:
"¡Felicidades, ganaste el juego!""
Para salir del juego haces Enter y vuelves a ejecutar el programa para empezar una nueva partida.
El código incluye los siguientes métodos:
aquí esta mi ejercicio.
<code>
Console.WriteLine("please,insert a sentence ");
string herr = " estoy haciondo pruebas";
string harr = "ESTOY HACIONDO PRUEBAS";
Console.WriteLine(herr.ToUpper());//este vuelve a masyusculas
Console.WriteLine(harr.ToLower());//este lo vuelve a minusculas
//segundo mentodo
Console.WriteLine("segundo metodo");
Console.WriteLine(herr.Trim());//recurda los parentesis
Console.WriteLine(harr.Trim());
//tercer metodo
Console.WriteLine("tercer metodo");
string a = "afdggg";
string b = "aasgdsee";
Console.WriteLine(a);// 1 es lo letra que vamos a cambiar y 2 es la que lo remplaza
Console.WriteLine(b);// 1 2
Console.WriteLine("a con replace "+a.Replace("a", "b"));
Console.WriteLine("b con replace "+b.Replace("a", "b"));
Console.WriteLine("cuarto metodo");
Console.WriteLine("a se el remove 3 "+a.Remove(3));//solo acepta una
Console.WriteLine("b se le remueve 2 "+b.Remove(2));//borras todod que esten despues del numero dado
Console.WriteLine("quinto metodo");
string information = "gonzalo, 21, chile, juan, treces";
string[] split = information.Split(',');//esto hace para dividir la informvion
Console.WriteLine("cero "+split[0]);
Console.WriteLine("primera palabra "+split[1]);
Console.WriteLine("segunda palabra "+split[2]);
Console.WriteLine("tercera palabra "+split[3]);
Console.WriteLine("cuarta palabra "+split[4]);
using System;
namespace metodosStr
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Cómo fue tu día?: ");
string tuDia = Console.ReadLine();
Console.WriteLine(tuDia);
Console.WriteLine("Convertido a mayusculas: " + tuDia.ToUpper());
Console.WriteLine(“Quita espacios en blanco: " + tuDia.Replace(” ", “-”));
Console.WriteLine("Convertido a minusculas: " + tuDia.ToLower());
bool resp = tuDia.Contains(“a”);
Console.WriteLine("Posee letra /a/ el texto? " + resp);
string tuDiaClonado = tuDia.Clone().ToString();
Console.WriteLine("Frase clonada y mayuscula: " + tuDiaClonado.ToUpper());
}
}
}
Con el método CompareTo() me devolvió -1.
static void Main (String [] arg){
String reto = "curso de platzi practica de lo que se puede hacer con un string";
String oracion = "veamos otra palabra del curso de platzi";
Console.WriteLine("comparando las 2 oraciones: "+reto.CompareTo(oracion));
Console.WriteLine("Volviendo la primera frase Mayuscula: "+reto.ToUpper());
Console.WriteLine(oracion.Insert(11," opinion"));
Console.WriteLine(oracion.Remove(11));
Console.WriteLine(reto.Substring(8,15));
}
Solucion para mi reto:
Hice un programa que pide un nombre y una cualidad y da informacion sobre las vocales que tiene el nombre, une las cualidad junto al nombre y transforma todo a MAYUSCULAS
using System;
namespace RetoMetodosStrings
{
internal class Program
{
static void Main(string[] args)
{
Console.WriteLine("Introduce tu nombre y presionar ENTER");
string nombreUsuario = Console.ReadLine();
Console.WriteLine("Escribe con una palabra una cualidad de tuya");
string cualidadUsuario = Console.ReadLine();
string nombreMayus = nombreUsuario.ToUpper(); //METODO 1 - .ToUpper
string cualidadMayus = cualidadUsuario.ToUpper();
Console.WriteLine("Tu nombre en mayusculas es: " + nombreMayus);
Console.WriteLine("Tu nombre tiene la vocal 'A': " + (nombreUsuario.ToUpper()).Contains("A")); //METODO 2 .Contains
Console.WriteLine("Tu nombre tiene la vocal 'E': " + (nombreUsuario.ToUpper()).Contains("E"));
Console.WriteLine("Tu nombre tiene la vocal 'I': " + (nombreUsuario.ToUpper()).Contains("I"));
Console.WriteLine("Tu nombre tiene la vocal 'O': " + (nombreUsuario.ToUpper()).Contains("O"));
Console.WriteLine("Tu nombre tiene la vocal 'U': " + (nombreUsuario.ToUpper()).Contains("U"));
string lastLetterName = nombreUsuario.Substring(nombreUsuario.Length - 1); //METODO 3 .Substring
Console.WriteLine(nombreMayus.Insert((nombreUsuario.LastIndexOf(lastLetterName))+1, " ES " + cualidadMayus)); //METODO 4 .Inser Y METODO 5 .LastIndexOf
}
}
}
Dejo mi codigo
<using System;
using System.Collections.Generic;
namespace Arrays
{
internal class Program
{
static void Main(string[] args)
{
string[] palabras;
string oracion = " En 15 minutos entro a trabajar y estoy practicando C#\n";
palabras = new string[] { "Como va", "Tengo hambre", "Tengo sueno","C#" };
for (int i = 0; i < palabras.Length; i++) //Armo un ciclo For en el que el valor de i ira incrementando en uno en cada ciclo
{
Console.WriteLine(oracion.Contains(palabras[i])); //Comprueba si las palabras de la lista estan en la oracion.
}
Console.WriteLine(oracion.EndsWith("C#"));
Console.WriteLine(oracion.ToUpper());
for (int i = 0; i < palabras.Length; i++)
{
Console.WriteLine(oracion.Insert(0, palabras[i])); //Genera las oraciones agregando las palabras de la lista al final
}
Console.WriteLine(oracion.GetHashCode()); //Genera un codigo Hash a partir del string
}
}
}>
Mi ejercicio:
using System;
namespace StringMethods
{
class Program
{
static void Main(string[] args) {
string name;
string lastName;
string fullName;
string defaulUser = "user123 ";
string defaultuserName;
//Request user name
Console.WriteLine("Enter your name: ");
name = Console.ReadLine();
//Request usar last name
Console.WriteLine("now enter your last name: ");
lastName = Console.ReadLine();
//Insert space between name and lastName
name = name.Insert(name.Length, " ");
//Insert lastName into fullName
fullName = name.Insert(name.Length, lastName);
//User fullName is equal to another user?
if (fullName.Equals(defaulUser)){
Console.WriteLine("I'm sorry, your user was already created. ");
}
else{
//initialize the Random method
Random rdn = new Random();
//Print a welcome and
Console.WriteLine($"¡Welcome, {fullName}! The username created by default to you is: {name.Trim().ToLower()}{char.ToUpper(lastName[0])}{lastName.Substring(1)}{rdn.Next(1,1000)}");
}
}
}
}
Es pero que les sirva.
using System;
namespace variablesDEstring
{
class Program
{
static void Main(string[] args)
{
string Prueba1 = "Bienvenido";//La diferencia es () Te reto a encontrala
string prueba1 = Prueba1.Clone().ToString();
Console.WriteLine("No repetido " + Prueba1);//No repetido
Console.WriteLine(" ");
Console.WriteLine("Repetido " + prueba1);//Repetido
Console.WriteLine(" ");
Console.WriteLine("Reemplazar B con V " + prueba1.Replace("B", "V"));//Cambio de letra
Console.WriteLine(" ");
string espacios = " espacio al inicio";
Console.WriteLine("tiene el " + espacios);
Console.WriteLine("quita el " + espacios.Trim());//quita el espacio de inicio y final
Console.WriteLine(" ");
Console.WriteLine("inserto " + Prueba1.Insert(10, " Hay un error"));//inserta al final de Bienvenido Hay un error
Console.WriteLine(" ");
Console.WriteLine("remuevo venido " + Prueba1.Remove(4));//elimina las palabras de izquierda a derecha <=
}
}
}
Convertir la primera letra en MAYUSCULA:
using System;
namespace MetodosString
{
internal class Program
{
static void Main(string[] args)
{
string nombre = "andy";
//poner la primera letra mayuscula
String restoPalabra = nombre.Substring(1,nombre.Length- 1);
nombre = nombre.Remove(1);
nombre = nombre.ToUpper();
nombre = nombre.Insert(1,restoPalabra);
Console.WriteLine(nombre);
}
}
}
Dejo acá, cada uno de los metodos explicados en la clase para ser ejecutados y ver su funcionamiento
using System;
namespace StringMethods
{
class Program
{
static void Main(string[] args)
{
string ClassTopic = "Métodos de strings";
string School = "Platzi";
Console.WriteLine("Estoy aprendiendo de "+ ClassTopic + " en " + School);
//Clone
Console.WriteLine("\n");
string SchoolClone = School.Clone().ToString();
Console.WriteLine("========== Clone Method ==========");
Console.WriteLine(SchoolClone);
//CompareTo
Console.WriteLine("\n");
Console.WriteLine("========== CompareTo Method ==========");
Console.WriteLine(ClassTopic.CompareTo(School));
Console.WriteLine(School.CompareTo(SchoolClone));
//Contains
Console.WriteLine("\n");
Console.WriteLine("========== Contains Method ==========");
Console.WriteLine(School.Contains("Pla"));
//EndsWith
Console.WriteLine("\n");
Console.WriteLine("========== EndsWith Method ==========");
Console.WriteLine(School.EndsWith("zi"));
//StartsWith
Console.WriteLine("\n");
Console.WriteLine("========== StartsWith Method ==========");
Console.WriteLine(School.StartsWith("Pl"));
//Equals
Console.WriteLine("\n");
Console.WriteLine("========== Equals Method ==========");
Console.WriteLine(School.Equals(SchoolClone));
//IndexOf
Console.WriteLine("\n");
Console.WriteLine("========== IndexOf Method ==========");
Console.WriteLine(School.IndexOf("a"));
//ToLower and ToUpper
Console.WriteLine("\n");
Console.WriteLine("========== ToLower and ToUpeer Methods ==========");
Console.WriteLine(ClassTopic.ToLower());
Console.WriteLine(ClassTopic.ToUpper());
//Insert
Console.WriteLine("\n");
Console.WriteLine("========== Insert Methods ==========");
Console.WriteLine(School.Insert(6, " es educación online efectiva"));
//LastIndexOf
Console.WriteLine("\n");
Console.WriteLine("========== LastIndexOf Methods ==========");
Console.WriteLine(ClassTopic.LastIndexOf("s"));
//Remove
Console.WriteLine("\n");
Console.WriteLine("========== Remove Methods ==========");
Console.WriteLine(ClassTopic.Remove(6));
//Replace
Console.WriteLine("\n");
Console.WriteLine("========== Replace Methods ==========");
Console.WriteLine(ClassTopic.Replace("s","z"));
//Split
Console.WriteLine("\n");
Console.WriteLine("========== Split Methods ==========");
string[] split = ClassTopic.Split(new char[] { 's' });
Console.WriteLine(split[0]);
Console.WriteLine(split[1]);
Console.WriteLine(split[2]);
//Substring
Console.WriteLine("\n");
Console.WriteLine("========== Substring Methods ==========");
Console.WriteLine(ClassTopic.Substring(2, 10));
//ToCharArray
Console.WriteLine("\n");
Console.WriteLine("========== ToCharString Methods ==========");
Console.WriteLine(School.ToCharArray()[0]);
Console.WriteLine(School.ToCharArray()[1]);
Console.WriteLine(School.ToCharArray()[2]);
Console.WriteLine(School.ToCharArray()[3]);
Console.WriteLine(School.ToCharArray()[4]);
Console.WriteLine(School.ToCharArray()[5]);
//Trim
Console.WriteLine("\n");
Console.WriteLine("========== Trim Methods ==========");
string textWithSpaces = " hola, habia espacios al principio y al final ";
Console.WriteLine(textWithSpaces.Trim());
}
}
}
Hola este fue mi ejercicio!!!
string ClassTopic = “Métodos de Strings”;
string School = “Platzi”;
Console.WriteLine(“Estoy aprendiendo de " + ClassTopic + " en " + School + “.”);
Console.WriteLine(”\n");
Console.WriteLine(“Clone”);
string schoolClone = School.Clone().ToString();
Console.WriteLine(“Seguimos aprendiendo con " + schoolClone);
Console.WriteLine(”\n");
//split
string correo = “[email protected]”;
string[] split = correo.Split(new char[] { ‘@’ });
Console.WriteLine(“Split”);
Console.WriteLine(“[email protected]”);
Console.WriteLine($“username: {split[0]}”);
Console.WriteLine($“domain: {split[1]}”);
Console.WriteLine("\n");
//Upper y Lower
string nombre = “Jeancarlos Marcillo”;
string[] splitnombres = nombre.Split(new char[] { ’ ’ });
Console.WriteLine(“Upper, Lower, Subtring, Trim, Spli”);
Console.WriteLine(“Jean Carlos Marcillo”);
Console.WriteLine("Nombres en Mayúsculas: " + nombre.ToUpper());
Console.WriteLine("Nombres en Minúsculas: " + nombre.ToLower());
Console.WriteLine($“Nombre: {splitnombres[0]}”);
Console.WriteLine($“Apellido: {splitnombres[1]}”);
Console.WriteLine(“Substring de 1 a 4: " + nombre.Substring(0,4));
string nombre2 = " Jeancarlos Marcillo “;
Console.WriteLine(nombre2);
Console.WriteLine(“Trim: " + nombre2.Trim());
Console.WriteLine(“Replace: " + nombre2.Replace(” “,”@”));
Console.WriteLine(”\n”);
aquí les comparto mi ejercicio
ejercicio de usar 5 métodos de los strings, validar si hay estudiantes con el mismo nombre
string students = " Juan,Pepe,Marcelo,Julian,Juan ";
string cloneStudents = students.Clone().ToString();
students = students.Trim();
students = students.ToUpper();
string [] allStudents = students.Split(new char[] { ',' });
for(int i = 0; i < allStudents.Length-1; i++)
{
for (int j = i+1; j < allStudents.Length; j++)
{
Console.WriteLine($"en etudiante {allStudents[i]}, el igual que {allStudents[j]} " +
$"{allStudents[i].Equals(allStudents[j])}");
}
}
string sopa = "Caldo de camaron";
string seco = "Chicharron";
Console.WriteLine("El almuerzo para hoy es: \n" + sopa + "\n" + seco);
Console.WriteLine("=================================================");
string seco_clone = seco.Clone().ToString();
Console.WriteLine(seco.Equals(seco_clone));
Console.WriteLine(sopa.ToUpper() + "\n" + seco.ToLower());
Console.WriteLine(seco.Insert(seco.Length, " de Pollo"));
Console.WriteLine(sopa.LastIndexOf("n"));
Console.WriteLine(sopa.LastIndexOf("c"));
Console.WriteLine(sopa.Substring(0,6));
using System;
namespace _17_MetodosDeStrings
{
internal class Program
{
public static void Main()
{
string classTopic = "Metodos de Strings";
string school = "Platzi";
// String interpolation: No es propiamente una funcion, pero es algo necesario a la hora de concatenar strings.
// Normalmente concatenamos strings asi:
Console.WriteLine("Estoy aprendiendo " + classTopic + " en " + school);
// Pero notemos como tenemos que tener especial cuidado con las comillas y los operadores +, esto podria ser un problema sin son muchas variables a concatenar.
// Con string interpolation, podemos concatenar strings de forma mas limpia y con azucar sintactico.
Console.WriteLine($"Estoy aprendiendo { classTopic } en { school }");
// Notemos como ya no usamos el operador + y no nos preocupamos por tantas comillas en la expresion, solo apretura y cierre.
// Solo debemos poner el signo pesos($) al inicio de las comillas y dentro de las comillas usar los las llaves {} y dentro su variable
// Escapar comillas: Para escapar las comillas dobles, es decir, que podamos usar las comillas en nuestro string, lo hacemos con el backslash \, asi:
Console.WriteLine("Creo que mi apodo es \"Coderlover\" y creo que es divertido!"); // Creo que mi apodo es "Coderlover" y creo que es divertido!
// 🤔 Y si fuera una ruta por ejemplo: c:\Users\Platziuser\Documents\Cursos
// Podria ser asi, con doble \ para escapar el \ es decir, \\:
Console.WriteLine("c:\\Users\\Platziuser\\Documents\\Cursos");
// Pero no es algo tan bueno cuando no sabemos que tan larga es la url, o no sepamos ni como es.
// En ese caso escapamos todos los \ con @ al inicio de las comillas.
Console.WriteLine(@"c:\Users\Platziuser\Documents\Cursos");
// Metodo Clone
string schoolClone = school.Clone().ToString()!;
Console.WriteLine($"Escuela: { schoolClone }"); // Escuela: PlatziPlatzi
// Metodo CompareTo
Console.WriteLine(school.CompareTo(school)); // 0: Si son iguales
Console.WriteLine(classTopic.CompareTo(school)); // 1: No son iguales
Console.WriteLine(school.CompareTo(classTopic)); // -1: No son iguales
// Metodo Contains
Console.WriteLine(school.Contains("Pla")); // La variables school sin contiene las letas "Pla", por ender retorna true
// Metodo EndsWith
Console.WriteLine(school.EndsWith("tzi")); // La variables school sin contiene al final de la palabra las letas "tzi", por ender retorna true
// Metodo StartsWith
Console.WriteLine(school.StartsWith("Pla")); // La variables school sin contiene al inicio de la palabra las letas "Pla", por ender retorna true
// Metodo Equals
Console.WriteLine(school.Equals(classTopic)); // Si son iguales las dos variables retorna true, de lo contrario retorna false
// Metodo IndexOf
Console.WriteLine(classTopic.IndexOf("dos")); // Retorna el indice en la cual se encuantra el string, en este csao 4
// Metodo ToLower
Console.WriteLine("pLaTzI".ToLower()); // Transforma todo el texto a minusculas -> platzi
// Metodo ToUpper
Console.WriteLine("platzi".ToUpper()); // Transforma todo el texto a mayusculas -> PLATZI
// Metodo Insert
Console.WriteLine(school.Insert(6, $" { classTopic }")); // Inserta un nuevo string en una posicion especifica -> Platzi Metodos de Strings
// Metodo LastIndexOf
Console.WriteLine(@"c:\Users\Platziuser\Documents\Cursos".LastIndexOf(@"\")); // Retorna la posicion de la ultima vez que aparece el caracter o los caracteres
// Metodo Remove
Console.WriteLine(@"c:\Users\Platziuser\Documents\Cursos".Remove(12)); // Elimina los caracteres desde una posicion especifica hasta el final
// Metodo Replace
Console.WriteLine(@"c:\Users\Platziuser\Documents\Cursos".Replace(@"\", "/")); // Remplaza los caracteres de un string inidcando el caratcer a remplazar y el caracter nuevo
// Metodo Split
String[] path = @"c:\Users\Platziuser\Documents\Cursos".Split(@"\"); // Retorna una collecion de strings separados por un caracter especifico
foreach (var item in path)
{
Console.WriteLine($"item: { item }");
}
// Metodo SubString
Console.WriteLine(@"c:\Users\Platziuser\Documents\Cursos".Substring(2, 10)); // Retona un string comprendido entre los inidices inicial y final deseados
// Metodo ToCharrArray
char[] text = @"c:\Users\Platziuser\Documents\Cursos".ToCharArray(); // Convierte el texto en un arreglo de caracteres
foreach (var item in text)
{
Console.WriteLine($"item: { item }");
}
// Metodo Trim
Console.WriteLine(" Hola esto es un texto con espacios al inicio y al final ".Trim()); // Elimina los espacios al inicio y al final de un string
// Reto - Url platzi
string urlCurso = " HTTPS://pLaTzI.COM/clAsEs/2198-INtrOdUcCiOn-cShaRp/36839-mEtoDOS-dE-sTrINgs/ ";
Console.WriteLine($"URL: {urlCurso}");
// 1 - Conviertiendo la url a minusculas
urlCurso = urlCurso.ToLower();
Console.WriteLine($"ToLower: {urlCurso}");
// 2 - Elimnar espacios
urlCurso = urlCurso.Trim();
Console.WriteLine($"Trim: {urlCurso}");
// 3 - Dividir la url por el slash /
String[] collecionSeccionesUrl = urlCurso.Split(@"/");
for (int i = 0; i < collecionSeccionesUrl.Length; i++)
{
Console.WriteLine($"Posicion: {i} - item: { collecionSeccionesUrl[i] }");
}
// 4 - Imprimir ruta al reves
char[] collectionChars = urlCurso.ToCharArray();
string urlReverse = "";
for (int i = collectionChars.Length - 1; i >= 0; i--)
{
urlReverse += collectionChars[i];
}
Console.WriteLine($"Url reverse: {urlReverse}");
// 5 - Reemplazar string en la url
urlCurso = urlCurso.Replace("2198-introduccion-csharp", "2144-introduccion-a-POO");
Console.WriteLine($"Replace: {urlCurso}");
// 6 - Agregar un nuevo recurso a la url
urlCurso = urlCurso.Insert(urlCurso.Length -1, "/clases-abstractas");
Console.WriteLine($"Insert: {urlCurso}");
}
}
}```
Hola amig@s, Quiero compartir mi actividad. Toda sugerencia es bienvenida.
Creé un metodo booleano para saber si un número era primo y a partir de ahí mostrar un mensaje.
bool numberPrime(int number)
{
int divisor = 0;
for (int i = 1; i <= number; i++)
{
if (number % i == 0)
{
divisor++;
}
}
if (divisor == 2)
{
return true;
}
else
{
return false;
}
}
Random rnd = new Random();
int number = rnd.Next(1, 100);
string p = " is prime, ";
string np = " is not prime, ";
if(numberPrime(number) == true)
{
Console.WriteLine(($"{number + p}").ToUpper() );
string prime = p.Insert(11, " because has to devisors.");
Console.WriteLine("{0}{1}", number, prime);
}
else
{
Console.WriteLine(($"{number + np} ").ToLower());
string notP = np.Insert(15, " because has more than 2 devisors.");
Console.WriteLine("{0}{1}", number, notP);
}
using System;
using System.Collections.Generic;
namespace _14Methodsofstring
{
internal class Program
{
static void Main(string[] args)
{
Console.Write("¿Que estas estudiando hoy?: ");
string ClassTopic = Console.ReadLine();
string School = "Platzi";
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine($"Estoy aprendiendo {ClassTopic} en {School}");
// Método Clone()
Console.WriteLine("\n---------------------------------------------------------");
Console.WriteLine("\tClone()\n");
Console.WriteLine($" Aprendes en ==> {School}");
string SchoolClone = School.Clone().ToString();
Console.WriteLine($"string SchoolClone = School.Clone().ToString() ==> Aprendes en ==>{SchoolClone}");
// Método EndsWidth()
Console.WriteLine("\n---------------------------------------------------------");
Console.WriteLine("\tENDSWIDTH()\n");
Console.Write("La palabra PlATZI finaliza con Pla t/f:");
Console.Write(School.EndsWith("Pla"));
//Método ToUpper
Console.WriteLine("\n---------------------------------------------------------");
Console.WriteLine("\tTOUPPER()\n");
Console.Write("Escribiendo Platzi en mayusuculas.......");
Console.Write(School.ToUpper());
//Metodo ToLower
Console.WriteLine("\n---------------------------------------------------------");
Console.WriteLine("\tTOLOWER()\n");
Console.Write("Escribiendo Platzi en minusculas.......");
Console.Write(School.ToLower());
Console.WriteLine("\n---------------------------------------------------------");
Console.Write($"Quitando desde la posición 3 de la palabra platzi nos queda: ");
Console.WriteLine(School.Remove(3));
Console.WriteLine("\n---------------------------------------------------------");
}
}
}
He aqui mi codigo y mi impresion
My contribution 😄
int numStudents = 5;
Random rand = new Random();
List<string> studenstList = new List<string>();
Console.WriteLine("\t\tEnter your students\t\t");
int i = 0;
while (i < numStudents)
{
Console.WriteLine("Enter name of student: ");
string student = Console.ReadLine().Trim();
studenstList.Add(student);
i++;
}
Console.WriteLine("\nThe email of students are: ");
studenstList.ForEach(student => Console.WriteLine($"{student.Insert(student.Length, "@scholl.es")}"));
Console.WriteLine("\nThe passwords of students are: ");
studenstList.ForEach(student => Console.WriteLine($"User: {student.ToUpper().Replace("a", "4").Insert(student.Length, "123")} Password: {rand.NextInt64(100000, 200000)}"));
Comparto mi código, con este se puede saber si una palabra s palindroma
<using System;
public class Program
{
public static void Main()
{
string word = "";
string wordInvert = "";
Console.WriteLine("Ingrese una palabra palindroma:");
word = Console.ReadLine();
word = word.ToLower().Replace(" ", "");
for (int i = word.Length - 1; i >= 0; i--)
{
wordInvert = wordInvert + word[i];
}
if (true == word.Equals(wordInvert))
{
Console.WriteLine("La parabla: " + word + " es palindroma");
}
else
{
Console.WriteLine("La parabla: " + word + " No es palindroma");
}
}
}>
EJERCICIOS DE LA CLASE:
using System;
namespace MeotodosDeStrings_17
{
internal class Program
{
static void Main(string[] args)
{
Console.WriteLine("17. Métodos de strings");
Console.WriteLine();
string ClassTopic = "Métodos de strings";
string School = "Platzi";
Console.WriteLine($"string ClasssTopic = {ClassTopic}");
Console.WriteLine($"string School = {School}\n");
Console.WriteLine($"Estoy aprendiendo de {ClassTopic} en {School}.");
Console.WriteLine();
// Método Clone()
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine("> 01. METODO Clone()\n");
Console.WriteLine($"string School = \"Platzi\" ==> {School}");
string SchoolClone = School.Clone().ToString();
Console.WriteLine($"string SchoolClone = School.Clone().ToString() ==> {SchoolClone}");
Console.WriteLine("---------------------------------------------------------\n\n");
// Método CompareTo()
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine("> 02. METODO CompareTo()\n");
Console.WriteLine("ClassTopic.CompareTo(School) = " + ClassTopic.CompareTo(School)); // -1
Console.WriteLine("School.CompareTo(SchoolClone) = " + School.CompareTo(SchoolClone)); // 0
Console.WriteLine("---------------------------------------------------------\n\n");
// Método Contains()
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine("> 03. METODO Contains()\n");
Console.WriteLine("School.Contains(\"Pla\") = " + School.Contains("Pla"));
Console.WriteLine("---------------------------------------------------------\n\n");
// Método EndsWith()
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine("> 04. METODO EndsWith()\n");
Console.WriteLine($"School.EndsWith(\"zi\") = {School.EndsWith("zi")}");
Console.WriteLine("---------------------------------------------------------\n\n");
// Método StartsWith()
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine("> 05. METODO StartsWith()\n");
Console.WriteLine($"School.StartsWith(\"Pl\") = {School.StartsWith("Pl")}");
Console.WriteLine("---------------------------------------------------------\n\n");
// Método Equals()
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine("> 06. METODO Equals()\n");
Console.WriteLine($"Shool.Equals(SchoolClone) = {School.Equals(SchoolClone)}");
Console.WriteLine("---------------------------------------------------------\n\n");
// Método IndexOf()
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine("> 07. METODO IndexOf()\n");
Console.WriteLine($"School.IndexOf(\"a\") = {School.IndexOf("a")}");
Console.WriteLine("---------------------------------------------------------\n\n");
// Método ToLower() y ToUpper()
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine("> 08. METODO ToLower() y ToUpper()\n");
Console.WriteLine($"ClassTopic.ToLower() = {ClassTopic.ToLower()}"); // métodos de strings
Console.WriteLine($"ClassTopic.ToUpper() = {ClassTopic.ToUpper()}"); // MÉTODOS DE STRINGS
Console.WriteLine("---------------------------------------------------------\n\n");
// Método Insert()
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine("> 09. METODO Insert()\n");
Console.WriteLine($"School.Insert(6, \" es educación online efectiva. = \" {School.Insert(6, " es educación online efectiva.")}");
Console.WriteLine("---------------------------------------------------------\n\n");
// Método LastIndexOf()
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine("> 10. METODO LastIndexOf()\n");
Console.WriteLine($"ClassTopic = {ClassTopic}");
Console.WriteLine($"ClassTopic.LastIndexOf(\"s\") = {ClassTopic.LastIndexOf("s")}");
Console.WriteLine("---------------------------------------------------------\n\n");
// Método Remove()
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine("> 11. METODO Remove()\n");
Console.WriteLine($"ClassTopic.Remove(6) = {ClassTopic.Remove(6)}"); // Método
Console.WriteLine("---------------------------------------------------------\n\n");
// Método Replace()
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine("> 12. METODO Replace()\n");
Console.WriteLine($"ClassTopic.Replace(\"s\", \"z\") = {ClassTopic.Replace("s", "z")}");
Console.WriteLine("---------------------------------------------------------\n\n");
// Método Split()
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine("> 13. METODO Split()\n");
string[] split = ClassTopic.Split(new char[] { 's' });
Console.WriteLine($"split[0] = {split[0]}");
Console.WriteLine($"split[1] = {split[1]}");
Console.WriteLine($"split[2] = {split[2]}");
Console.WriteLine(split[2]);
Console.WriteLine("---------------------------------------------------------\n\n");
// Método Substring()
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine("> 14. METODO Substring()\n");
Console.WriteLine($"ClassTopic = {ClassTopic}");
Console.WriteLine($"ClassTopic.Substring(0,6) = {ClassTopic.Substring(0,6)}");
Console.WriteLine("---------------------------------------------------------");
// Método ToCharArray()
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine("> 15. METODO ToCharArray()\n");
Console.WriteLine($"School.ToCharArray() = {School.ToCharArray()}\n");
char[] schoolArray = School.ToCharArray();
Console.WriteLine($"School = {School}");
Console.WriteLine($"Longitud de School.Lenght = {schoolArray.Length}");
for (int i = 0; i < schoolArray.Length; i++)
{
Console.WriteLine($"schoolArray[{schoolArray[i]}]");
}
Console.WriteLine();
Console.WriteLine("---------------------------------------------------------\n\n");
// Método Trim()
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine("> 16. METODO Trim()\n");
string textWithSpaces = " ¡Hola!, había espacios al principio y a al final. ";
Console.WriteLine($"TextWithSpaces.Trim = {textWithSpaces.Trim()}");
Console.WriteLine("---------------------------------------------------------");
}
}
}
No es mucho pero es trabajo honesto
Esto va adentro de nuestra clase:
List<string> text = new List<string>();
text.Add(" Holaa, soy Facundo y estoy aprendiendo en platziiiiiiiiiiiiiiiiiiii ");
text.Add(" Ay no! Me equivoque y escribi mal el texto y con muchos espacios. ");
void PrintAll()
{
for (int i = 0; i < text.Count; i++)
{
Console.WriteLine(text[i]);
}
Console.WriteLine("--------------------");
}
//Estado inicial
PrintAll();
//Quito todos los espacios del inicio y final
for (int i = 0; i < text.Count; i++)
{
text[i] = text[i].Trim();
}
PrintAll();
//Quito todas las i sobrantes
text[0] = text[0].Remove(48);
PrintAll();
//Agrego un punto al final
text[0] = text[0].Insert(48, ".");
PrintAll();
//Como ya todo esta bien, puedo borrar el segundo elemento.
text.RemoveAt(1);
PrintAll();
//Voy agregar un poco mas de texto
text.Add("Me esta gustando programar cada vez mas, \nes inimaginable las puertas que me abre \ny muy interesante como con cada pieza de codigo que \nescribo me surge otra idea llena de vida que quiero implementar \ny termina volviendo un reto que me \nhace sentir la necesidad de tener que superarlo");
PrintAll();
//Convierto mi primer elemento en un array de strings
char[] chars = text[0].ToCharArray();
Console.WriteLine("------Inicio cuenta letras------");
foreach (char item in chars)
{
Console.WriteLine(item);
}
Console.WriteLine("------Fin------");
//Y ahora voy a ponerme un poco locochon, voy a splitear las cosas que empiecen con a ver que diantres me devuelve
string[] split = text[1].Split(new char[] {'a'});
foreach (string item in split)
{
Console.WriteLine(item);
}
//Quedé conforme con el texto endemoniado ese que me salio.
Si bien el programa este no tiene mucho sentido, cumple con el reto y la implementación de 5 métodos.
using System;
namespace SplitExample
{
internal class Program
{
static void Main(string[] args)
{
#region Grupo_de_Personas
Console.WriteLine("--------- Grupo_de_Personas -----------\n\n");
Console.WriteLine("Ingrese los nombres de las personas separadas por una '/' \n");
string personas = Console.ReadLine();
string[] personasArchivadas = personas.Split(new char[] { '/' });//Separa a las personas seguna la separacion de la barra
Console.WriteLine("");
for (int i = 0; i < personasArchivadas.Length; i++)
{
Random random = new Random();
int dinero = random.Next(0, 10000);
int numeroPersona = i + 1; //Esto es para que no haya una persona numero 0.
Console.WriteLine("Persona numero " + numeroPersona + ": " + personasArchivadas[i].Trim().ToUpper().Insert(0,"Argentinx ") + " tiene $" + dinero);
}
#endregion Grupo_de_Personas
}
}
}
using System;
namespace JugandoMetodosString
{
internal class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
string textoPurebas = "Hello World!";
string clonandoTexto = textoPurebas.Clone().ToString();
Console.WriteLine(clonandoTexto);
int comparandoTexto = clonandoTexto.CompareTo(textoPurebas);
Console.WriteLine(comparandoTexto);
bool contenidoTexto = textoPurebas.Contains("!");
Console.WriteLine(contenidoTexto);
bool finalizaConTeto = textoPurebas.EndsWith("d");
Console.WriteLine(finalizaConTeto);
bool empiezaConTexto = textoPurebas.StartsWith("e");
Console.WriteLine(empiezaConTexto);
bool igualdadTexto = textoPurebas.Equals(clonandoTexto);
Console.WriteLine(igualdadTexto);
string remplazoTexto = textoPurebas.Replace("World", "Universe");
Console.WriteLine(remplazoTexto);
string[] splitTexto = textoPurebas.Split(new char[] { 'e' });
for (int i = 0; i < splitTexto.Length; i++)
{
Console.WriteLine(splitTexto[i]);
}
}
}
}
Console.WriteLine("Hello, DBZ World!\n");
string ClassTopic = "Métodos de strings";
string School = "DBZ School";
Console.WriteLine("Estoy aprendiendo de " + ClassTopic + " en " + School + ".");
Console.WriteLine("\nHello, DBZ World! Clone\n");
string SchoolClone = School.Clone().ToString();
Console.WriteLine(SchoolClone);
Console.WriteLine("\nHello, DBZ World! Compare\n");
Console.WriteLine(ClassTopic.CompareTo(School));
Console.WriteLine(School.CompareTo(SchoolClone));
Console.WriteLine("\nHello, DBZ World! Contains\n");
Console.WriteLine(School.Contains("DBZ"));
Console.WriteLine("\nHello, DBZ World! End With\n");
Console.WriteLine(School.EndsWith("ool"));
Console.WriteLine("\nHello, DBZ World! Start With\n");
Console.WriteLine(School.StartsWith("DBZ"));
Console.WriteLine("\nHello, DBZ World! Equal\n");
Console.WriteLine(School.Equals(SchoolClone));
Console.WriteLine("\nHello, DBZ World! Index Of\n");
Console.WriteLine(School.IndexOf("a"));
Console.WriteLine("\nHello, DBZ World! Lower and Upper\n");
Console.WriteLine(ClassTopic.ToLower());
Console.WriteLine(ClassTopic.ToUpper());
Console.WriteLine("\nHello, DBZ World! Insert\n");
Console.WriteLine(School.Insert(4 , "Repasando Ando "));
Console.WriteLine("\nHello, DBZ World! Last index\n");
Console.WriteLine(ClassTopic.LastIndexOf("s"));
Console.WriteLine("\nHello, DBZ World! Remove\n");
Console.WriteLine(ClassTopic.Remove(6));
Console.WriteLine("\nHello, DBZ World! Replace\n");
Console.WriteLine(ClassTopic.Replace("s", "z"));
Console.WriteLine("\nHello, DBZ World! Split\n");
string[] split = ClassTopic.Split(new char[] { 's' });
Console.WriteLine(split[0]);
Console.WriteLine(split[1]);
Console.WriteLine(split[2]);
Console.WriteLine("\nHello, DBZ World! Substring\n");
Console.WriteLine(ClassTopic.Substring(2, 10));
Console.WriteLine("\nHello, DBZ World! To Array\n");
School.ToCharArray();
Console.WriteLine("\nHello, DBZ World! Trim\n");
string TextWithSpaces = " hola, había espacios al principio y al final ";
Console.WriteLine(TextWithSpaces.Trim());
Mi reto:
Verificar si una palabra o frase es un palindromo
void Palindrome(string word)
{
word = word.Trim();
word = word.ToLower();
word = word.Replace(" ", "");
string wordReverse="";
for (int i = word.Length-1;i>=0; i--)
{
wordReverse += word[i];
}
if (wordReverse == word)
{
Console.WriteLine("Is a palindrome");
}
else
{
Console.WriteLine("Not is a palindrome");
}
}
Palindrome("Luz azul");//True
//No admite tildes
Está un poco engorrosa la sintaxis de C# para uno que inicio con python xd
Metodos
> string Player = "Paladin";
string City = "Cazordon";
Console.WriteLine("Your election player was " + Player + " in " + City);
//Method #1
Console.WriteLine(Player.CompareTo(City));
//Method #2
Console.WriteLine(Player.Contains("lad"));
//Method #3
Console.WriteLine(City.IndexOf("o"));
//Method #4
Console.WriteLine(City.LastIndexOf("o"));
//Method #5
Console.WriteLine(City.ToUpper());
Console.WriteLine(City.ToLower());
Aporte de código…
Estuvo muy interesante el ejercicio:
Console.WriteLine("Hello, World!");
Console.WriteLine("Manejo de Métodos comunes...\n");
string val1 = "string, predeterminado";
string val2 = "string";
Console.WriteLine("\n *** Clone *** \n");
string clone = val1.Clone() + " clonado";
Console.WriteLine(" string clonado:\t " + clone);
Console.WriteLine("\n *** Compare *** \n");
var result = val2.CompareTo(val1);
Console.WriteLine(" Comparación:\t " + result);
Console.WriteLine("\n *** Contains *** \n");
var result1 = val1.Contains("ing");
Console.WriteLine(" Contains:\t " + result1);
Console.WriteLine("\n *** EndWith *** \n");
var result2 = val2.EndsWith("ing");
Console.WriteLine(" EndsWith:\t " + result2);
Console.WriteLine("\n *** StartsWith *** \n");
var result3 = val2.StartsWith("ing");
Console.WriteLine(" StartsWith:\t " + result3);
Console.WriteLine("\n *** Equals *** \n");
var result4 = val1.Equals(val2);
Console.WriteLine(" Equals:\t " + result4);
Console.WriteLine("\n *** IndexOf *** \n");
var result5 = val1.IndexOf("i");
Console.WriteLine(" IndexOf:\t " + result5);
Console.WriteLine("\n *** ToLower *** \n");
Console.WriteLine(" ToLower:\t " + val2.ToLower());
Console.WriteLine("\n *** ToUpper *** \n");
Console.WriteLine(" ToUpper:\t " + val1.ToUpper());
Console.WriteLine("\n *** Insert *** \n");
Console.WriteLine(" Insert:\t " + val2.Insert(0, "Nuevo ingreso - "));
Console.WriteLine("\n *** LastIndexOf *** \n");
Console.WriteLine(" LastIndexOf:\t " + val1.LastIndexOf("r"));
Console.WriteLine("\n *** Remove *** \n");
Console.WriteLine(" Remove:\t " + val1.Remove(3));
Console.WriteLine("\n *** Replace *** \n");
Console.WriteLine(" Replace:\t " + val1.Replace("r", "j"));
Console.WriteLine("\n *** Split *** \n");
var result6 = val1.Split("r");
Console.WriteLine(" Split:\t "+ result6.Length + "\n");
for (int i = 0; i < result6.Length; i++)
{
Console.WriteLine(result6[i]);
}
Console.WriteLine("\n *** SubString *** \n");
Console.WriteLine(" SubString:\t " + val1.Substring(2,2));
Console.WriteLine("\n *** ToArray *** \n");
var result7 = val2.ToArray();
Console.WriteLine(" ToArray:\t " + result7.Length);
for (int i = 0; i < result7.Length; i++)
{
Console.WriteLine(result7[i]);
}
Console.WriteLine("\n *** Trim *** \n");
Console.WriteLine(" Trim:\t " + val1.Trim());
Aquí esta mi ejercicio espero en la otra clase aprender más sobre el método
split
Que no me quedo muy claro su propósito.
<// See https://aka.ms/new-console-template for more information
Console.WriteLine("Metodos de string");
string classTopic = "Juan Manuel Taborda Ortiz";
string School = "Platzi";
Console.WriteLine("Estoy aprendiendo de" + classTopic + "en" + School + ".");
//Clone Method
string SchoolClone = School.Clone().ToString();
Console.WriteLine(SchoolClone);
//Method CompareTo
Console.WriteLine(classTopic.CompareTo(School));
Console.WriteLine(School.CompareTo(SchoolClone));
//Method Contains
Console.WriteLine(School.Contains("Pla"));
Console.WriteLine(classTopic.Contains("Manuel"));
//Method EndsWith
Console.WriteLine(School.EndsWith("zi"));
Console.WriteLine(classTopic.EndsWith("iz"));
//Method StartsWith
Console.WriteLine(School.StartsWith("Pl"));
Console.WriteLine(classTopic.StartsWith("Juan"));
//Method Equals
Console.WriteLine(School.Equals("SchoolClone"));
//Method Split
string[] split = School.Split(new char[] {'s'});
Console.WriteLine(split[0]);
Console.WriteLine(split[1]);
Console.WriteLine(split[2]);
>
Podemos hacer una lista de artículos separando por comas, esto hace que se guarde cada uno de los artículos en un arreglo.
string listaArticulos = "manzanas,avena,yogurt,platanos";
string[] split = listaArticulos.Split(new char[] { ',' });
for (int i = 0; i < split.Length; i++)
{
Console.WriteLine(split[i]);
}
Podemos usar el .Split para leer un .txt indicándole que separe por el caracter que le indiquemos.
Convierte el string en un arreglo de caracteres.
string School = "Platzi";
char[] letras = School.ToCharArray();
for (int i = 0; i < letras.Length; i++)
{
Console.WriteLine(letras[i]);
}
string classTopic = "Métodos de strings";
string[] split = classTopic.Split(new char[] {'s'}); // Split elimina la letra por la cual se partió el string
for (int i = 0; i < split.Length; i++)
{
Console.WriteLine(split[i]); // puede verse el ejemplo aquí
}
Console.WriteLine(classTopic.Substring(0, 7));
char[] chars = classTopic.ToCharArray();
for (int i = 0;i < chars.Length; i++)
{
Console.WriteLine(chars[i]);
}
string pruebaEspacios = " En este string tenemos espacios al inicio y al final ";
Console.WriteLine(pruebaEspacios);
Console.WriteLine(pruebaEspacios.Trim());
Reto cumplido:
using System;
namespace StringMethods
{
internal class Program
{
static void Main(string[] args)
{
string Pizzeria = "Manew Pizzeria";
string OrderedPizza = "Margarita";
Console.WriteLine("I am in " + Pizzeria.ToUpper() + " and I will order a " + OrderedPizza.Replace("Margarita", "Pepperoni") + " pizza");
Console.WriteLine();
Console.WriteLine(Pizzeria.Contains("new Pi"));
Console.WriteLine();
string[] split = Pizzeria.Split(new char[] { 'e' });
Console.WriteLine(split[0]);
Console.WriteLine(split[1]);
Console.WriteLine(split[2]);
Console.WriteLine();
Console.WriteLine(OrderedPizza.Remove(5));
}
}
}
Hola, comparto mis 5 metodos, en un ejercicio con un nombre completo:
String nameAll = "Juan,Daniel,Ramirez,Coroy";
string[] split = nameAll.Split(new char[] { ',' });
Console.WriteLine("Metodo split");
Console.WriteLine(split[0]);
Console.WriteLine(split[1]);
Console.WriteLine(split[2]);
Console.WriteLine(split[3] + "\n");
Console.WriteLine("Metodo subString");
Console.WriteLine(nameAll.Substring(2, 10));
Console.WriteLine("Metodo trim");
String nameWithSpace = " Juan Daniel Ramirez Coroy ";
Console.WriteLine(nameWithSpace.Trim() + "\n");
Console.WriteLine("Metodo remove");
String onlyNames = nameAll.Remove(11);
Console.WriteLine(onlyNames + "\n");
Console.WriteLine("Metodo ToUpper");
Console.WriteLine(nameWithSpace.ToUpper());
Console.ReadLine();
Esto hice yo, una lista de bandas
using System;
namespace StringMethods
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Rock and Metal bands list");
string[] BandLists = { "mayhem", "iron MaidEN", "AmON AMARTH", "BaTHORY", "Scorpions", "JUDAS PRIEST", "PINK FLOYD", "megadeth", "transMetal", "helloween" };
int Counter;
char PrevChar = '\0';
foreach (string Band in BandLists)
{
Counter = 0;
foreach (char BandPart in Band)
{
if (Counter == 0 || PrevChar == ' ')
Console.Write(char.ToUpper(BandPart));
else
Console.Write(char.ToLower(BandPart));
Counter++;
PrevChar = BandPart;
}
Console.WriteLine(" ");
}
}
}
}
Hola! voy a dejar los metodos que me parecieron mas interesantes!
/*Reto Platzisero*/
Console.WriteLine("\nEsto es parte del Reto de Platzi!\n");
//toma las variables de un string y las concatena
Console.WriteLine("Método string.Concat() ");
string phrase1 = "Estoy concatenando ";
string phrase2 = "con un metodo ";
string phrase3 = "que brinda C#!";
string phrase4 = " ''Este texto fue añadido por un argumento del metodo Join. ''";
string[] phrases = { phrase1, phrase2, phrase3, phrase4 };
Console.WriteLine(string.Concat(phrases[0], phrases[1], phrases[2]));
Console.WriteLine("Método string.Join() ");
//agrega el primer parametro, dentro del arreglo pasado por el segundo, entre las posiciones pasadas en el 3 y 4 parametro
string newPhrase = string.Join(phrase4, phrases, 1, 2);
Console.WriteLine(string.Concat(phrases[0], newPhrase));
Console.WriteLine("Método string.ToCharArray() ");
//toma una string y la convierte en un array de chars
string toCharMetod = "Esto es lo que hace un ToCharArray()";
char[] charArray = toCharMetod.ToCharArray();
for (int l = 0; l < toCharMetod.Length; l++)
{
Console.WriteLine(toCharMetod[l]);
}
Console.WriteLine("Asi es como se ve el array, recorrido a travez de un ciclo for");
//Otro metodo para "copiar" un string
string str1 = "n95";
string str2 = "n96";
Console.WriteLine("las lineas Originales son: {0}, {1}.", str1, str2);
Console.WriteLine("son iguales? {0} ", string.Equals(str1, str2));
Console.WriteLine("vamos a copiarlas con el metodo ToString();");
str2 = str1.ToString();
Console.WriteLine("las lineas despues de copiarlas son: {0}, {1}.", str1, str2);
Console.WriteLine("ahora son iguales? {0} ", string.Equals(str1, str2));
//rellena un string con el argumento especificado por parametro, añadiendo todos los caracteres necesarios hasta llegar al indicado en el argumento.
char paddingChar = 'a';
string phrase5 = "todo esto aprendi en Platzi!";
Console.WriteLine(phrase5.PadLeft(50,paddingChar));
Console.WriteLine(phrase5.PadRight(60, paddingChar));
Este es el Output:
using System;
namespace Challenge
{
internal class Program
{
static void Main(string[] args)
{
string rights = " ©2021 Developed by Maxcodev ";
Console.WriteLine(rights.Trim().ToUpper() + "\nWelcome to Easy Sumatory\nNow please type the first number, you can use decimal with dot or comma (Example: 2,5)");
float a = float.Parse(Console.ReadLine());
Console.WriteLine("Now type the second Number");
float b = float.Parse(Console.ReadLine());
float result = a + b;
Console.WriteLine("The result is: " + result);
Console.WriteLine(result.ToString() + " es el resultado");
}
}
}
Reto
Console.WriteLine("\nVerifiquemos si la palabra introducida es un palíndromo");
string text = Console.ReadLine();
//Pasamos a minúsculas
text = text.ToLower();
//Quitamos espacios no deseados
text = text.Trim();
text = text.Replace(" ","");
// Clonamos el texto
string auxText = text.Clone().ToString();
//Pasamos el texto a un Array de caracteres
char[] textArray = text.ToCharArray();
// Invertimos el orden de los caracteres
textArray = text.Reverse().ToArray();
// Unimos el Array de caracteres en una String sin espacios
auxText = String.Join("", textArray);
// Verificamos si es un palíndromo e imprimimos el resultado
Console.WriteLine("¿El texto es un palíndromo?: " + (auxText == text));
Ok 😕 No hay lectura, ¿Qué procede?
Mi solución usando Contains, Indexof, Substring, Split y ToUpper.
string url = "https://www.google.com/search?q=Quiero+aprender+a+disenar+juegos";
int indix=0;
if(url.Contains("https://www.google.com/"))
{ indix =url.IndexOf("=");}
url = url.Substring(indix+1);
string[] part = url.Split('+');
string message = "The Message is: ";
for (int i = 0;i < part.Length; i++)
{
message = message + part[i] +" ";
message = message.ToUpper();
};
Console.WriteLine(message);
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?