We can use any method. As we can find out the area of the circle by three methods as i known.

1.ordinary programming

e.g. void main() {

int r;float area;

printf("\n\tEnter radius of the circle : "); scanf("%d",&r); area=3.14*r*r; printf("Radius = %d and area=%f",r,area); } 2. By using macros e.g. #define PI 3.14

#define AREA(x) PI*x*x 3. We can solve by user defined functions also

🤓

🤯

🤔

Q: How to write a programme in c to calculate that reads floating point number but displays only integer?

Write your answer...

Character or small integerShort IntegerIntegerLong integerBooleanFloating point numbersDouble precision floating point numberLong double precision floating point numberWide characterTo get a better idea on C++ data types, see related links below.

yes However, integer is a representation of a whole number that does not use fractions or decimals. A floating point number may represent a whole number, but not be an integer. So 23 is a whole number, 23 is an integer, but 23.00 is a floating point number, not an integer.All integers are whole numbers

integer character floating point

#include <math.h> inline unsigned int get_num_digits(const unsigned int n) { return ((unsigned int) log10(n) + 1); }

integer data is stored as binary integers which can be converted to decimal, and used in addition/subtraction/multiplication/division with no loss of accuracy. floating point data is stored as an approximation and suffers from some inaccuracy.

In real-world math, there is no "largest" integer or floating point number. This is covered by the concepts known as "infinity" and "irrationality." Depending on the processor and/or application, a number with significant digits into the thousands can be operated upon.

A floating point number is one that contains an integer as well as a fractional part, for example 101.3625. These are often represented by their scientific notations as well, such as 1.013625E2

No, 9.6 is a floating-point number. Integers are whole numbers without fractional parts.

The advantages of integer arithmetic over floating point arithmetic is the absence of rounding errors. Rounding errors are an intrinsic aspect of floating point arithmetic, with the result that two or more floating point values cannot be compared for equality or inequality (or with other relational operators), as the exact same original value may be presented slightly differently by two or more floating point variables. Integer arithmetic does not show this symptom, and allows for simple and reliable comparison of numbers. However, the disadvantage of integer arithmetic is the limited value range. While scaled arithmetic (also known as fixed point arithmetic) allows for integer-based computation with a finite number of decimals, the total value range of a floating point variable is much larger. For example, a signed 32-bit integer variable can take values in the range -231..+231-1 (-2147483648..+2147483647), an IEEE 754 single precision floating point variable covers a value range of +/- 3.4028234 * 1038 in the same 32 bits.

You don't need to use default arguments in a function -- they are optional. You use them if and when they are required. Typically you will use them to gain the benefit of function overloading without the need to provide completely separate implementations. As an example, consider the following trivial class declaration: struct foo { foo(): m_integer(0), m_floating(0.0) {} foo(int integer, float floating): m_integer(integer), m_floating(floating) {} private: int m_integer; float m_floating; }; Note that there are two constructors, a default constructor that accepts no arguments and an overloaded constructor that accepts two arguments. In both cases the implementations are fundamentally the same (they both initialise the data members) so they could just as easily be combined into a single constructor with default arguments: struct foo { foo(int integer=0, float floating=0.0): m_integer(integer), m_floating(floating) {} private: int m_integer; float m_floating; }; Now you gain the benefit of construction overloading via a single constructor. In effect you've actually created 4 different construction methods, depending on which, if any, arguments you supply: foo a; // assigns 0 to integer and 0.0 to floating foo b(1); // assigns 1 to integer and 0.0 to floating foo c(1,1.0); // assigns 1 to integer and 1.1 to floating foo d(,1.0); // assigns 0 to integer and 1.0 to floating

char: A one-byte integer with implementation-defined signedness.signed char: A signed one-byte integer.unsigned char: An unsigned one-byte integer.wchar_t: A wide character of implementation-defined size and signedness.short: A signed integer with at least 16 bits.unsigned short: An unsigned integer with at least 16 bits.int: A signed integer with at least 16 bits.unsigned int: An unsigned integer with at least 16 bits.long: A signed integer with at least 32 bits.unsigned long: An unsigned integer with at least 32 bits.long long: A signed integer with at least 64 bits.unsigned long long: An unsigned integer with at least 64 bits.float: A floating-point number with 32 bits of precision.double: A floating-point number with 64 bits of precision.long double: A floating-point number with 80-96 bits of precision.

175.23*10^-2

5 is an integer and not a fraction. However, it can be expressed in rational form as 5/1. You can then calculate equivalent rational fractions if you multiply both, its numerator and denominator, by any non-zero integer.5 is an integer and not a fraction. However, it can be expressed in rational form as 5/1. You can then calculate equivalent rational fractions if you multiply both, its numerator and denominator, by any non-zero integer.

the sum of two consecutive integers is -241, what is the larger integer?

For i as integer = 1 to 10 ....... Next i

The LCM is defined as being a positive integer. Ignore the negative signs. Calculate as if everything's positive.

Calculate all the operations following BIDMAS or PEMDAS, as appropriate.

You can't address memory with floating point values. All pointers are integer values pointing to a location in memory, regardless of what type it is pointing to. If you wanted a floating point pointer, then the following should do the trick: float *floatingPointer; Note: If you wanted to ask that which integer type is big enough to hold a (flat) pointer, then the answer: ptrdiff_t, intptr_t (both signed) and size_t, uintptr_t (both unsigned).

138558 x 10-2

Multiply the numerator and the denominator of the fraction by the same, non-zero integer.

using class shared sub main() dim s as integer=10 dim g as integer=20 system.console.writeline(s+g) end sub end class

Why not try it out? See if you can find an integer which, when squared, gives you 100. Or: use a calculator and calculate the square root of 100. If you get an integer, then the answer to the question is "yes"; otherwise the answer is "no".

It allows you to compare two floating point values using integer hardware.

There are many different operators, which are you referring to?

69 is an integer and can be expressed in rational form as 69/1. You can then calculate equivalent rational fractions if you multiply both, its numerator and denominator, by any non-zero integer.