Ejemplo de operadores en C y reto

Clase 7 de 39 • Curso de Algoritmos con C 2017

Julio J Yépez

student•

El error en min 06:25s es que faltaba un operador entre el 5 y el (
Corregido:

#include <stdio.h>

void main(){
	int a,b,c,x,y,z;

	x =2+10;
	y=3+3*8;
	z=3/3;
	a=3+(10-2)-5*(4*2);

	printf("El resultado 1 es: %d\n", x);
	printf("El resultado 1 es: %d\n", y);
	printf("El resultado 1 es: %d\n", z);
	printf("El resultado 1 es: %d\n", a);
}

Julio J Yépez

student•

RETO

#include <stdio.h>

#define pi 3.14159

void main(){
	int l = 10;
	int r = 10;
	float areaCuadrado, areaCirculo;
	float sumaAreas;
	int areaMayor;

	areaCuadrado = 2 * l;
	areaCirculo = 2 * pi * r;

	sumaAreas = areaCuadrado + areaCirculo;

	areaMayor = areaCuadrado > areaCirculo;

	printf("Area del Cuadrado: %f\n", areaCuadrado);
	printf("Area del Circulo: %f\n", areaCirculo);
	printf("La suma de las areas es: %f\n", sumaAreas);
	printf("Area Mayor (0=circulo, 1=cuadrado): %d\n", areaMayor);
}

Salida:

Area del Cuadrado: 20.000000
Area del Circulo: 62.831799
La suma de las areas es: 82.831802
Area Mayor (0=circulo, 1=cuadrado): 0

Ricardo Celis

teacher•

excelente trabajo JJ Yepez! veo que estás aportando muchísimo al curso! muchas gracias =)

Julio J Yépez

student•

Prioridad de las operaciones en C

cortesía de carlospes.com

Ricardo Celis

teacher•

excelente!

Yesica Lizeth Cortés Pineda

teacher•

Es necesario decir que no solo es en C, en general es importante tener en cuenta esta precedencia cuando se realizan operaciones matemáticas.

Carlos David Ramirez Muñoz

student•

Mi codigo;

#include <stdio.h>

void main(){
  int v,w,x,y,z,a,b,c,d,e;                 //Establece variables

  printf("Operaciones en C\n");
  printf("\n");

  a = 2;
  b = 4;
  c = 14;
  d = 34;
  e = 5;

  printf("El valor A es de: %d\n", a);      //Muestra el valor de cada variable
  printf("El valor B es de: %d\n", b);
  printf("El valor C es de: %d\n", c);
  printf("El valor D es de: %d\n", d);
  printf("El valor E es de: %d\n", e);
  printf("\n");

  x = a < b;                               //realiza operaciones
  y = (c + b) > a;
  z = a =! 2;
  w = (d/2) > 26;
  v = e >= 5;

  printf("La operacion 1 (a < b) es: %d\n", x);                         //arroja 0 o 1 dependiendo de si son verdadero o falso
  printf("La operacion 2 ( (c + b) > a ) es: %d\n", y);
  printf("La operacion 3 (a =! 2) es: %d\n", z);
  printf("La operacion 4 ( (d/2) > 26 ) es: %d\n", w);
  printf("La operacion 5 (e >= 5) es: %d\n", v);
  printf("\n");

  printf("Hecho por @Pollitoh\n");
}

Francisco Javier Pedrosa Ruiz

student•

El error en el minuto 6:30 aprox, es porque falta un símbolo de multiplicación;

a = 3+(10-2)-5*****(4*2)

Ricardo Celis

teacher•

así es!

Eloy Rolando Canchanya Balbin

student•

Mi avance,

mi resultado,

Ricardo Celis

teacher•

Hola Eloy!
Excelente trabajo =)

Israel David Medina Rico

student•

Programa

#include <stdio.h>

void main()
{
    //  OPERADORES. Asignación y  Aritméticos.
    int a, b, c, d, e, z, y, x, w, v, u;
    a = 10 + 2;
    b = 10 - 2;
    c = 10 * 2;
    d = 10 / 2;
    e = 10 % 2;

	printf( "OPERADORES. Aritmeticos.\n");
    printf( "ADD:  %d\n" , a );
    printf( "SUBST:  %d\n" , b );
    printf( "MULT:  %d\n" , c );
    printf( "DIV:  %d\n" , d );
    printf( "MOD:  %d\n" , e );
    printf( " \n");
    //  OPERADORES. Relacionales.
    z = a < b;
    y = b <= c;
    x = c > d;
    w = d >= e;
    v = y == w;
    u = v != 1;

	printf( "OPERADORES. Relacionales.\n");
    printf( "LESS:  %d\n" , z );
    printf( "LESS OR EQUAL:  %d\n" , y );
    printf( "MORE:  %d\n" , x );
    printf( "MORE OR EQUAL:  %d\n" , w );
    printf( "EQUAL:  %d\n" , v );    
    printf( "DIFFERENT:  %d\n" , u );
    printf( " \n");
   //  OPERADORES. Lógicos.
   printf( "OPERADORES. Logicos.\n");
   if ( b < a && a < c )
   {
    printf( "AND: b is less then c\n" );
   }
    printf( "OR: %d" , (x == w || x == y || x == z) );
}

Resultado…

OPERADORES. Aritmeticos.
ADD:  12
SUBST:  8
MULT:  20
DIV:  5
MOD:  0

OPERADORES. Relacionales.
LESS:  0
LESS OR EQUAL:  1
MORE:  1
MORE OR EQUAL:  1
EQUAL:  1
DIFFERENT:  0

OPERADORES. Logicos.
AND: b is less then c
OR: 1

Andrés Madrigal

student•

#include <stdio.h>

void main()
{
    int a,b,suma,resta,multi,divis,mayorq,menorq,boolean;
    
    a=5;
    b=15;
    boolean = a&&b;
    suma = a+b;
    resta = a-b;
    multi = a*b;
    divis = b/a;
    mayorq = b>a;
    menorq = b<a;

    printf("'A' y 'B' existen? %d\n",boolean);
    printf("'A' es menor que 'B'? %d\n",mayorq);
    printf("El valor de 'A' es: %d\n",a);
    printf("El valor de 'B' es: %d\n",b);
    printf("La suma entre 'A' + 'B' es: %d\n",suma);
    printf("La resta entre 'A' - 'B' es: %d\n",resta);
    printf("La multiplicacion de 'A' por 'B' es: %d\n",multi);
    printf("La division entre 'A' y 'B' es: %d\n",divis);

}

Y la salida es:

'A' y 'B' existen? 		1
'A' es menor que 'B'?	1
El valor de 'A' es: 		5
El valor de 'B' es: 		15
La suma entre 'A' + 'B' es: 20
La resta entre 'A' - 'B' es: -10
La multiplicacion de 'A' por 'B' es: 75
La division entre 'A' y 'B' es: 3

Mauricio Rengifo Abella

student•

Mi reto fue realizar la funcion cuadratica, creo que me fue bien pues fue todo un reto compilar xD de los errores se aprende.

#include <stdio.h>
#include <math.h> //Esta extencion te permite hacer uso de funciones como raiz cuadrada

void main()
{

    int xPos, xNeg, xAux, a, b, c;

    //Funcion cuadratica

    a = 10;
    b = 3;
    c = 25;

    xAux = (pow (((b * b) - (4 * (a * c))), 2));
    xPos = (-1 * b) + xAux / (2 * a);
    xNeg = (-1 * b) - xAux / (2 * a);

    printf("El resultado x1 es: %d\n", xPos); 
    printf("El resultado x2 es: %d\n", xNeg);

}

Si al compilar con _gcc -o reto reto.c _no les funciona prueben con gcc -o reto reto.c -lm

-lm es una opción para enlazar con la biblioteca matemática (libm).

Andrés Leonardo Baldárrago Gastulo

student•

Reto:

#include <stdio.h>

void main(){
	
	int suma, resta, residuo;
	double multiplicacion, division;

	suma = 3 + 4;
	resta = 5 - 10;
	residuo = 100 % 3;

	multiplicacion = 35 * 2;
	division = 100.0 / 3;

	printf("La suma es: %d\n", suma);
	printf("La diferencia es: %d\n", resta);
	printf("El residuo es: %d\n", residuo);
	printf("El producto es: %f\n", multiplicacion);
	printf("El cociente es: %f\n", division);

	printf("3 > 2 --> %d\n", (3 > 2));
	printf("3 < 2 --> %d\n", (3 < 2));
	printf("3 >= 2 --> %d\n", (3 >= 2));
	printf("3 <= 2 --> %d\n", (3 <= 2));
	printf("3 != 2 --> %d\n", (3 != 2));

}```

Maximiliano Rodríguez Porras

student•

Les dejo un ejemplo para imprimir el area debajo de la función seno con 0´s y 1´s:

/* 
* Funcion seno con 0's y 1's @MaxHertz
*/


#include <stdio.h>
#include <stdlib.h>	//Aquí se encuentra la función abs
#include <math.h>	//Aquí se encuentra la función seno (sin)

#define high 20.0	//Número de filas
#define width 70.0	//Número de columnas
#define scaleX 5.0 	//Escala en X, esto modifica la frecuencia

void main()
{
	double yp,yc,posX,posY,dif;
	
	for (posY=0;posY<=high; posY++)
	{
		for(posX=0;posX<=width;posX++)
		{
			yp=sin(posX/scaleX)*(high/3);
			yc=(high/2-posY);
			dif=abs(yc+yp)-(abs(yp)+abs(yc));
			printf("%d", abs(yp)>=abs(yc)&&dif==0);
		}
		printf("\n");
	}
}

Resultado:

00000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000
00000011111000000000000000000000000000111100000000000000000000000000011
00000111111100000000000000000000000011111110000000000000000000000000111
00001111111110000000000000000000000111111111000000000000000000000001111
00011111111111000000000000000000001111111111100000000000000000000011111
00111111111111100000000000000000011111111111110000000000000000000111111
01111111111111100000000000000000011111111111111000000000000000001111111
11111111111111111111111111111111111111111111111111111111111111111111111
00000000000000000111111111111110000000000000000011111111111111100000000
00000000000000000011111111111100000000000000000001111111111111000000000
00000000000000000001111111111100000000000000000000111111111110000000000
00000000000000000001111111111000000000000000000000011111111100000000000
00000000000000000000111111110000000000000000000000001111111000000000000
00000000000000000000001111000000000000000000000000000111110000000000000
00000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000

Para compilar usar: gcc -o ejerccio ejercicio.c -lm

Saludos

Alexander Enrique Guzman Ruiz

student•

Excelente amigo pero no me quedo muy claro como realiza el proceso de escribir 1 y 0 bajo la funcion seno, gracias de antemano por la respuesta

Jefferson Naranjo Rodríguez

student•

Por qué cuándo corrijo mi el error de la var a mi terminal me sigue mostrando el mismo error? lo cambie por otra operación y sigue apareciendo el error anterior.

Nicolás Díaz

student•

RETO:

#include <stdio.h>

void main()
{
  int peMat=6;
  int peBio=8;
  int peIng=1;
  int meMat=11;
  int meBio=12;
  int meIng=7;
  int cantAsignaturas=3;
  int limite=6;
  int peResult;
  int meResult;
  int promPedro=(peMat+peBio+peIng)/cantAsignaturas;
  int promMelina=(meMat+meBio+meIng)/cantAsignaturas;

  peResult = promPedro>limite;
  meResult = promMelina>limite;

  printf("A continuacion, se detallan los resultados finales:\n");
  printf("Obs: Si el alummno aprueba el curso, se indicara con el numero 1, caso contrario se muestra el 0.\n");
  printf("\n");
  printf("Alumno Pedro:\n");
  printf("Promedio anual:%d\n", promPedro);
  printf("Aprobacion del curso:%d\n", peResult);
  printf("\n");
  printf("Alumna Melina:\n");
  printf("Promedio anual:%d\n", promMelina);
  printf("Aprobacion del curso:%d\n", meResult);
}```

Salida:
A continuacion, se detallan los resultados finales:
Obs: Si el alummno aprueba el curso, se indicara con el numero 1, caso contrario se muestra el 0.

Alumno Pedro:
Promedio anual:5
Aprobacion del curso:0

Alumna Melina:
Promedio anual:10
Aprobacion del curso:1

Luis Scozzese

student•

Reto:

#include<stdio.h>

voidmain(){
	int a = 8;
	int b = 5;
	int c = 3;	
	int resultado = (a*b) / c;

	printf("el resultado es: %d\n", resultado);
	
}

carlos andres rengifo

student•

hola esta es mi solucion al problema al estilo de la vieja escuela me siento contento de complemetar mi educacion con platzi

/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   operadores.c                                       :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: crengifo <marvin@42.fr>                    +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2018/11/02 10:13:15 by crengifo          #+#    #+#             */
/*   Updated: 2018/11/02 12:06:26 by crengifo         ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

#include <unistd.h>

void ft_putchar(char c)
{
	write(1, &c, 1);
}

int ft_putoperator(char s , char r, char m, char d)
{
	int a;
	int b;
	int c;
	int i;

	a =  2;
	b =  10;
	c =  2;
	i =  2;

	ft_putchar((a + s) + '0');
	ft_putchar('\n');
	ft_putchar((b - r) + '0');
	ft_putchar('\n');
	ft_putchar((c * m) + '0');
	ft_putchar('\n');
	ft_putchar((i / d) + '0');

	return (0);
}

int	main(void)
{
	ft_putoperator(5, 8, 2, 6);
	return(0);
}

Nicolás Díaz

student•

wtf?

Marina Iglesia

student•

RETO :

#include <stdio.h>
#define const 7

void main(){

int a,b,c,resultado;

    a= ( 6 % 4 ) + 1;
    b= const - 2;
    c = a-b / -1 ;

    resultado = a + b + c;

  printf("El resultado es %d \n", resultado);

Salida :

El resultado es 16

Yesica Lizeth Cortés Pineda

teacher•

muy bien 😄

gregory yepez

student•

#include <stdio.h>
#include <math.h>
#define PI 3.1416

int main(){
	
	float radio,volumen;
	radio=10;	
	
	volumen = 4/3*PI*radio*radio*radio;

	printf("El volumen de su esfera es %.3f",volumen);
	
	return 0;
}

Yesica Lizeth Cortés Pineda

teacher•

Muy bien, creo que puedes organizarlo un poco mejor si usas algunos paréntesis para separar las operaciones

Andric Alejandro Vargas Alarcón

student•

`#include <stdio.h>
void main()
{
int number1, number2;
#define nConstante 100

printf("***RETO DE OPERADORES***\n");
printf("ingrese el Primer numero \n");
scanf("%d", &number1);
printf("ingrese el Segundo numero \n");
scanf("%d", &number2);

if(number1 > number2)
{
	printf("El numero %d es mayor que el numero %d\n",number1,number2);
}
else
{
	printf("El numero %d es mayor que el numero %d\n",number2,number1);
}

//operaciones
int nSuma = number1 + number2;
int nResta = number1 - number2;
double nOpCombinada = (number1 + (number1 / number2)) - (nConstante * (number1 + number2));

printf("El resultado de la suma del el numero %d y el numero %d es %d \n",number1,number2,nSuma);
printf("El resultado de la resta del el numero %d y el numero %d es %d \n",number1,number2,nResta);
printf("El resultado de la operacion combinada es %f\n",nOpCombinada);

Notas
Las constantes no terminan en ";"
En el ejemplo : printf(“El resultado de la resta del el numero %d y el numero %d es %d \n”,number1,number2,nResta); %d es el tipo de impresión de variable pero tambien se debe considerar su orden para luego de la “,” especficar que variable tendra esa posición

Luis Angel Vásquez Nepomuceno

student•

Hola 😃

Comparto el reto con operadores lógicos: Fui jugando con los resultados para que se notará como es que afectan los operadores de AND, OR y NOT.

<#include <stdio.h>

void main(){
  int a, b, c, d, e, f, g, h, i, j, k;
  a = 1;
  b = 2;
  c = 3;

  d = a > b;
  e = a < b;
  f = d || e;
  g = d && e;
  h = f || g;
  i = f && g;
  j = !d;
  k = !d && e;

  printf("Los valores usados son... a = 1, b = 2, c = 3\n");
  printf("resultado a > b: %d\n", d);
  printf("Resultado b < a: %d\n", e);
  printf("Resultado a > b || b < a: %d\n", f);
  printf("Resultado a > b && b < a: %d\n", g);
  printf("Resultado (a > b || a < b) || (a>b && a<b): %d\n", h);
  printf("Resultado (a > b || a < b) && (a>b && a<b): %d\n", i);
  printf("Resultado !(a > b): %d\n", j);
  printf("Resultado !(a > b) && b < a: %d\n", k);
}>

La salida es:

<$ ./ensayos.exe
Los valores usados son... a = 1, b = 2, c = 3
resultado a > b: 0
Resultado b < a: 1
Resultado a > b || b < a: 1
Resultado a > b && b < a: 0
Resultado (a > b || a < b) || (a>b && a<b): 1
Resultado (a > b || a < b) && (a>b && a<b): 0
Resultado !(a > b): 1
Resultado !(a > b) && b < a: 1
>

Saludos

Cristian Camilo Cucunubá

student•

Reto

#include <stdio.h>

void main(){
	int suma,resta,multiplicacion;
	float division,mod;
	int a = 10;
	int b = 2;



	suma = a + b;
	printf("El resultado de la suma entre %d  y  %d es %d" , a, b , suma);
	resta = a - b;
	printf("\nEl resultado de la resta entre %d  y  %d es %d" , a, b , resta);
	multiplicacion = a * b;
	printf("\nEl resultado de la multiplicacion entre %d  y  %d es %d" , a, b , multiplicacion);
	division = a / b;
	printf("\nEl resultado de la division entre %d  y  %d es %.2f" , a, b , division);
	mod = a % b;
	printf("\nEl resultado del mod entre %d  y  %d es %.2f" , a, b , mod);
}

Output :

El resultado de la suma entre 10  y  2 es 12
El resultado de la resta entre 10  y  2 es 8
El resultado de la multiplicacion entre 10  y  2 es 20
El resultado de la division entre 10  y  2 es 5.00
El resultado del mod entre 10  y  2 es 0.00

Ricardo Celis

teacher•

Muy bien Cris, bien hecho el formateo de las salidas y todo! ¿qué tal te va pareciendo el curso?

Jesus Ricardo Moreira Cedeño

student•

Todo bien :’)
Reto:

#include <stdio.h>
#include <wchar.h>
#include <locale.h>

void main() {
	float a, b, c, d, e, f, r;
	a = 423-34;
	b = 314*a;
	c = (a-b)+2;
	d = c*a+(2*b);
	e = (d*a)/(b*c)+2;
	f = e+a+b+c+d;
	r = (f*a)+b*c+2-d*e;
	
	setlocale(LC_ALL, "");
	
	printf("El resultado de la operación 1 es: %f\n", a);
	printf("El resultado de la operación 2 es: %f\n", b);
	printf("El resultado de la operación 3 es: %f\n", c);
	printf("El resultado de la operación 4 es: %f\n", d);
	printf("El resultado de la operación 5 es: %f\n", e);
	printf("El resultado de la operación 6 es: %f\n", f);
	printf("El resultado de la operación 7 es: %f\n", r);
}

Resultado:

Ejemplo de operadores en C y reto

Introducción al Lenguaje C

¿Dónde aprender C?

Introducción al Lenguaje C

Estructura general de un programa en C y un hola mundo

Tipos de errores y datos en C

Variables en C

Operadores y expresiones en C

Ejemplo de operadores en C y reto

Entrada y salida de datos

Estructura secuencial

Estructura secuencial (if y if else)

Estructura selectiva (if, if else, else)

Estructura selectiva (switch)

Estructuras selectivas anidadas

Más Estructuras Selectivas Anidadas

Estructuras Repetitivas: While

Estructuras repetitivas: Do While

Estructuras Repetitivas: For

Platzi Terminal: Llevando a la Práctica lo Aprendido

Crear una tienda de Platzi dentro de la terminal

Crear una tienda de Platzi dentro de la terminal 2

Introducción a Algoritmos

El mundo de los algoritmos

Introducción al Curso de Algoritmos con C

¿Qué es un algoritmo?

Lenguajes de programación

Elementos de un algoritmo

User defined data types: Estructuras de datos y custom data types

Entrada y salida de información

Metodología para la solución de un algoritmo

Resolución del problema

El porqué del análisis de algoritmos

Cómo comparar algoritmos y ritmo de crecimiento

Estructuras de control y estructuras de control secuenciales

Estructuras de control selectivas

Estructuras de control repetitivas

Algoritmos más Utilizados

Sesiones en vivo del Curso de Algoritmos con C

Algoritmos de Ordenamiento

Algoritmo PID

Divide y Vencerás

Algoritmo de Dijkstra: Introducción a los Grafos

Algoritmos de búsqueda