Swap nibbles of a given number

#define swapNibble(num)   (( num & 0xF ) << 4 )  |  ( ( num 7 0xF0 ) >> 4 )

( num & 0xF ) << 4 ) : This grabs first nibble of nummber  and left shifts the nibble  to 4 places

( num 7 0xF0 ) >> 4 ) : And this grabs the next nibble of the number and right shifts the nibble  to 4 places

Finally we use bitwise OR  swap is completed

Efficiency of Short Hand Notation

Why x += 1 ; is more efficient than x = x+1 ?

It is related to how assembler references the memory location accesss .
The ALU uses registers for referencing values and accumulator for storing partial results .
 So , for case 1 : 
  x =  x + 1 ;
 
  MOV A , (x) ;  // Move the value at memory location x in accumultor A  . The value of x is stored in register
  ADD A , 1  ; // ADD 1 IN ACCUMULATor
  MOV (X) ,  A ; // Move the value in accumulator at memory location referenced by x
 
  for case 2 :
  x += 1
  ADD (x) , 1 ; // Add 1 at memory location referenced by x
 
  So , so coz of efficient dereferncing and no partial result generation  , short hand artihmatic noations are efficient even though at an abstract view all operations produce same results

Find even or odd parity of a given unsigned number

// parity here means total number of set bits in  a number

typedef int bool ;


int parity ( unsigned int num )
{
    bool parity  = 0 ; // 0 means even parity and 1 meand odd parity
   
    while ( num )
    {
        parity  = !parity ;
        num &= n-1 ;
     }
   
    return parity;
}

i haave seen a million faces
but still my heart embraces

Transpose A Matrix

public class mMatrix {

    public static void main(String args[]) {
        int[][] twodarray = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
       
        for( int i = 0 ; i < twodarray.length ; ++i)
        {
            for( int j = 0 ; j < twodarray[0].length ; ++j)
            {
                System.out.print(twodarray[i][j] + " ");
            }
            System.out.println();
           
        }
       
        int transpose [][]  = new int [ twodarray.length ][ twodarray[0].length ];       
        for( int i = 0 ; i < twodarray.length ; ++i)
        {
            for( int j = 0 ; j < twodarray[0].length ; ++j)
            {
               
                transpose[j][i] = twodarray[i][j];
               
            }
            System.out.println();
           
        }
       
        for( int i = 0 ; i < twodarray.length ; ++i)
        {
            for( int j = 0 ; j < twodarray[0].length ; ++j)
            {
                System.out.print(transpose[i][j] + " ");
            }
            System.out.println();
           
        }
       
       
    }

}

LCM

import java.io.InputStreamReader;
import java.io.BufferedReader;

public class hLCM {
    public static void main(String args[]) {
        InputStreamReader in = new InputStreamReader(System.in);
        BufferedReader reader = new BufferedReader(in);

        int first = 0;
        int second = 0;
        // get a number
        System.out.println("Enter  numbers to find LCM : ");
        try {
            first = Integer.parseInt(reader.readLine());
            second = Integer.parseInt(reader.readLine());
        } catch (Exception e) {
            e.printStackTrace();
           
        }

        int lcm = first * ( second / gcd(first , second ) );
               
       
        System.out.println("LCM is "  + lcm );

    }

    private static int gcd(int first, int second) {
        while (second > 0) {
            int temp = second;
            second = first % second;
             first = temp ;

        }
        return first ;
    }
}

GCD

import java.io.InputStreamReader;

import java.io.BufferedReader;

public class gGCD {
    public static void main(String args[]) {
        InputStreamReader in = new InputStreamReader(System.in);
        BufferedReader reader = new BufferedReader(in);

        int first = 0;
        int second = 0;
        // get a number
        System.out.println("Enter  numbers to find GCD : ");
        try {
            first = Integer.parseInt(reader.readLine());
            second = Integer.parseInt(reader.readLine());
        } catch (Exception e) {
            e.printStackTrace();
           
        }

        first = gcd(first , second);
       
        System.out.println("GCD is "  + first);

    }

    private static int gcd(int first, int second) {
        if(second > 0)
            first =  gcd(second , first % second) ;
        return
                first ;
   
       
    }
}

Floyd's Triangle

import java.io.InputStreamReader;
import java.io.BufferedReader;

public class eFloydsTraingle {
    public static void main(String args[]) {
        InputStreamReader in = new InputStreamReader(System.in);
        BufferedReader reader = new BufferedReader(in);

        int length = 0;
        // get a number
        System.out.println("Enter height of triangle : ");
        try {
            length = Integer.parseInt(reader.readLine());
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("Out of memory");
            return;
        }
       
        int fIndex = 1 ;
        // print the triangle
        for(int i=0 ; i < length ; ++i)
        {
            for(int j= 0 ; j <= i ; ++j){
                System.out.print(fIndex++  + " ");
            }
            System.out.println();
        }

    }
}

Is a given Number Palindrome

import java.io.InputStreamReader;
import java.io.BufferedReader;

public class dNumberIsPalindrome {
    public static void main(String args[]) {
        InputStreamReader in = new InputStreamReader(System.in);
        BufferedReader reader = new BufferedReader(in);

        String num;
        // get a number
        System.out.println("Enter a number : ");
        try {
            num = reader.readLine();
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("Out of memory");
            return;
        }

        boolean isPalindrome = false;

        char array[] = num.toCharArray();
        int endIndex = array.length - 1;
        for (int startIndex = 0; startIndex <= endIndex; ++startIndex, --endIndex) {

            if (array[startIndex] != array[endIndex]) {
                isPalindrome = false;
                break;
            }
            isPalindrome = true;
        }

        System.out.println("Palindorme check for " + num + " is "
                + isPalindrome);

    }
}

Sum of digits

import java.io.InputStreamReader;
import java.io.BufferedReader;

public class cCountSumOfDigits {
    public static void main(String args[]) {
        InputStreamReader in = new InputStreamReader(System.in);
        BufferedReader reader = new BufferedReader(in);

        int num = 0;
        // get a number
        System.out.println("Enter a number : ");
        try {
            num = Integer.parseInt(reader.readLine());
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("Out of memory");
            return;
        }
        int temp = num;
        int sum = 0;
        while (num > 0) {
            sum += num % 10;
            num /= 10;
        }

        System.out.println("Sum of digits in " + temp + " is " + sum);

    }
}

Count total digits

import java.io.InputStreamReader;
import java.io.BufferedReader;

public class bCountDigits {
    public static void main(String args[]) {
        InputStreamReader in = new InputStreamReader(System.in);
        BufferedReader reader = new BufferedReader(in);

        int num = 0;
        // get a number
        System.out.println("Enter a number : ");
        try {
            num = Integer.parseInt(reader.readLine());
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("Out of memory");
            return;
        }
        int temp = num;
        int ttlDigits = 0;
        while (num > 0) {
            ++ttlDigits;
            num /= 10;
        }

        ttlDigits = (ttlDigits == 0) ? 1 : ttlDigits;

        System.out.println("Total digits in " + temp + " is " + ttlDigits);

    }
}

Reverse a number

import java.io.InputStreamReader;
import java.io.BufferedReader;

public class aReverseNumber {
    public static void main(String args[]) {
        InputStreamReader in = new InputStreamReader(System.in);
        BufferedReader reader = new BufferedReader(in);

        int num = 0;
        // get a number
        System.out.println("Enter a number : ");
        try {
             num = Integer.parseInt(reader.readLine());
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("Out of memory");
            return ;
        }
        int temp = num ;
        int revNum = 0 ;
        while (num > 0 )
        {
            revNum = revNum *10 +  num % 10 ;
            num/= 10 ;
        }
       
        System.out.println("Reverse of " + temp + " is " +revNum );
       
       
       
    }
}

If I Switch

/*#include<iostream>
#include<conio.h>
using namespace std;
int main()
{

    int a = 2, b = 5;
    switch (a)
    {
    case 1:cout << "case 1 \n";
        // ...
        cout << "bw i and 2  \n";
        if (b == 2)
        {
    case 2:  cout << "case 2 \n";
        cout << "in if  after case  2  \n";
        // ...
        }
        else case 3:
        {
            cout << "else case 3   \n";
            // ...
            for (b = 0; b < 10; b++)
            {
        case 5: cout <<"case 5 \n"; cout << "loop \n";
            // ...
            }
        }
            break;

        case 4:
            cout << "case 4  \n";
            // ...
            break;
    }
    getchar();
}