đŸ’ģ
C - Structured Programming Language
  • C - Structured Programming Language
  • Structured Programming Language
    • Chapter 0: Overview
      • Overview of Programming
      • Overview of C Programming
      • History of C Programming
      • IDE - Code::Blocks
      • New File Creation and Managing Program Files in Folders
      • C Program Basic Structure
      • Sections of the C Program
      • Steps for Using a Program
      • Flow of a Program Execution
      • First C Program - Hello World
      • Comment
      • Lexical Elements (/Tokens)
      • Keywords
      • Character Set
    • Chapter 1: Data Type, IO
      • Data Type
      • Variable
        • Variable Declaration for Primitive Data Type
        • Variable Address and Input
        • Constant and Macro
        • Variable Scope and Lifetime
        • Variable Storage Type
        • Variable Declaration Vs Definition Vs Initialization
        • Variable Default Value
        • Identifier Naming Rules and Conventions
      • Primitive Data Type: Format Specifier and Size
      • Literals
      • Primitive Data Type: Input Output
        • Input Output Function
        • Integer IO
        • Real Number IO
        • Character IO
        • String IO
        • Formatted Output
        • Formatted Input
        • Return of Scanf and Printf
      • IO Error
      • Escape Sequence / Backslash Characters
      • Data Type Modifiers
        • Data Type Size and Format Specifier
        • Input Output Using Modifiers
      • Data Type Limit
        • Integer Number
        • Floating Point Number
      • Memory Segment
      • Type Casting
      • Declaration of Derived Data Type
        • Array
        • Pointer
        • Function
        • Structure
        • Union
      • Declaration of User Defined Data Type
        • Enumeration
          • Enum Constant Value
          • Enumeration Exercise
        • Typedef
      • Declaration of Other Data Type
        • Boolean
        • Complex and Imaginary Number
        • File
        • Clock and Time
    • Chapter 2: Operator
      • Types of Operators
      • Assignment Operator
      • Arithmetic Operators
        • Math Operation
      • Increment, Decrement Operators
      • Relational Operators
      • Logical Operators
      • Bitwise Operators
      • Miscellaneous Operators
      • Operator Precedence and Associativity
      • Programming Syntax & Expression
      • Operator Exercise
    • Chapter 3: Conditional Statement
      • Truth Value
      • If Else Exercise
        • Zero, Positive, Negative - Number Sign Test
        • Voting Eligibility
        • Complex Numbers Equality
        • Different Example
          • Print a Digit into Word
          • Grade Evaluation
          • FizzBuzz
          • EVEN or ODD
          • Leap Year
          • Maximum of 2 Numbers
          • Maximum of 3 Numbers
          • Minimum of 2 Numbers
          • Minimum of 3 Numbers
      • Ternary Operator
        • Ternary Operator Exercise
      • Switch Statement
        • Switch Statement Exercise
    • Chapter 4: Loop
      • Loop Basic
      • Series Printing using Loop
      • Summation and Factorial
      • Loop Exercise
      • Number Theory
      • Break and Continue
      • Nested Loop
      • Managing Test Case
      • Goto Statement
    • Chapter 5: Pointer and Dynamic Memory Allocation
      • Pointer Fundamental Concept
        • Pointer Declaration
        • Types of Pointer
        • Pointer for Primitive Data Types
        • Pointer Referencing, Initialization, Accessing, Dereferencing
        • Pointer Size
      • Pointer Operation
        • Value Assignment/Update
        • Pointer Input Output
        • Pointer and Operator
          • Assignment Operator
          • Arithmetic Operator
          • Increment/Decrement Operator
          • Relational Operator
        • Pointer and Flow Control
      • Multilevel Pointer
      • Dynamic Memory Allocation (DMA)
        • Dynamic Memory Allocation (DMA)
        • DMA for Primitive Data Types
        • Pointer Operation after DMA
    • Chapter 6: Function & Recursion
      • Type of Function
      • Function Exercise
      • Conditional Statement and Function
      • Loop Exercise using Function
      • Pointer and Function
      • Recursion
        • Example
        • Pointer
    • Chapter 7: Array
      • Array Fundamental Concept
        • Necessity
        • Declaration (1D Array)
        • Initialization
        • Access
        • Assignment
        • Address
        • User Input
          • Test Case
      • Function and Array
      • Basic Array Operation
        • Statistical Operations
          • Summation
          • Average (Mean), Median
          • Frequency Table, Mode
          • Standard Deviation, Variance
          • Covariance, Correlation
        • Searching
          • Linear Search
          • Binary Search
          • Maximum
          • Minimum
        • Update
          • Index Based
          • Element Based
        • Delete
          • Index Based
          • Element Based
        • Insert
          • Index Based
          • Element Based
        • Sorting
          • Selection Sort
          • Insertion Sort
          • Bubble Sort
      • Other Array Operation
        • Copy
        • Reverse
        • Compare
        • Merge
        • Split
        • Cyclic Permutation
      • Pointer and Array
        • Basic
        • Insert
        • Delete
        • Summation
        • Reverse
        • Compare
        • Merge
        • Split
        • Cyclic Permutation
      • Pointer and Array
      • DMA and Array
      • 2D Array
    • Chapter 8: Character and String
      • Character
        • Declaration and Initialization
        • ASCII Code
        • Input Output
        • Conditional Statement
        • Character Arithmetic
      • String
        • String Declaration and Initialization
        • Input Output
        • Character Count in String
        • Character Conversion in String
        • String Operations
          • Substring
      • String and Pointer
    • Chapter 9: Structure
      • Basic of Structure
      • Structure Pointer
      • Function and Structure
      • Nested Structure
      • DMA and Structure
    • Chapter 10: File
    • Miscellaneous
      • Working with Math Functions
      • Working with Time Functions
      • Union
      • Preprocessor
      • Custom Header File
      • Error Handling
      • Graphics
      • Other
      • Coding Convention
      • Identifiers (Variable, Function & Structure) Naming Convention
      • Sizeof
      • Exit, Abort
      • Assert
    • Reference
      • Online Learning Material
  • Exercise
    • Problem Set 0: IDE, First C Program - 4
    • Problem Set 1: Data Types, IO - 55
      • Data Type, Variable, Format Specifier, Input, Output, String - 33
      • Data Type, Input, Output - 8
      • Data Type, Data Type Modifier, Format Specifier, Size, Limit, Address - 9
      • Formatted Input-Output - 4
    • Problem Set 2: Operator - 108
      • 2.1 Assignment Operator - 11
      • 2.2 Arithmetic Operator - 73
        • 2.2.1 Arithmetic Operator [5]
        • 2.2.2 Arithmetic Operator Exercise [10]
        • 2.2.3 Scale Conversion [25]
        • 2.2.4 Geometrical Shapes [35]
      • Bitwise Operator - 11
      • Use of Library Functions - 23
    • Problem Set 3: Conditional Statements - 47
    • Problem Set 4: Loop - 124
      • Sequence and Series - 33
      • More Loop Exercise - 52
      • Test Case - 7
      • Loop Nested - 32
    • Problem Set 5: Pointer and Dynamic Memory Allocation
      • Pointer Exercise
    • Problem Set 6: Function and Recursion - 42
      • Recursion
    • Problem Set 7: Array
      • One Dimensional Array - 114
      • Two Dimensional Array
    • Problem Set 8: Character and String - 61
      • Character - 29
      • String - 32
    • Problem Set 9: Structure
    • Problem Set 10: File
  • Solution
    • 0: IDE, First C Program
    • 1: Data Types, IO
    • 2: Operator
      • 2.1 Assignment Operator
      • 2.2 Arithmetic Operator
    • 3: Conditional Statements
      • 3.1 Conditional Statement
      • 3.2 Relational Operator
      • 3.3 Logical Operator
      • 3.4 Max, Min Median, Sorting
      • 3.5 Divisibility
    • 4: Loop
      • 4.1.1 Loop (Repetition)
      • 4.1.2 Print Sequence
      • 4.1.3 Summation of Series
      • 4.2 Loop Exercise
    • 5: Pointer and Dynamic Memory Allocation
    • 6: Function and Recursion
      • 5.1 Types of User Defined Function
      • 5.2 Exercise - Function
    • 7: Array
    • 8: Character and String
      • 7.1 Character Basic
      • 7.2 Character Input
      • 7.3 ASCII Code
      • 7.4 Character Test
      • 7.5 Character Conversion
      • 7.6 Character Arithmetic Operation
    • 9: Structure
    • 10: File
Powered by GitBook
On this page
  • ā§Ē.⧍ āĻ…āύ⧁āĻļā§€āϞāύ: āϞ⧁āĻĒ (⧍⧍)
  • āϏāĻŽāĻžāϧāĻžāύ
  • [19] āϝ⧇āϕ⧋āύ⧋ āĻāĻ•āϟāĻŋ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āύāĻžāĻŽāϤāĻž āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻ•āϰāĨ¤
  • [20] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻĢā§āϝāĻžāĻ•ā§āϟāϰāĻŋāϝāĻŧāĻžāϞ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤ [N! = 1 × 2 × 3 × 4 × ......... × N]
  • [21] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻ‰ā§ŽāĻĒāĻžāĻĻāĻ• (Factor)/āϗ⧁āĻŖāύ⧀āϝāĻŧāĻ• (Divisor) āϗ⧁āϞ⧋ āĻĒā§āϰāĻĻāĻ°ā§āĻļāĻŖ āĻ•āϰāĨ¤
  • [22] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻĒā§āϰāĻ•ā§ƒāϤ āĻ‰ā§ŽāĻĒāĻžāĻĻāĻ• (Factor)/āϗ⧁āĻŖāύ⧀āϝāĻŧāĻ• (Divisor) āϗ⧁āϞ⧋ āĻĒā§āϰāĻĻāĻ°ā§āĻļāĻŖ āĻ•āϰāĨ¤
  • [23] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻŽā§‹āϟ āĻ‰ā§ŽāĻĒāĻžāĻĻāĻ• (Factor)/āϗ⧁āĻŖāύ⧀āϝāĻŧāĻ• (Divisor) āϏāĻ‚āĻ–ā§āϝāĻž āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤
  • [24] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻž āĻŽā§ŒāϞāĻŋāĻ• (Prime) āϏāĻ‚āĻ–ā§āϝāĻž āĻ•āĻŋāύāĻž āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤
  • [25] ā§§ āĻĨ⧇āϕ⧇ n āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϏāĻ‚āĻ–ā§āϝāĻž āϏāĻŽā§‚āĻšā§‡āϰ āĻŽāĻ§ā§āϝ⧇ āĻŽā§ŒāϞāĻŋāĻ• (Prime) āϏāĻ‚āĻ–ā§āϝāĻž āϗ⧁āϞ⧋ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤
  • [26] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ āĻœā§‹ā§œ āĻ‰ā§ŽāĻĒāĻžāĻĻāĻ• (Factor)/āϗ⧁āĻŖāύ⧀āϝāĻŧāĻ• (Divisor) āϗ⧁āϞ⧋ āĻĒā§āϰāĻĻāĻ°ā§āĻļāĻŖ āĻ•āϰāĨ¤
  • [27] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ āĻŦāĻŋāĻœā§‹ā§œ āĻ‰ā§ŽāĻĒāĻžāĻĻāĻ• (Factor)/āϗ⧁āĻŖāύ⧀āϝāĻŧāĻ• (Divisor) āϗ⧁āϞ⧋ āĻĒā§āϰāĻĻāĻ°ā§āĻļāĻŖ āĻ•āϰāĨ¤
  • [28] āĻĻ⧁āχāϟāĻŋ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻ—.āϏāĻž.āϗ⧁ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤
  • [29] āĻĻ⧁āχāϟāĻŋ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āϞ.āϏāĻž.āϗ⧁ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤
  • [30] āĻĻ⧁āχāϟāĻŋ āϏāĻ‚āĻ–ā§āϝāĻž āϏāĻšāϗ⧁āĻŖāĻ• (Co-Prime) āĻ•āĻŋāύāĻž āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤ [if GCD (a, b) == 1, then a and b are Co-Prime]
  • [31] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻ‰ā§ŽāĻĒāĻžāĻĻāĻ• (Factor)/āϗ⧁āĻŖāύ⧀āϝāĻŧāĻ• (Divisor) āϗ⧁āϞ⧋āϰ āϝ⧋āĻ—āĻĢāϞ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤
  • [32] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻĒā§āϰāĻ•ā§ƒāϤ āĻ‰ā§ŽāĻĒāĻžāĻĻāĻ• (Factor)/āϗ⧁āĻŖāύ⧀āϝāĻŧāĻ• (Divisor) āϗ⧁āϞ⧋āϰ āϝ⧋āĻ—āĻĢāϞ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤
  • [33] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻž āĻĒāĻžāϰāĻĢ⧇āĻ•ā§āϟ (Perfect) āϏāĻ‚āĻ–ā§āϝāĻž āĻ•āĻŋāύāĻž āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤
  • [34] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻž Perfect, Abundant, or Defective āϏāĻ‚āĻ–ā§āϝāĻž āĻ•āĻŋāύāĻž āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤
  • [35] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻž Amicable āϏāĻ‚āĻ–ā§āϝāĻž āĻ•āĻŋāύāĻž āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤ [sopd(a)==b&&sopd(b)==a]
  • [36] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžā§Ÿ āĻ•ā§ŸāϟāĻŋ āĻ…āĻ‚āĻ• āĻ°ā§Ÿā§‡āϛ⧇ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤
  • [37] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžā§Ÿ āĻ…āĻ‚āĻ• āϗ⧁āϞ⧋āϕ⧇ āĻŦāĻŋāĻĒāϰ⧀āϤ āĻ•ā§āϰāĻŽā§‡ āĻĒā§āϰāĻĻāĻ°ā§āĻļāĻŖ āĻ•āϰāĨ¤
  • [38] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻ…āĻ‚āĻ• āϗ⧁āϞ⧋āϰ āϝ⧋āĻ—āĻĢāϞ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤
  • [39] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻ…āĻ‚āĻ• āϗ⧁āϞ⧋āϰ āϝ⧋āĻ—āĻĢāϞ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰ, āϝāϤāĻ•ā§āώāύ āύāĻž āϝ⧋āĻ—āĻĢāϞ āĻāĻ• āĻ…āĻ‚āĻ• āĻŦāĻŋāĻļāĻŋāĻˇā§āϟ āĻšā§ŸāĨ¤
  • [40] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻž āĻĒā§āϝāĻžāϞāĻŋāĻŖā§āĻĄā§āϰāĻŽ āϏāĻ‚āĻ–ā§āϝāĻž āĻ•āĻŋāύāĻž āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤
  1. Solution
  2. 4: Loop

4.2 Loop Exercise

ā§Ē.⧍ āĻ…āύ⧁āĻļā§€āϞāύ: āϞ⧁āĻĒ (⧍⧍)

  1. [19] āϝ⧇āϕ⧋āύ⧋ āĻāĻ•āϟāĻŋ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āύāĻžāĻŽāϤāĻž āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻ•āϰāĨ¤

  2. [20] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻĢā§āϝāĻžāĻ•ā§āϟāϰāĻŋāϝāĻŧāĻžāϞ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤ [N! = 1 × 2 × 3 × 4 × ......... × N]

  3. [21] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻ‰ā§ŽāĻĒāĻžāĻĻāĻ• (Factor)/āϗ⧁āĻŖāύ⧀āϝāĻŧāĻ• (Divisor) āϗ⧁āϞ⧋ āĻĒā§āϰāĻĻāĻ°ā§āĻļāĻŖ āĻ•āϰāĨ¤

  4. [22] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻĒā§āϰāĻ•ā§ƒāϤ āĻ‰ā§ŽāĻĒāĻžāĻĻāĻ• (Factor)/āϗ⧁āĻŖāύ⧀āϝāĻŧāĻ• (Divisor) āϗ⧁āϞ⧋ āĻĒā§āϰāĻĻāĻ°ā§āĻļāĻŖ āĻ•āϰāĨ¤

  5. [23] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻŽā§‹āϟ āĻ‰ā§ŽāĻĒāĻžāĻĻāĻ• (Factor)/āϗ⧁āĻŖāύ⧀āϝāĻŧāĻ• (Divisor) āϏāĻ‚āĻ–ā§āϝāĻž āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

  6. [24] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻž āĻŽā§ŒāϞāĻŋāĻ• (Prime) āϏāĻ‚āĻ–ā§āϝāĻž āĻ•āĻŋāύāĻž āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

  7. [25] ā§§ āĻĨ⧇āϕ⧇ n āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϏāĻ‚āĻ–ā§āϝāĻž āϏāĻŽā§‚āĻšā§‡āϰ āĻŽāĻ§ā§āϝ⧇ āĻŽā§ŒāϞāĻŋāĻ• (Prime) āϏāĻ‚āĻ–ā§āϝāĻž āϗ⧁āϞ⧋ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

    1. [25.1] ā§§ āĻĨ⧇āϕ⧇ ā§Šā§Ļ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϏāĻ‚āĻ–ā§āϝāĻž āϏāĻŽā§‚āĻšā§‡āϰ āĻŽāĻ§ā§āϝ⧇ āĻŽā§ŒāϞāĻŋāĻ• (Prime) āϏāĻ‚āĻ–ā§āϝāĻž āϗ⧁āϞ⧋ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

  8. [26] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ āĻœā§‹ā§œ āĻ‰ā§ŽāĻĒāĻžāĻĻāĻ• (Factor)/āϗ⧁āĻŖāύ⧀āϝāĻŧāĻ• (Divisor) āϗ⧁āϞ⧋ āĻĒā§āϰāĻĻāĻ°ā§āĻļāĻŖ āĻ•āϰāĨ¤

  9. [27] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ āĻŦāĻŋāĻœā§‹ā§œ āĻ‰ā§ŽāĻĒāĻžāĻĻāĻ• (Factor)/āϗ⧁āĻŖāύ⧀āϝāĻŧāĻ• (Divisor) āϗ⧁āϞ⧋ āĻĒā§āϰāĻĻāĻ°ā§āĻļāĻŖ āĻ•āϰāĨ¤

  10. [28] āĻĻ⧁āχāϟāĻŋ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻ—.āϏāĻž.āϗ⧁ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

  11. [29] āĻĻ⧁āχāϟāĻŋ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āϞ.āϏāĻž.āϗ⧁ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

  12. [30] āĻĻ⧁āχāϟāĻŋ āϏāĻ‚āĻ–ā§āϝāĻž āϏāĻšāϗ⧁āĻŖāĻ• (Co-Prime) āĻ•āĻŋāύāĻž āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤ [if GCD (a, b) == 1, then a and b are Co-Prime]

  13. [31] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻ‰ā§ŽāĻĒāĻžāĻĻāĻ• (Factor)/āϗ⧁āĻŖāύ⧀āϝāĻŧāĻ• (Divisor) āϗ⧁āϞ⧋āϰ āϝ⧋āĻ—āĻĢāϞ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

  14. [32] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻĒā§āϰāĻ•ā§ƒāϤ āĻ‰ā§ŽāĻĒāĻžāĻĻāĻ• (Factor)/āϗ⧁āĻŖāύ⧀āϝāĻŧāĻ• (Divisor) āϗ⧁āϞ⧋āϰ āϝ⧋āĻ—āĻĢāϞ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

  15. [33] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻž āĻĒāĻžāϰāĻĢ⧇āĻ•ā§āϟ (Perfect) āϏāĻ‚āĻ–ā§āϝāĻž āĻ•āĻŋāύāĻž āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

  16. [34] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻž Perfect, Abundant, or Defective āϏāĻ‚āĻ–ā§āϝāĻž āĻ•āĻŋāύāĻž āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

  17. [35] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻž Amicable āϏāĻ‚āĻ–ā§āϝāĻž āĻ•āĻŋāύāĻž āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤ [sopd(a)==b&&sopd(b)==a]

  18. [36] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžā§Ÿ āĻ•ā§ŸāϟāĻŋ āĻ…āĻ‚āĻ• āĻ°ā§Ÿā§‡āϛ⧇ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

  19. [37] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžā§Ÿ āĻ…āĻ‚āĻ• āϗ⧁āϞ⧋āϕ⧇ āĻŦāĻŋāĻĒāϰ⧀āϤ āĻ•ā§āϰāĻŽā§‡ āĻĒā§āϰāĻĻāĻ°ā§āĻļāĻŖ āĻ•āϰāĨ¤

  20. [38] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻ…āĻ‚āĻ• āϗ⧁āϞ⧋āϰ āϝ⧋āĻ—āĻĢāϞ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

  21. [39] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻ…āĻ‚āĻ• āϗ⧁āϞ⧋āϰ āϝ⧋āĻ—āĻĢāϞ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰ, āϝāϤāĻ•ā§āώāύ āύāĻž āϝ⧋āĻ—āĻĢāϞ āĻāĻ• āĻ…āĻ‚āĻ• āĻŦāĻŋāĻļāĻŋāĻˇā§āϟ āĻšā§ŸāĨ¤

  22. [40] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻž āĻĒā§āϝāĻžāϞāĻŋāĻŖā§āĻĄā§āϰāĻŽ āϏāĻ‚āĻ–ā§āϝāĻž āĻ•āĻŋāύāĻž āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

āϏāĻŽāĻžāϧāĻžāύ

[19] āϝ⧇āϕ⧋āύ⧋ āĻāĻ•āϟāĻŋ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āύāĻžāĻŽāϤāĻž āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻ•āϰāĨ¤

#include<stdio.h>
int main(){
    int n, i;
    
    scanf("%d", &n);
    for(i = 1; i <= 10; i++){
        printf("%d x %d = %d\n", n, i, n * i);
    }

    return 0;
}
Sample Input
Sample Output

5

5 x 1 = 5

5 x 2 = 10

5 x 3 = 15

5 x 4 = 20

5 x 5 = 25

5 x 6 = 30

5 x 7 = 35

5 x 8 = 40

5 x 9 = 45

5 x 10 = 50

10

10 x 1 = 10

10 x 2 = 20

10 x 3 = 30

10 x 4 = 40

10 x 5 = 50

10 x 6 = 60

10 x 7 = 70

10 x 8 = 80

10 x 9 = 90

10 x 10 = 100

[20] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻĢā§āϝāĻžāĻ•ā§āϟāϰāĻŋāϝāĻŧāĻžāϞ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤ [N! = 1 × 2 × 3 × 4 × ......... × N]

#include<stdio.h>
int main(){
    int n, i;
    long long factorial = 1;

    scanf("%d", &n);
    for (i = 1; i <= n; i++) {
        factorial *= i;
    }
    printf("%d! = %lld\n", N, factorial);

    return 0;
}
Sample Input
Sample Output

5

5! = 120

10

10! = 3628800

[21] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻ‰ā§ŽāĻĒāĻžāĻĻāĻ• (Factor)/āϗ⧁āĻŖāύ⧀āϝāĻŧāĻ• (Divisor) āϗ⧁āϞ⧋ āĻĒā§āϰāĻĻāĻ°ā§āĻļāĻŖ āĻ•āϰāĨ¤

#include<stdio.h>
int main(){
    int n, i;
    
    scanf("%d", &n);
    for (i = 1; i <= n; i++) {
        if (n % i == 0) {
            printf("%d ", i);
        }
    }
    printf("\n");

    return 0;
}
Sample Input
Sample Output

28

1 2 4 7 14 28

100

1 2 4 5 10 20 25 50 100

[22] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻĒā§āϰāĻ•ā§ƒāϤ āĻ‰ā§ŽāĻĒāĻžāĻĻāĻ• (Factor)/āϗ⧁āĻŖāύ⧀āϝāĻŧāĻ• (Divisor) āϗ⧁āϞ⧋ āĻĒā§āϰāĻĻāĻ°ā§āĻļāĻŖ āĻ•āϰāĨ¤

#include<stdio.h>
int main(){
    int n, i;
    
    scanf("%d", &n);
    for (i = 1; i < n; i++) {
        if (n % i == 0) {
            printf("%d ", i);
        }
    }
    printf("\n");

    return 0;
}
Sample Input
Sample Output

28

1 2 4 7 14

100

1 2 4 5 10 20 25 50

[23] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻŽā§‹āϟ āĻ‰ā§ŽāĻĒāĻžāĻĻāĻ• (Factor)/āϗ⧁āĻŖāύ⧀āϝāĻŧāĻ• (Divisor) āϏāĻ‚āĻ–ā§āϝāĻž āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

#include<stdio.h>
int main(){
    int n, i, count = 0;
    
    scanf("%d", &n);
    for (i = 1; i <= n; i++) {
        if (n % i == 0) {
            count++;
        }
    }
    printf("%d\n", count);

    return 0;
}
Sample Input
Sample Output

28

6

100

9

[24] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻž āĻŽā§ŒāϞāĻŋāĻ• (Prime) āϏāĻ‚āĻ–ā§āϝāĻž āĻ•āĻŋāύāĻž āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

#include<stdio.h>
int main(){
    int n, i, count = 0;
    
    scanf("%d", &n);
    for (i = 1; i <= n; i++) {
        if (n % i == 0) {
            count++;
        }
    }
    if(count == 2){
        printf("%d is a Prime Number\n", n);
    }
    else{
        printf("%d is a Not Prime Number\n", n);
    }

    return 0;
}
Sample Input
Sample Output

13

13 is a Prime Number

100

100 is a Not Prime Number

[25] ā§§ āĻĨ⧇āϕ⧇ n āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϏāĻ‚āĻ–ā§āϝāĻž āϏāĻŽā§‚āĻšā§‡āϰ āĻŽāĻ§ā§āϝ⧇ āĻŽā§ŒāϞāĻŋāĻ• (Prime) āϏāĻ‚āĻ–ā§āϝāĻž āϗ⧁āϞ⧋ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

#include<stdio.h>
int main(){
    int n, i, j, count;
    
    scanf("%d", &n);
    for( j = 1; j <= n; j++){
        count = 0;
        for (i = 1; i <= j; i++) {
            if (j % i == 0) {
                count++;
            }
        }
        if(count == 2){
            printf("%d ", j);
        }
    }
    printf("\n", n);
    
    return 0;
}
Sample Input
Sample Output

30

2 3 5 7 11 13 17 19 23 29

100

2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

[25.1] ā§§ āĻĨ⧇āϕ⧇ ā§Šā§Ļ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϏāĻ‚āĻ–ā§āϝāĻž āϏāĻŽā§‚āĻšā§‡āϰ āĻŽāĻ§ā§āϝ⧇ āĻŽā§ŒāϞāĻŋāĻ• (Prime) āϏāĻ‚āĻ–ā§āϝāĻž āϗ⧁āϞ⧋ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

#include<stdio.h>
int main(){
    int n, i, j, count;
    
    for( j = 1; j <= 30; j++){
        count = 0;
        for (i = 1; i <= j; i++) {
            if (j % i == 0) {
                count++;
            }
        }
        if(count == 2){
            printf("%d ", j);
        }
    }
    printf("\n", n);
    
    return 0;
}
Sample Input
Sample Output

2 3 5 7 11 13 17 19 23 29

[26] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ āĻœā§‹ā§œ āĻ‰ā§ŽāĻĒāĻžāĻĻāĻ• (Factor)/āϗ⧁āĻŖāύ⧀āϝāĻŧāĻ• (Divisor) āϗ⧁āϞ⧋ āĻĒā§āϰāĻĻāĻ°ā§āĻļāĻŖ āĻ•āϰāĨ¤

#include<stdio.h>
int main(){
    int n, i;
    
    scanf("%d", &n);
    for (i = 1; i <= n; i++) {
        if (n % i == 0) {
            if( i % 2 == 0 ){
                printf("%d ", i);
            }
        }
    }
    printf("\n");

    return 0;
}
Sample Input
Sample Output

28

2 4 14 28

100

2 4 10 20 50 100

[27] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ āĻŦāĻŋāĻœā§‹ā§œ āĻ‰ā§ŽāĻĒāĻžāĻĻāĻ• (Factor)/āϗ⧁āĻŖāύ⧀āϝāĻŧāĻ• (Divisor) āϗ⧁āϞ⧋ āĻĒā§āϰāĻĻāĻ°ā§āĻļāĻŖ āĻ•āϰāĨ¤

#include<stdio.h>
int main(){
    int n, i;
    
    scanf("%d", &n);
    for (i = 1; i <= n; i++) {
        if (n % i == 0) {
            if( i % 2 == 1 ){
                printf("%d ", i);
            }
        }
    }
    printf("\n");

    return 0;
}
Sample Input
Sample Output

28

1 7

100

1 5 25

[28] āĻĻ⧁āχāϟāĻŋ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻ—.āϏāĻž.āϗ⧁ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

#include<stdio.h>
int main(){
    int a, b, temp, gcd;

    scanf("%d%d", &a, &b);
    while(b != 0){
        temp = b;
        b = a % b;
        a = temp;
    }
    gcd = a;
    printf("%d\n", gcd);
    
    return 0;
}
Sample Input
Sample Output

56 98

14

20 28

4

[29] āĻĻ⧁āχāϟāĻŋ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āϞ.āϏāĻž.āϗ⧁ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

#include<stdio.h>
int main(){
    int a, b, gcd, lcm;
    int temp, temp_a, temp_b;

    scanf("%d%d", &a, &b);
    temp_a = a, temp_b = b;
    while(temp_b != 0){
        temp = temp_b;
        temp_b = temp_a % temp_b;
        temp_a = temp;
    }
    gcd = temp_a;
    lcm = (a * b) / gcd;
    printf("%d\n", lcm);

    return 0;
}
Sample Input
Sample Output

12 15

60

20 25

100

[30] āĻĻ⧁āχāϟāĻŋ āϏāĻ‚āĻ–ā§āϝāĻž āϏāĻšāϗ⧁āĻŖāĻ• (Co-Prime) āĻ•āĻŋāύāĻž āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤ [if GCD (a, b) == 1, then a and b are Co-Prime]

#include<stdio.h>
int main(){
    int a, b, temp, gcd;

    scanf("%d%d", &a, &b);
    while(b != 0){
        temp = b;
        b = a % b;
        a = temp;
    }
    gcd = a;
    if(gcd == 1){
        printf("Co-Prime\n");
    }
    else{
        printf("Not Co-Prime\n");
    }
    
    return 0;
}
Sample Input
Sample Output

20 23

Co-Prime

20 25

Not Co-Prime

[31] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻ‰ā§ŽāĻĒāĻžāĻĻāĻ• (Factor)/āϗ⧁āĻŖāύ⧀āϝāĻŧāĻ• (Divisor) āϗ⧁āϞ⧋āϰ āϝ⧋āĻ—āĻĢāϞ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

#include<stdio.h>
int main(){
    int n, i, sum = 0;
    
    scanf("%d", &n);
    for (i = 1; i <= n; i++) {
        if (n % i == 0) {
            sum += i;
        }
    }
    printf("%d\n", sum);

    return 0;
}
Sample Input
Sample Output

28

56

100

217

[32] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻĒā§āϰāĻ•ā§ƒāϤ āĻ‰ā§ŽāĻĒāĻžāĻĻāĻ• (Factor)/āϗ⧁āĻŖāύ⧀āϝāĻŧāĻ• (Divisor) āϗ⧁āϞ⧋āϰ āϝ⧋āĻ—āĻĢāϞ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

#include<stdio.h>
int main(){
    int n, i, sum = 0;
    
    scanf("%d", &n);
    for (i = 1; i < n; i++) {
        if (n % i == 0) {
            sum += i;
        }
    }
    printf("%d\n", sum);

    return 0;
}
Sample Input
Sample Output

28

28

100

117

[33] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻž āĻĒāĻžāϰāĻĢ⧇āĻ•ā§āϟ (Perfect) āϏāĻ‚āĻ–ā§āϝāĻž āĻ•āĻŋāύāĻž āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

#include<stdio.h>
int main(){
    int n, i, sum = 0;
    
    scanf("%d", &n);
    for (i = 1; i < n; i++) {
        if (n % i == 0) {
            sum += i;
        }
    }
    if(sum == n){
        printf("%d is a Perfect Number\n", n);
    }
    else{
        printf("%d is a Not Perfect Number\n", n);
    }
    
    return 0;
}
Sample Input
Sample Output

28

28 is a Perfect Number

100

100 is a Not Perfect Number

[34] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻž Perfect, Abundant, or Defective āϏāĻ‚āĻ–ā§āϝāĻž āĻ•āĻŋāύāĻž āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

#include<stdio.h>
int main(){
    int n, i, sum = 0;
    
    scanf("%d", &n);
    for (i = 1; i < n; i++) {
        if (n % i == 0) {
            sum += i;
        }
    }
    if(sum == n){
        printf("%d is a Perfect Number\n", n);
    }
    else if( sum > n){
        printf("%d is a Abundant Number\n", n);
    }
    else{
        printf("%d is a Defective Number\n", n);
    }
    
    return 0;
}
Sample Input
Sample Output

28

28 is a Perfect Number

30

30 is a Abundant Number

35

35 is a Defective Number

[35] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻž Amicable āϏāĻ‚āĻ–ā§āϝāĻž āĻ•āĻŋāύāĻž āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤ [sopd(a)==b&&sopd(b)==a]

#include<stdio.h>
int main(){
    int a, b, i, sopd_a = 0, sopd_b = 0;
    
    scanf("%d%d", &a, &b);
    for (i = 1; i < a; i++) {
        if (a % i == 0) {
            sopd_a += i;
        }
    }
    for (i = 1; i < b; i++) {
        if (b % i == 0) {
            sopd_b += i;
        }
    }
    if(sopd_a == b && sopd_b == a){
        printf("Amicable Number\n");
    }
    else{
        printf("Not Amicable Number\n");
    }
    
    return 0;
}
Sample Input
Sample Output

220 284

Amicable Number

20 24

Not Amicable Number

[36] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžā§Ÿ āĻ•ā§ŸāϟāĻŋ āĻ…āĻ‚āĻ• āĻ°ā§Ÿā§‡āϛ⧇ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

#include<stdio.h>
int main(){
    int n, count = 0;
    
    scanf("%d", &n);
    while(n != 0){
        n /= 10;
        count++;
    }
    printf("%d\n", count);
    
    return 0;
}
Sample Input
Sample Output

100

3

12345

5

[37] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžā§Ÿ āĻ…āĻ‚āĻ• āϗ⧁āϞ⧋āϕ⧇ āĻŦāĻŋāĻĒāϰ⧀āϤ āĻ•ā§āϰāĻŽā§‡ āĻĒā§āϰāĻĻāĻ°ā§āĻļāĻŖ āĻ•āϰāĨ¤

#include<stdio.h>
int main(){
    int n;
    
    scanf("%d", &n);
    while(n != 0){
        printf("%d", n % 10);
        n /= 10;
    }
    
    return 0;
}
Sample Input
Sample Output

12345

54321

987654321

123456789

[38] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻ…āĻ‚āĻ• āϗ⧁āϞ⧋āϰ āϝ⧋āĻ—āĻĢāϞ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

#include<stdio.h>
int main(){
    int n, sum = 0;
    
    scanf("%d", &n);
    while(n != 0){
        sum += n % 10;
        n /= 10;
    }
    printf("%d\n", sum);
    return 0;
}
Sample Input
Sample Output

12345

15

987654321

45

[39] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžāϰ āĻ…āĻ‚āĻ• āϗ⧁āϞ⧋āϰ āϝ⧋āĻ—āĻĢāϞ āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰ, āϝāϤāĻ•ā§āώāύ āύāĻž āϝ⧋āĻ—āĻĢāϞ āĻāĻ• āĻ…āĻ‚āĻ• āĻŦāĻŋāĻļāĻŋāĻˇā§āϟ āĻšā§ŸāĨ¤

#include<stdio.h>
int main(){
    int n, sum;
    
    scanf("%d", &n);
    while(n > 9){
        sum = 0;
        while(n != 0){
            sum += n % 10;
            n /= 10;
        }
        n = sum;
    }
    printf("%d\n", sum);
    return 0;
}
Sample Input
Sample Output

12345

6

987654321

9

[40] āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻž āĻĒā§āϝāĻžāϞāĻŋāĻŖā§āĻĄā§āϰāĻŽ āϏāĻ‚āĻ–ā§āϝāĻž āĻ•āĻŋāύāĻž āύāĻŋāĻ°ā§āϪ⧟ āĻ•āϰāĨ¤

#include<stdio.h>
int main(){
    int n, a, b = 0;
    
    scanf("%d", &n);
    a = n;
    while(n != 0){
        b = b * 10 + n % 10;
        n /= 10;
    }
    if(a == b){
        printf("%d is a Palindrom.\n", a);
    }
    else{
        printf("%d is a Not Palindrom.\n", a);
    }
    
    return 0;
}
Sample Input
Sample Output

1221

1221 is a Palindrom.

123

123 is Not a Palindrom.

Previous4.1.3 Summation of SeriesNext5: Pointer and Dynamic Memory Allocation

Last updated 8 months ago