Entrada y salida de datos

Se llama placeholder o marcador de posición, a una etiqueta que le dice al compilador que información debería aparecer en ese espacio. Son usados para presentar en pantalla el contenido de una variable (según su tipo de dato y formato deseado).

Adicionalmente, existe una propiedad de los placeholders llamada truncamiento, la cual permite definir la cantidad de digitos presentados

pienso que este curso de programación estructurada debió ser el primer curso en empezar en la programación siento que ya voy por el lado correcto.

Cuado en un programa se leen por teclado datos numéricos y datos de tipo carácter o String debemos tener en cuenta que al introducir los datos y pulsar intro estamos también introduciendo en el buffer de entrada el intro. por tal razon al no colocar el espacio se ve de la siguiente manera:

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

int main()
{
    int x,y,aux;

    printf("Ingrese el valor de X:");
    scanf("%i", &x);
    printf("Ingrese valor de Y:");
    scanf("%i", &y);

    aux = x;
    x = y;
    y = aux;

    printf("El valor intercambiado de X es: %i\n", x);
    printf("El valor intercambiado de Y es: %i\n    ", y);

    return 0;
}```

No veo necesario usar una variable auxiliar para poder invertir los valores:

#include <stdio.h>

int main()
{
int x;
int y;
int z;

printf("Ingresa un valor entero para X: \n");
scanf("%i", &x);
printf("Ingresa un valor entero para Y; \n");
scanf("%i", &y);



printf("Valores intercambiados:\n");
printf("El valor de x=%i\n",y);
printf ("El valor de y=%i\n",x);

return 0;

}

Hola una duda ¿a qué te refieres conlimpiar el buffer?, ¿Por qué ocurre o cuando pasa?. Gracias!

Apuntes de la clase:
En un programa, los datos de entrada son los que la computadora va a procesar. Los datos de salida son datos derivados, es decir, obtenidos a partir de los datos de entrada. Por esta razón, a los datos de salida se les considera más significativos que a los datos de entrada. Ambos tipos de datos son información (textos, imágenes, sonidos, videos, …) que maneja la computadora. Sin embargo, en un sentido más filosófico, a los datos de entrada se les considera la materia prima de los datos de salida, considerados estos como la verdadera información.

🐱‍💻 Solución al reto en lenguaje Dart.

import 'dart:io';

void main(List<String> arguments) {
  var x;
  var y;
  var z;

  print('Ingrese número x:');
  x = stdin.readLineSync();
  print('Ingrese número y:');
  y = stdin.readLineSync();

  z = x;
  x = y;
  y = z;

  print('Valor actual de x: $x');
  print('Valor actual de y: $y');
}

RETO CUMPLIDO!!
Creo que la profesora debería de explicar mejor los ejercicios, por ejemplo ella dijo dale dos valores a X y a Y pero no dijo pidele los valores al usuario y la mayoría de la personas hicieron un scanf otra cosa, dice usa una variable auxiliar(ni la use, no entendi para que utilizarla) pero este programa requeria mas de una variable auxiliar, para hacer los cambios de los valores, realmente se pudo hacer dos variable e invertir los valores directamente en el printf osea enteroX meterlo en "el resultado de y es: ", enteroX.

Pero igual reto cumplido, Ademas que le agregue que sume los valores y lo reste, creo que eso es lo bueno de haber tocado código antes que sabes más o menos como funciona!!

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

int main() {
    // insert code here...
    int enteroX;
    int enteroY;
    
    printf("Introduce el valor de X: ");
    scanf("%i", &enteroX);
    
    printf("Introduce el valor de Y: ");
    scanf("%i", &enteroY);
    
    //Invertir valores
    int xFinal = enteroY;
    int yFnal = enteroX;
    
    printf("El valor de X es: %i \n", xFinal);
    printf("El valor de Y es: %i \n", yFnal);
    
    //suma y resta
    int suma = xFinal + yFnal;
    int resta = xFinal - yFnal;
    
    printf("La suma de X + Y es: %i \n", suma);
    printf("La resta de X - Y es: %i \n", resta);
    return 0;
}

Las entradas (inputs) son todas aquellas piezas de Hardware que nos permiten comunicarnos efectivamente con el computador.
Mientras, que las salidas (outputs) son las partes donde el computador nos responde después de haber recibido información, como la pantalla o las bocinas de audio, a veces las salidas también pueden suceder en archivos de nuestro disco duro.

Alt + 92 = \

#include <iostream>

using namespace std;

int main()
{
    cout << "Introducción a variables y tipos de datos" << endl;
    
    int integerA;
    float floatA;
    char favoriteLetter;
    
    cout << "Ingresa un número entero: " << endl;
    cin >> integerA;
    cout << "Ingresa un número con decimales: " << endl;
    cin >> floatA;
    cout << "Ingresa tu letra favorita: " << endl;
    cin >> favoriteLetter;

    cout << "El número entero que ingresaste es: " << integerA << endl;
    cout << "El número con decimales que ingresaste es: " << floatA << endl;
    cout << "Tu letra favorita es: " << favoriteLetter << endl;

    return 0;
}

![](

mi respuesta al reto ❤️

#include <stdio.h>

int main(){

int x,y,z;

printf("ingresa el valor de x\n");
scanf("%i",&x);

printf("ingresa el valor de y\n");
scanf("%i",&y);

z=y;
y=x;
x=z;

printf("el valor de x es: %d\n",x);
printf("el valor de y es: %d\n",y);

return 0;

}

El resultado del reto me quedo así

#include <stdio.h>

int main () {
  int v1,v2,aux;

  printf("Ingresa el valor de la variable 1: \n");
  scanf("%i", &v1);
  
  printf("Ingresa el valor de la variable 2: \n");
  scanf(" %i", &v2);

  aux = v1;
  v1 = v2;
  
  //en la siguiente linea estamos imprimiendo integerA
  printf("El valor de la variable 1 es: %i \n", v1);
  printf("El valor de la variable 2 es: %i \n", aux);
  
  return 0;
}

Este curso está muy bueno, por que explica todos los detalles que en los otros se pasaron por alto y el ritmo de la profe es tan acorde que me esta sentando super bien.

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

int main(){
int x;
int y;
int b;
printf("Da el valor de x: ");
scanf("%i",&x);
printf("Da el valor de y: ");
scanf("%i",&y);
b=x;
x=y;
y=b;
printf("El valor intercambiado del entero x es: %i \n",x);
printf("El valor intercambiado del entero y es: %i \n",y);

return 0;
}

Entrada y salida de datos.

Los inputs o entradas son la información que le suministramos al computador y que puede usar nuestro programa esta llega a través de un medio como el teclado, mouse, microfono, tableta graficadora, touch, botones (en los celulares), scanner,lector de codigos de barra, puerto Ethernet, puerto usb

Los outputs o salidas es la información que se genera desde el programa o computadora y se muestra al usuario atraves de alguno de sus dispositivos de salida, siendo la más común la pantalla tambien hay muchos otros como impresora o parlantes etc.

printf(); es una función de la <stdio.h> (standar input output) que podemos usar para mostrar por pantalla

        int integerA = 123;
        float floatB = 12.3;
        double doubleA = 1.234;
        char letterA = 'A';
        //printf("mensaje %letraDeDato \n(saltoLinea)", nombreVarible);

        printf("El valor de integerA es : %i \n", integerA);
        printf("La variable float vale %f \n",floatB);
        printf("Los valores double usan f para escribir y lf para leer %f \n , doubleA");
        printf("El caracter dentro de la variable es: %c \n",letterA);

Cuando cambiamos los valores en las variables ejecutamos buil and run imprimira los nuevos valores en dichas variables

para imprimir en una sola linea el mensaje debe contener los especificadores o placeholders de las variables donde se imprimiran y al final las variables en el mismo orden que se indicaron.

printf("Mensaje %i, mensaje2 %f, mensaje3 %f \n",integerA,floatB,doubleA);

Podriamos poner los saltos de linea en la misma sentencia

printf("\n Mensaje %i, \n\n mensaje2 %f ,\n\n mensaje3 %f \n",integerA,floatB,doubleA);

La función que usamos es scanf();

    //scanf("%Tdato", &variable);

     printf("Digite el valor de la variable \n");
     scanf("%i", &integerA);
     printf("El valor ingresado es: %i \n",integerA);

El caracter & (andpersand) funciona como apuntador a la variable que le asignamos el valor.

_ para ingresar un tipo char en el placehoder dejamos un espacio para limpiar el buffer ya que el programa guarda las entradas como el enter
Cuado en un programa se leen por teclado datos numéricos y datos de tipo carácter o String debemos tener en cuenta que al introducir los datos y pulsar intro estamos también introduciendo en el buffer de entrada el intro. por tal razon al no colocar el espacio se ve de la siguiente manera

    char letterA ;
    printf("Digite el valor de la variable char \n");

   // aca el espacio antes del placeholder
    scanf(" %c", &letterA);

    printf("El valor char es: %c",letterA);

El mìo quedo asì:

**int main()
{
int var1, var2,aux;

printf("Ingresa el valor para la Variable 1: \n");
scanf("%i",&var1);
printf("Ingresa el valor para la Variable 2: \n");
scanf("%i",&var2);
printf("Le has asignado el valor de %i a la Variable 1 y %i a la Variable 2.\n",var1,var2);
aux=var1;
var1=var2;
var2=aux;

printf("En el intercambio quedo de la siguiente manera:\n");
printf("El valor de Variable 1 ahora es %i.\n",var1);
printf("El valor de Variable 2 ahora es %i.\n",var2);
return 0;

}
**

#include <stdio.h>
#include <stdlib.h>

/** Reto1 curso programacion estructurada platzi.
*   Se requiere recibir dos valores, mostrarlos en pantalla y luego
*   intercambiarlos.
*/

int x;
int y;
int z;

int main()
{
    printf("Ingrese el valor de x: \n\n", x);
    scanf("%i", &x);

    printf("Ingrese el valor de y: \n\n", y);
    scanf("%i", &y);

    printf("El valor de X es: %i \n", x);
    printf("El valor de Y es: %i \n\n", y);

    int z = x;
    int x = y;
    int y = z;

    printf("El valor intercambiado de X es: %i \n", x);
    printf("El valor intercambiado de Y es: %i \n", y);

    return 0;
}

Ejercicio en PYTHON…

<
if __name__ == "__main__":
    interA = int
    interB = int
    aux = int

    interA = int(input("Ingrese un valor entero \n"))
    interB  = int(input("Ingrese un segundo valor entero \n"))

    aux = interA
    interA = interB
    interB = aux

    print("Los valores ha sido cambiados \n")
    print(interA)
    print(interB)>
>

Reto Cumplido 😄 :

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int integerA;
    int integerB;
    int aux;

    printf("Ingrese un valor entero: \n");
    scanf("%i", &integerA);
    printf("Ingrese un valor entero: \n");
    scanf("%i", &integerB);

    aux = integerA;
    integerA = integerB;
    integerB = aux;

    printf("Los valores han sido cambiados");
    printf("\n %i", integerA);
    printf("\n %i", integerB);
    printf("\n");
    

    return 0;
}```

RETO:

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

int main(void) {
  int integerA;
  int integerB;

printf("HOLA COMUNIDAD PLATZI, AQUI HAREMOS UN TRUCO DE MAGIA... SOLO SIGUE MIS INSTRUCCIONES \n");

printf("Ingresa el valor del entero A: ");
scanf("%i", &integerA);

printf("Ingresa el valor del entero B: ");
scanf("%i", &integerB);

int removedor = integerB;
int intergerB = integerA;

printf("A ya no es A, ahora A es: %i \n", removedor);
printf("B ya no es B, ahora B es: %i \n", integerA);

printf("Que te pareció? Dale Like, yo sé que te gustó");

  return 0;
}

reto 😃

Reto cumplido!

Que genial se siente uno haciendo estos retos, bueno en realidad es el primero de este curso pero fue genial jajajajaja dejo por acá el código del reto n°1…

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int wholeNumberA;
    int wholeNumberB;

    printf("Ingresa tu primer valor entero, que denominaremos como A: ");
    scanf("%i", &wholeNumberA);
    printf("Ingresa tu segundo valor entero, que denominaremos como B: ");
    scanf("%i", &wholeNumberB);
    printf("El valor intercambiado de A es: %i \n", wholeNumberB);
    printf("El valor intercambiado de B es: %i \n", wholeNumberA);

    return 0;
}```

Ingresa tu primer valor entero, que denominaremos como A: 72
Ingresa tu segundo valor entero, que denominaremos como B: 98
El valor intercambiado de A es: 98
El valor intercambiado de B es: 72

Process returned 0 (0x0) execution time : 5.983 s
Press any key to continue.```

![](

#include <stdio.h>
#include <stdlib.h>

int main()
{
    char primera = 'a';
    char segunda = 'b';
    printf("Primera variable: %c \n",primera);
    printf("Segunda variable: %c \n", segunda);

    char bandera;
    bandera = primera;
    primera= segunda;
    segunda = bandera;
    printf("....Si las intercambiamos y querdaria .......\n");
    printf("Primera variable: %c \n",primera);
    printf("Segunda variable: %c \n ", segunda);
}```

sin el espacio en el C me arrojaba error

Para los que les imprima directamente el %c y no les pregunte por el caracter deben escribir:
" %c"
Con un espacio antes del %.
¿Por qué?
Ni idea, pero funciona jajaja.

Ahí está

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h> //librería para usar bool

int main()
{
    int integerX;
    int integerY;

    printf("Da el valor de x: ");
    scanf("%i", &integerX);

    printf("Da el valor de y: ");
    scanf("%i", &integerY);

    printf("El valor intercambiado del entero x es: %i \n", integerY);
    printf("El valor intercambiado del entero y es: %i \n", integerX);

    return 0;
}

😃

#include <stdio.h>

using namespace std;

int main()
{
    
    int varIntA, varIntB, varIntAux;
    
    printf("Hi!!\nWrite an integer number please: ");
    scanf("%i", &varIntA);

    printf("Thanks!\nNow write another integer number: ");
    scanf("%i", &varIntB);

    printf("Your values were %i y %i\n", varIntA, varIntB);

    varIntAux=varIntB;
    varIntB=varIntA;
    varIntA=varIntAux;

    printf("But now, the values have been exchanged to %i y %i\nTa daa!!\nThanks for playing.\n", varIntA, varIntB);
    


    return 0;
}```

#include <stdio.h>
#include <stdlib.h>

int main()
{
int edad;
char segundo;

printf("ingresa tu edad: ");
scanf (" %i", &edad);

printf("ingresa la inicial de tu nombre: ");
scanf (" %c", &segundo);

printf ("tu edad es : %i \n", edad);
printf ("tu inicial es : %c", segundo);

}

RETO

#include <iostream>

using namespace std;

int main()
{
    int x, y;

    cout << "Ingresa el valor de x: " << endl;
    cin >> x;
    cout << "Ingresa el valor de y: " << endl;
    cin >> y;

    cout << "El valor de x es: " << x << endl;
    cout << "El valor de y es: " << y <<endl;
    cout << "El valor intercambiado de x es: " << y << endl;
    cout << "El valor intercambiado de y es: " << x << endl; 

    return 0;
}

![](

Solución al reto 1:

#include<stdio.h>
#include<stdlib.h>

int main(){
int intX, intY, intAux;

printf("Digite un numero entero para x: ");
scanf("%i", &intX);
printf("\nDigite un numero entero para y: ");
scanf(" %i", &intY);

intAux = intX;
intX = intY;
intY = intAux;

printf("\nEl valor intercambiado de x = %i", intX);
printf("\nEl valor intercambiado de y = %i", intY);
printf("\n");

system("pause");
return 0;

}

Solución del reto:

    //Crear dos variables
    float x;
    float y;

    //Ingresar y guardar su valor
    printf("Ingresa el valor de x: ");
    scanf("%f", &x);

    printf("Ingresa el valor de y: ");
    scanf("%f", &y);

    //Intercambiar el valor de ambas con la ayuda de
    //una variable auxiliar
    float aux = x;
    x = y;
    y = aux;

    //Imprimir el valor de las variables intercambiadas
    printf("El valor de x intercambiado es: %f \n", x);
    printf("El valor de y intercambiado es: %f", y);

Reto-1

#include <stdio.h>
#include <stdbool.h>

int main(void) {
  int varX; 
  int varY;
  int aux;

  printf("Da el valor de X: ");
  scanf("%i", &varX);

  printf("Da el valor de Y: ");
  scanf("%i", &varY);

  aux = varY;
  varY = varX;
  varX = aux;

  printf("El valor intercambiado del entero X es: %i \n", varX);
  printf("El valor intercambiado del entero Y es: %i \n", varY);
}

Aquí mi solución, espero les sirva

#include <stdio.h>
#include <stdlib.h>


int main()
{
    int variableA;
    int variableB;
    int auxA;

    printf("Ingresa el valor de A: ");
    scanf(" %i",&variableA);

    printf("Ingresa el valor de B: ");
    scanf(" %i",&variableB);

    auxA = variableA;
    variableA = variableB;
    variableB = auxA;

    printf("El valor de mi variable A es: %i \n", variableA);
    printf("El valor de mi variable B es: %i \n", variableB);


    return 0;
}

Reto

#include <stdio.h>
#include <stdlib.h>

/*
    RETO
    * Crea dos variables.
    * Ingresa y guarda el valor de ambas variables.
    * Intercambia el valor de las variables con ayuda de una variable auxiliar.
    * Imprime el valor de las variables ya intercambiadas.
*/

int main() {
    int variable1;
    int variable2;
    int variableAuxiliar;

    printf("Ingresa el valor de la variable 1: ");
    scanf("%i", &variable1);
    printf("Ingresa el valor de la variable 2: ");
    scanf("%i", &variable2);

    variableAuxiliar = variable1;
    variable1 = variable2;
    variable2 = variableAuxiliar;

    printf("\nEl valor de la variable 1 es %i \n", variable1);
    printf("El valor de la variable 2 es %i \n", variable2);

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

int main()
{
int x;
int y;

printf("cual sera el valor de x : ");
scanf("%i", &x);

printf("cual sera el valor de y : ");
scanf("%i", &y);

printf("los valores intercambiados son:\n x: %i \n y: %i", y, x);
printf("\nlos valores en realidad son:\n x: %i \n y: %i", x, y);

return 0;

}

hoy aprendí que si se ponen comillas dobles al declarar en valor de una variable tipo char, no va a funcionar
se debe hacer con comillas simples,
las pueden hacer así, si no les aparece en el teclado
ALT + 39 = ’ ’

A los que no le funcionan Code Block al iniciar el codigo descarguen Mingw pueden descargarlo aqui: https://sourceforge.net/projects/mingw/files/

Instalan el archivo exe en su pc, Selecionan todas las casillas

Luego van a Code Block buscan apartado de Setting - Compiler, van al apartado de Toolchain executables y le dan Auto-detect y listo problema solucionado😉

El reto me quedo asi

<#include <stdio.h>
#include <stdlib.h>

int main()
{
    int d;
    int b;
    int c;

    printf("Ingrese el valor de d: ");

    scanf("%i", &d);

    printf("Ingrese el valor de b: ");

    scanf("%i", &b);

    c = d;

    d = b;

    b = c;

    printf("El valor de d es : %i \n El valor de b es %i ", d, b);


   return 0;
}> 

![]

()

Codigo:

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

int main(){
  
    int x;
    int y;
    int aux;

    printf("Enter value X: ");
    scanf("%i", &x);
    printf("Enter value Y: ");
    scanf("%i", &y);

    aux = x;
    x = y;
    y = aux;

    printf("X value: %d \n", x);
    printf("Y value: %d \n", y);
    return 0;
}

Listo, no estaba tan complejo.

Hola, dejo mi aporte con la solución, utilicé una variable auxiliar:

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

int main()
{
int x;
int y;
int z;

printf("Ingresa el valor de x: ");
scanf("%i", &x);

printf("Ingresa el valor de y: ");
scanf("%i", &y);

z=x;
x=y;
printf("El valor intercambiado del entero x es: %i \n", x);

y=z;
printf("El valor intercambiado del entero y es: %i \n", y);

return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main()
{

    //DECLARO LAS VARIABLES
    int X;
    int Y;
    int Z;

    // PIDO VALORES AL USUARIO Y LOS ASIGNO A LAS VARIABLES
    printf ("Ingresa un numero entero para X y pulsa ENTER: ");
    scanf ("%i", &X);

    printf ("Ingresa un numero entero para Y y pulsa ENTER: ");
    scanf ("%i", &Y);

    //INTERCAMBIO LOS VALORES DE X y Y USANDO Z COMO VARIABLE DE INTERCAMBIO
    Z=X;
    X=Y;
    Y=Z;

    //MUESTRO LOS NUEVOS VALORES
    printf ("El valor intercambiado de X es: %i \nEl valor intercambiado de Y es: %i", X, Y);

    return 0;
}

Reto:

#include <stdio.h>
#include <stdlib.h>

int main ()
    {
        int vx, vy, v1;
        //PETICION DE DATOS
        printf("Ingrese la variable X: \n");
        scanf("%i", &vx);
        printf("Ingrese la variable Y: \n");
        scanf("%i", &vy);
        //CAMBIO DE DATOS
        v1 = vx;
        vx = vy;
        vy = v1;
        //IMPRESION DE DATOS
        printf("El valor de X es %i \n", vx);
        printf("El valor de Y es %i \n", vy);
    }

Código del reto

int main()
{

int variable01;
int variable02;
int variable_auxiliar;

printf(“Digite el valor de la primera variable\n”);
scanf("%i",&variable01);
printf(“Digite el valor de la segunda variable\n”);
scanf("%i",&variable02);

variable_auxiliar = variable01;
variable01 = variable02;
variable02=variable_auxiliar;

printf(“El valor de variable01 es: %i \n”,variable01);
printf(“El valor de variable02 es: %i \n”,variable02);

return 0;
}

Esta es mi respuesta al reto 😃

#include <stdio.h>

int main()
{
    int primeraVar;
    int segundaVar;

    printf("Ingresar el valor de la primera variable: ");
    scanf("%i", &primeraVar);

    printf("Ingresar el valor de la segunda variable: ");
    scanf("%i", &segundaVar);

    int terceraVar = primeraVar;
    primeraVar = segundaVar;
    segundaVar = terceraVar;

    printf("El valor intercambiado de la primera variable es: %i\n", primeraVar);
    printf("El valor intercambiado de la segunda variable es: %i\n", segundaVar);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

int main(){

float n1, n2;
float auxiliar;

//ingresar un valor desde teclado los cuales seran cambiados de posicion
printf(“Ingresa el primer valor: \n”);
scanf("%f", &n1);

printf(“Ingresa el segundo valor: \n”);
scanf("%f", &n2);

printf("\n \n El primer valor es: %f", n1);
printf("\n El segund valor es: %f", n2);

printf("\n \n //Cambiando posicion de numeros// \n");

//Cambiando de posicion de los valores
auxiliar = n1;
n1=n2;
n2=auxiliar;

printf(" El nuevo valor del primer numero es : %f", n1);
printf("\n El nuevo valor del segundo valor es %f", n2);

getchar();


return 0;

}

Comparto mi solución del reto
😄

#include <stdio.h>

int main() {

  // Declarar las variables
  int x;
  int y;
  int z; // Variable auxiliar

  // Pedir el valor y asignarlo a su variable respectiva
  printf("Da el valor x: ");
  scanf("%i",&x);

  printf("Da el valor y: ");
  scanf("%i",&y);

  // Utilizar la variable auxiliar para intercambiar los valores
  z = x;
  x = y;
  y = z;

  // Imprimir
  printf("El valor intercambiado del entero x es: %i \nEl valor intercambiado del entero y es: %i \n", x, y );
  
  return 0;

Comparto mi código con el reto:
Utilice x,y,z; z se agrego para poder hacer el cambio entre “x” y “y”

#include <stdio.h>

main (){
	int x,y,z;
	
	printf ("Escribe el valor de x:\n");
	scanf ("%d",&x);
	printf ("Escribe el valor de y:\n");
	scanf ("%d",&y);
	
	printf ("El valor de x es:%d\n",x);
	printf ("El valor de y es:%d\n",y);
	
	z=x;
	x=y;
	y=z;
	printf ("El valor de x intercambiado es:%d\n",x);
	printf ("El valor de y intercambiado es:%d\n",y);
	
return 0;
}

Comparto el reto

int main()
{
    //Defino variables
    int x;
    int y;
    int z;//variable para el intercambio

    //Ingreso valores por teclado
    printf("Ingrese el valor de x:");
    scanf("%i",&x);

    printf("Ingrese el valor de y:");
    scanf("%i",&y);

    //Intercambio de valores
    z=x;
    x=y;
    y=z;

    //Imprimo el resultado en pantalla
    printf("El valor intercambiado de x es: %i,\n El valor intercambiado de y es: %i",x,y);



    return 0;
}

int main()
{
    int varA;
    int varB;
    int varC;

    // ENTRADA DE DATOS
    printf("Escribe el valor de X: ");
    scanf("%i", &varA);
    printf("Escribe el valor de Y: ");
    scanf("%i", &varB);

    // PROCESO
    varC = varA;
    varA = varB;
    varB = varC;

    // SALIDA DE DATOS
    printf("\nEl valor intercambiado de X es: %i", varA);
    printf("\nEl valor intercambiado de Y es: %i \n", varB);

    return 0;
}

<
char letrita, letraCap, otraletra;

printf("Ingresa una letra minuscula: ");
scanf(" %c", &letrita);
printf("Ingresa una letra MAYUSCULA: ");
scanf(" %c", &letraCap);

 otraletra = letraCap;
 letraCap = letrita;
 letrita = otraletra;

printf("El valor intercambiado de la letra minuscula es: %c\n", letrita);
printf("El valor intercambiado de la letra Mayuscula es: %c\n", letraCap);

return 0;
> 

Hola, saludos a la comunidad, realice el reto de la siguiente manera:

int main()
{
int integerX;
int integerY;

printf("Ingresa el valor de X: ");

    scanf("%i", &integerX);

printf("Ingresa el valor de Y: ");

    scanf("%i", &integerY);

printf("El valor de X es: %i \n", integerY);
printf("El valor de Y es: %i \n", integerX);

return 0;

}

Espero que sea de ayuda y si alguien lo puede mejorar, gracias de antemano.

Al inicio quise realizar el reto con lo que recordaba del curso, hasta el momento de ejecutarlo fue cuando aprendí más sobre mis errores.
Por ejemplo, olvide insertar & para guardar el valor que ingrese y agregar unas comas, creyendo que el problema era el compilador.
A lo que voy es que les recomiendo que lo intenten ustedes para aprender de sus errores, revisen de sus notar con detalle y al final, comprueben sus resultados con los códigos de otros.

Así fue como cumplí el reto:

#include <stdio.h>

int main(){
    int x;
    int y;
    int aux;
    
    printf("Ingrese el valor de x: ");
    scanf("%i", &x);
    printf("Ingrese el valor de y: ");
    scanf("%i", &y);

    aux = x;
    x = y;
    y = aux;

    
    printf("\nEl valor intercambiado de x es: %i\n", x);
    printf("El valor intercambiado de y es: %i\n", y);

    return 0;
}

Cumpliendo el reto de realizar un swap

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
    int i;
    int j;
    int aux;
    printf("introduce un numero:");
    scanf("%i", &i);
    printf("\n");
    printf("introduce otro numero:");
    scanf("%i", &j);
    printf("\n");
    printf("el valor de i es:%i \n", i);
    printf("el valor de j es:%i \n", j);
    printf("swap");
    //swap
    aux = i;
    i = j;
    j = aux;
    printf("el valor de i es:%i \n", i);
    printf("el valor de j es:%i \n", j);
    system("pause");
    return 0;
}

int main()
{
    int integerA, integerB, aux;
    
    printf("Ingresa el numero A: ");
    scanf("%i", &integerA);
    
    printf("Ingresa el numero B: ");
    scanf("%i", &integerB);
    
    aux = integerA;
    integerA = integerB;
    integerB = aux;
    
    printf("El valor intercambiado de A es: %i \n", integerA);
    printf("El valor intercambiado de B es: %i \n", integerB);

Primer reto del curso resuelto!

#include <stdio.h>
#include <stdlib.h>

/*
Primer Reto:
. Crea dos variables.
. Ingresa y guarda el valor de
  ambas variables.
. Intercambia el valor de las variables con ayuda de una
  variable auxiliar.
. Imprime el valor de las
  variables ya intercambiadas.
*/

int main()
{
    int IntegerX;
    int IntegerY;
    int aux;

    aux = IntegerX;
    IntegerX = IntegerY;
    IntegerY = aux;

    printf("Ingrese el valor de x: ");
    scanf("%i", &IntegerX);

    printf("Ingrese el valor de y: ");
    scanf("%i", &IntegerY);

    printf("El valor intercambiado del entero x es: %i \n", IntegerX);
    printf("El valor intercambiado del entero y es: %i", IntegerY);

    return 0;
}

Excelente clase, me recodo mucho la escuela.

Dejo el replit con el reto.
 
Un saludo y gracias.

![](

)

RETO: #include <stdio.h>
#include <stdlib.h>

int main()
{
int Integerx = 3;
int Integery = 5;

printf("El valor de la variable x es:%i\n",Integery);
printf("El valor de la variable x es:%i\n",Integerx);

}

Reto:

int main()
{
    int  X = 30;
    int Y = 170;

    printf("El valor de X es: %i \n", X);
    printf("El valor de Y es: %i \n", Y);

    printf("El valor intercambiado del entero X es : %i \n", Y);
    printf("El valor intercambiado del entero Y es : %i \n", X);


    return 0;
}

Asi es como lo resolvi que opinan.

#include <stdio.h>
#include <stdlib.h>

int main()
{
int x;
int y;
int iter;

printf("INTRODUCE EL VALOR DE X: ");
scanf("%i", & x);

printf("INTRODUCE EL VALOR DE Y: ");
scanf("%i", & y);

iter= x;
printf("El valor de y es: %i \n",iter);
iter= y;
printf("El valor de x es: %i \n",iter);

return 0;

}

Dejo el código del reto:

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int valorx = 3;
    int valory = 5;

    printf("Da el valor de x %i \n", valorx);
    printf("Da el valor de y %i \n", valory);

    printf("El valor intercambiado del entero x es %i \n", valory);
    printf("El valor intercambiado del entero y es %i \n", valorx);


    return 0;

Existe una amplia variedad de formatoscon printf, loscaracteres especiales a utilizar son:

 %d   imprime una variable int en formato decimal.

 %ld  imprime un long int en decimal.

 %c   imprime un caracter.

 %s   imprime una cadena de caracteres.

 %f   imprime un float o double.

 %e   igual que %f, pero utilizando notacion exponencial.

 %g   utiliza %f o %e dependiendo de cual es mas conveniente.

 %o   imprime un entero en octal.

 %x   imprime un entero en hexadecimal.

 %%   imprime el caracter %.

 \n   caracter de nueva linea, salta al siguiente renglón.

 \t   caracter tabulador, avanza hasta la siguiente columna de tabulación.

 \a   caracter de alarma, genera un sonido "beep" en la consola. 

resultado del ejercicio

Mi solución.

int main()
{

    // Forma de imprimir la variable recordar % y la primera letra del tipo de variable
    //printf("El valor de nuestro entero A es: %i \n", integerA );
    // Solicitar dato desde consola
    //scanf("%f", &floatA);

    int x;
    int y;
    int variableIntercambio;
    printf("El valor de x es: ");
    scanf("%i", &x);
    printf("El valor de y es: ");
    scanf("%i", &y);
    variableIntercambio=x;
    x=y;
    y=variableIntercambio;
    printf("El valor intercambiado de x es: %i\n", x);
    printf("El valor intercambiado de y es: %i", y);
    return 0;
}

Reto cumplido

#include <stdio.h>
#include <stdbool.h>

int main () {

    int variable1;
    int variable2;
    int auxiliar;

    printf("Ingresa el valor de la variable 1: ");

    scanf(" %i", &variable1);

    printf("Ingresa el valor de la variable 2: ");

    scanf(" %i", &variable2);

    auxiliar = variable1;
    variable1 = variable2;
    variable2 = auxiliar;

    printf("El valor intercambiado de la variable 1 es %i \n", variable1);
    printf("El valor intercambiado de la variable 2 es %i \n", variable2);

    return 0;
}

reto listo me agrada saber de estos retos me emocionan y de verdad me hacen querer aprender mas muy buena clase

#include <stdio.h>
#include <stdlib.h>

int main()
{
int primeraVariable;
int seguntaVariable;
int variableAuxiliar;

printf("ingresa el primer numero: ");
scanf("%i", & primeraVariable);
printf("ingresa el segundo numero: ");
scanf("%i", & seguntaVariable);

variableAuxiliar =primeraVariable;
primeraVariable = seguntaVariable;
seguntaVariable = variableAuxiliar;


printf("los datos al contrario son: \n");
printf("primer valor: %i", primeraVariable);
printf("\nsegundo valor: %i", seguntaVariable);
return 0;

}

A huevo!

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <stdbool.h>

int main() {
    
  int integerX;
  int integerY;

  printf("Da el valor de x: ");
  scanf("%i", &integerX);
 
  printf("Da el valor de y: ");
  scanf("%i", &integerY);

  printf("El valor intercambiado del entero x es: %i \n", integerY);
  printf("El valor intercambiado del entero x es: %i \n", integerX);

  return 0;
}

{
int casa1;
int casa2;

printf("Ingresa el numero de la casa1: ");

scanf("%i", &casa1);

printf("La casa del primer piso es la numero: %i \n ", casa1);

printf("Ingresa el numero de la casa2: ");

scanf("%i", &casa2);

printf("La casa del segundo piso es la numero: %i \n ", casa2);

printf(“Al intercambiar la posicion de las casas, la casa del primer piso es: %i \n”,casa2);
printf(“Al intercambiar la posicion de las casas, la casa del segundo piso es: %i \n”,casa1);

return 0;

}

Tipos de datos primitivos:

Numéricos: int (números enteros), float (números decimales)
Caracteres: char
Booleanos: bool (True or false)

#include <stdio.h>
#include <stdlib.h>

int main(){
   int a,b,c;
   printf("Ingresa valor a");
    scanf("%i",&a);
     c=a;
    printf("Ingresa valor b");
    scanf("%i",&b);
     a=b;
   printf("Valor a %i , Valor b %i",b,c);
return 0;
}

//Reto
    int x;
    int y;
    int z;

printf("\n***RETO***\n\n");

    printf("Introduce un valor para x:\t");
    scanf("%i", &x);

    printf("\n\nIntroduce un valor para y:\t");
    scanf("%i", &y);

    printf("El valor de x es: %i\n\n", x);
    printf("El valor de y es: %i\n\n", y);

    z = x;
    x = y;
    y = z;

    printf("El valor cambiado de x es: ***%i***\n\n", x);
    printf("El valor cambiado de y es: ***%i***\n", y);

Ya está probado y sí funciona

Reto 1: Intercambio de número

int NumX;
int NumY;
int Holder;

printf(“Dale un valor a x: “);
scanf(”%i”, &NumX);

printf(“Dale un valor a y: “);
scanf(”%i”, &NumY);

Holder = NumY;
NumY = NumX;
NumX = Holder;

printf("\nEl valor intercambiado de x es: %i", NumX);
printf("\nEl valor intercambiado de y es: %i \n", NumY);

#include <stdio.h>
#include <stdlib.h>

int main()
{
int x, y, z;
printf(“Ingrese x: “);
scanf(”%i”, &x);
printf(“Ingrese y: “);
scanf(”%i”, &y);
z = x;
x = y;
y = z;

printf("x: %i, y: %i", x, y);

return 0;

}

#include <stdio.h>
#include <stdbool.h>
int main(void) {

int entero = 1;
float flotante = 0.5;
double doublea = 2.5;
char caracter = ‘a’;
bool booleano = true;

//Aqui estamos imprimiedo

printf("El valor de mi entero es : %i \n ", entero);
printf (“el valor de mi flotante es : %f \n”, flotante);
printf (“el valor de mi double es : %f \n”, doublea );
printf(“el valor de mi caracter es: %c \n”, caracter);
return 0;
}

Reto completado 😃

#include <iostream>
#include <stdlib.h>
#include <stdbool.h>

/* run this program using the console pauser or add your own getch, system(“pause”) or input loop */

int main()

{

int integerA;
int integerB;
printf("ingresa el valor del entero A:");
scanf("%i", &integerA);
	
printf("ingresa el valor del entero B:");
scanf("%i", &integerB);

printf("el entero A es: %i\n", integerB);
printf("el entero B es: %i", integerA);

return 0;

}

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

int main()
{
int x;
int y;
int z;

printf("Ingresa el valor de un entero x: ");
scanf("%i", &x);

printf("Ingresa el valor de un entero y: ");
scanf("%i", &y);

z = x;
x = y;
y = z;

printf("El entero x es: %i \n", x);
printf("El entero y es: %i \n", y);


return 0;

}

int main()
{
int intY;
int intX;

printf(“ingresa el valor de X:”);

    scanf("%i", &intY);

printf("ingresa el valor de Y:");

    scanf("%i", &intX);

    printf("el intercambio del entero Y es: %i \n", intY);
    printf("el intercambio del entero X es:%i", intX);

return 0;

}

Así quedo mi código para el reto, en este caso lo cree de manera que el usuario pueda ingresar cualquier valor para las constantes. En segundo lugar se dejo comentado para tener la impresión con los valores inicializados en 3 y 5

El reto:

#include <stdio.h>
#include <stdbool.h>

int main(void) {
  int varA;
  int varB;
  int varAux;

  printf("Ingrese el valor de x: ");

  scanf("%i", &varA);

  printf("Ingrese el valor de y: ");

  scanf("%i", &varB);

  varAux = varA;
  varA = varB;
  varB = varAux;

  printf("El valor intercambiado de x es: %i \n", varA);
  printf("El valor intercambiado de y es: %i \n", varB);

  return 0;
}
}

Buen dia, reto cumplido… Assembler code ‘c’

#include<stdbool.h>
#include<string.h>
#include<stdio.h>
#include<stdlib.h>

int main() {
  int a, b, aux;

  printf("\n\nvalue of 'a': ");
  scanf("%i", &a);
  printf("value of 'b': ");
  scanf("%i", &b);
  aux = a;
  a = b;
  b = aux;

  printf("\nexchanged value of 'a' is: %d", a);
  printf("\nexchanged value of 'b' is: %d\n\n", b);

  return 0;
}