#include  < iostream.h > 

void main()
{
        int a, b, c, d, max;

        cout << "Enter 4 values ";

        cin  >> a >> b >> c >> d;

        max = a;

        if(b/max)
                max=b;

        if(c/max)
                max=c;

        if(d/max)
                max=d;

  cout  << "Maximum is " << max;
}

#include <iostream.h>
void main()
{
        int a, b;
        cout << "Enter two values ";
        cin >> a >> b;

        a = a + b;
        b = a - b;
        a = a - b;

        cout << "After swapping a = " << a << "b = " << b;
}

#include <stdio.h>

void main( )
{
    if (printf("Bodacious it hub pvt. ltd. "))
    { }
}

#include <iostream.h>

void main( )
{
       int a , b;
       cout << "Enter 2 values ";
       cin >> a >> b;
       
       a = a ^ b;
       b = a ^ b;
       a = a ^ b;

       cout << "After swapping a = " << a << " b = " << b;
}

// we can overcome overflow problem using this version

Q. If a blank file is saved with the name A.java, what will happen 
   when this file is compiled ?

A. The program will compile successfully as there is no compile 
   time error in it but it wont create any class file so we wont
   be able to execute it.

Nothing will happen ... destroy() will be executed and servlet will 
continue running. destroy() method is not supposed to destroy 
servlet instance, in fact it is called by servlet container when 
it decides to destroy the servlet.

if u want a function to be called when ur application terminates 
u can use atexit( functionname) for that purpose.

The function should not take any argument and return no value.

u can call atexit( ) multiple times in ur program and they all will 
be executed in reverse order of calling.(see the example)

example :

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

void func1 (void)
{
  puts ("Jaipur");
}

void func2 (void)
{
  puts ("Bodacious IT Hub Pvt. Ltd.");
}

int main ()
{
  atexit (func1);
  atexit (func2);
  puts ("Main function.");
  return 0;
} 


output will be:

Main function.
Bodacious IT Hub Pvt. Ltd.
Jaipur

Both malloc() and calloc() are used for dynamic memory allocation.
malloc() is used to allocate a single block of memory.
calloc() is used to allocate multiple block of memory.
malloc() leaves the memory uninitialized whereas calloc() initializes it with 0.
malloc() takes single argument whereas calloc() takes two arguments.
calloc() is slightly less efficient then malloc( ).

import java.io.*;
import java.util.*;

public class SequenceInputStreamTest {

 public static void main(String[] args) throws Exception {

  FileInputStream fis1 = new FileInputStream("test1.txt");
  FileInputStream fis2 = new FileInputStream("test2.txt");
  FileInputStream fis3 = new FileInputStream("test3.txt");

  Vector<InputStream> inputStreams = new Vector<InputStream>();
  inputStreams.add(fis1);
  inputStreams.add(fis2);
  inputStreams.add(fis3);

  Enumeration<InputStream> enu = inputStreams.elements();
  SequenceInputStream sis = new SequenceInputStream(enu);

  int ch;
  while ((ch = sis.read()) != -1) {
    System.out.print((char)ch);
  }

  sis.close();
 }
}

import java.awt.*;
import java.awt.image.*;
import javax.swing.*;
class LabelIconDemo {
 public static void main(String args[]) {
  JFrame f = new JFrame();
  f.setDefaultCloseOperation(f.EXIT_ON_CLOSE);
  MyLabel l = new MyLabel();
  f.add(l);
  f.setSize(400,400);
  f.setVisible(true);
 }
}

class MyLabel extends JLabel {
 Image img = Toolkit.getDefaultToolkit().createImage(getClass().getResource("icon.jpg"));
 public void paintComponent(Graphics g) {
  super.paintComponent(g);
  g.drawImage(img, 0, 0, getWidth(), getHeight(), Color.white, this);
 }

 public boolean imageUpdate(Image image, int flags, int x, int y , int width, int height){
  super.imageUpdate(image, flags, x, y , width, height);
  Graphics g = getGraphics();
  g.drawImage(img, 0, 0, getWidth(), getHeight(), Color.white, this);
  return true;
 }
}

import java.awt.*;
import javax.swing.*;
class LayeredPaneDemo extends JFrame
{
    public LayeredPaneDemo() {
        super("LayeredPaneDemo");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        JLayeredPane lp = getLayeredPane();
        lp.setLayout(null);
        for(int i=0;i<5;i++)
        {
            JButton b = new JButton("Button"+(i+1));
            b.setBounds(50+(i*40),50+(i*40),100,50);
            lp.add(b,i);
        }
        setBounds(50,50,500,400);
        setVisible(true);
    }
    public static void main(String args[ ]) {
        new LayeredPaneDemo();
    }
}

import java.io.*;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class FileChooserDemo{
JFrame f;
JButton b;

public FileChooserDemo(){
f = new JFrame();
f.setBounds(100,100,250,200);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setLayout(new FlowLayout());
b = new JButton("Choose File");
f.add(b);
b.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
JFileChooser jfc = new JFileChooser();
int action = jfc.showOpenDialog(f); // Pops up a open file dialog
//int action = jfc.showSaveDialog(f); // Pops up a file save dialog
if(action == JFileChooser.APPROVE_OPTION){
File f = jfc.getSelectedFile();
System.out.println("Selected File " + f.getPath());
}

}
});
f.setVisible(true);
}

public static void main(String args[]){
new FileChooserDemo();
}
}

import java.awt.*;
import javax.swing.*;
import javax.swing.text.*;

public class TextPaneDemo extends JFrame{
JTextPane jtp;
public TextPaneDemo(){
setBounds(100,100,400,400);
setDefaultCloseOperation(EXIT_ON_CLOSE);
jtp = new JTextPane();
add(jtp);
jtp.setText("This is a simple JText Pane Example.\nThis is bold and underlined");
//=== Featching StyledDocument for styles =======================
StyledDocument doc = jtp.getStyledDocument();

//=== Creating a new style ======================================
Style redStyle = jtp.addStyle("red", null); 
        // Style addStyle(String styleName, Style parent);
StyleConstants.setForeground(redStyle, Color.red);

//=== Apply new style to specifiec characters of text pane ======
doc.setCharacterAttributes(10,6,jtp.getStyle("red"), true);

//=== Creating Bold & Underlined Style ==========================
Style bold_ul = jtp.addStyle("bold_ul", null);
StyleConstants.setBold(bold_ul, true);
StyleConstants.setUnderline(bold_ul, true);

doc.setCharacterAttributes(37, 27, bold_ul, true);

//=== Creating text with background color =======================
Style italic_blue = jtp.addStyle("italic_blue", null);
StyleConstants.setItalic(italic_blue, true);
StyleConstants.setForeground(italic_blue, Color.white);
StyleConstants.setBackground(italic_blue, Color.blue);

try{
//*** inserting text at the end of text pane with style ****
doc.insertString(doc.getEndPosition().getOffset(), "\nThis is Highlighted", italic_blue);
}
catch(BadLocationException ble){
ble.printStackTrace();
}

setVisible(true);
}

public static void main (String[] args) {
new TextPaneDemo();
}
}

Step 1 : To read data from an excel document, we need to create a Data Source Name (DSN) in Control Panel for excel document.

Step 2 : Now we can use this DSN name into our simple JDBC program (All drivers and classes will remain same).

Program:
import java.io.*;
import java.sql.*;
public class ExcelReadTest{
public static void main(String[] args){
 Connection connection = null;
 try{
  Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
  Connection con = DriverManager.getConnection( "jdbc:odbc:exceltest" );
  Statement st = con.createStatement();
  ResultSet rs = st.executeQuery( "Select * from [Sheet1$]" );

  ResultSetMetaData rsmd = rs.getMetaData();
  int numberOfColumns = rsmd.getColumnCount();

  while (rs.next()) {
   for (int i = 1; i <= numberOfColumns; i++) {
     if (i > 1) System.out.print(", ");
     String columnValue = rs.getString(i);
     System.out.print(columnValue);
   }
   System.out.println("");
  }

  st.close();
  con.close();

 }
 catch(Exception ex) {
  System.out.println(ex.getMessage());
 }
}
}

File-1: (index.html)
===============

<!doctype html>
<html>
<head>
<title>File Upload Example</title>
</head>
<body>
<form action="upload" method="post" enctype="multipart/form-data">
Select File : <input type="file" name="file" />
<br />
<input type="submit" value="Upload File"/>
</form>
</body>
</html>

*****************************************************************************************

File-2: (FileUploadServlet.java)
=========================

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.sql.*;

@WebServlet(name = "FileUploadServlet", urlPatterns = {"/upload"})
@MultipartConfig
public class FileUploadServlet extends HttpServlet{

public void doPost(HttpServletRequest request, HttpServletResponse response){
OutputStream out = null;
InputStream filecontent = null;
PrintWriter writer = null;

try {
Part part = request.getPart("file");
String fileName = getFileName(part);
String type = part.getContentType();
long size = part.getSize();

String fileData = "";

writer = response.getWriter();

filecontent = part.getInputStream();


DriverManager.registerDriver(new com.mysql.jdbc.Driver());
Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root", "root");

String sql = "insert into files(fname, type, size, filedata) values"
+"(?,?,?, ?)";


PreparedStatement pstmt = con.prepareStatement(sql);

pstmt.setString(1, fileName);
pstmt.setString(2, type);
pstmt.setLong(3, size);
pstmt.setBinaryStream(4, filecontent);

int id = pstmt.executeUpdate();
if(id > 0)
writer.println("New file " + fileName + " uploaded successfully");

if (filecontent != null) {
filecontent.close();
}
if (writer != null) {
writer.close();
}

} catch (Exception e) {
e.printStackTrace();
writer.println("
ERROR: " + e.getMessage());
}
}

private String getFileName(final Part part) {
final String partHeader = part.getHeader("content-disposition");
for (String content : part.getHeader("content-disposition").split(";")) {
if (content.trim().startsWith("filename")) {
return content.substring(
content.indexOf('=') + 1).trim().replace("\"", "");
}
}
return null;
}
}

class EightQueen
{
private int arr[];
int sizeOfChessBoard;
public EightQueen(int n)
{
this.sizeOfChessBoard=n;
arr=new int[sizeOfChessBoard];
problem(0);
}
public void print() //for printting chess board
{
for(int i=0;i < arr.length;i++)
{
for(int j=0;j< sizeOfChessBoard;j++)
{
if(arr[i]==j)
{
System.out.print("Q");
}
else
System.out.print("-");
}
{
}
System.out.println();
}
}
boolean check(int row,int col) //check if queen can be placed or not
{
for(int i=0;i< row;i++)
{
if(arr[i]==col || (arr[i]-col)==(i-row) || (col-arr[i])==(i-row)) //check if queen exists in same row or diagonal
{
return false;
}
}
return true;
}
public void problem(int counter) //backtracking algorithm for sizeOfChessBoard queen
{
if(counter==sizeOfChessBoard)
{
print();
System.out.println();
return;
}
for(int i=0;i< arr.length;i++)
{
arr[counter]=i;
if(check(counter,i)) //branch and bound
{
problem(counter+1);
}
}
}
public static void main(String arg[])
{
new EightQueen(8);
}
}

#include
#include
using namespace std;
class DynamicStack
{
private:
char *arr;
int top;
char *temp;
int MAX;
public:
DynamicStack(int size):MAX(size)
{
arr=new char[MAX];
top=-1;
}
bool reAllocateArray()
{
temp=new char[MAX*2];
if(temp==0)
return false;
MAX=MAX*2;
for(int i=0;i<=top;i++)
{
temp[i]=arr[i];
}
arr=temp;
return true;
}
bool isEmpty()
{
return top==-1;
}
void push(char item)
{
if(top+1==MAX)
{
if(!reAllocateArray())
{
cout<< endl<<"Memory Can't be Allocated.";
return;
}
}
arr[++top]=item;
}
char pop()
{
if(isEmpty())
{
cout<< endl<<"Stack is Empty.";
return -1;
}
return arr[top--];
}
};
class ExpressionValidation
{
private:
DynamicStack * stack;
char *expression;
public:
ExpressionValidation(char *expression)
{
this->expression=expression;
stack =new DynamicStack(strlen(expression)+1);
}
bool match(char c1,char c2)
{
if(c1==')' && c2=='(')
{
return true;
}
if(c1==']' && c2=='[')
{
return true;
}
if(c1=='}' && c2=='{')
{
return true;
}
return false;
}
bool check()
{
for(unsigned i=0;i {
cout<<" "< if(expression[i]=='(' || expression[i]=='{' || expression[i]=='[')
{
stack->push(expression[i]);
}
else if(expression[i]==')' || expression[i]=='}' || expression[i]==']')
{
if(stack->isEmpty())
{
return false;
}
else
{
char ch=stack->pop();
if(!match(expression[i],ch))
{
return false;
}
}
}
}
if(!stack->isEmpty())
{
return false;
}
return true;
}
};
int main()
{
cout<<"Enter Expression";
char str[100];
cin>>str;
ExpressionValidation * exp=new ExpressionValidation(str);
bool b=exp->check();
if(b)
{
cout<< endl <<"Expression is Vaild.";
}
else
{
cout<< endl <<"Expression is Not Vaild";
}
}

ALB Application Load Balancer
AMI Amazon Machine Image
ARN Amazon Resource Name
ASG Auto Scaling Groups
CFN Cloud Formation
DDOS Distributed Denial of Service
EB Elastic BeanStalk
EBS Elastic Block Storage
EC2 Elastic Cloud Compute
ECR Elastic Container Repository
ECS Elastic Container Service
EFS Elastic File Storage
EKS Elastic Kubernetes Service
ELB Elastic Load Balancer
EMR Elastic MapReduce
ES ElastiSearch
IAM Identity and Access Management
IoT Internet of Things
MKS Managed Kafka Service
MQ Amazon ActiveMQ
NLB Network Load Balancer
RDS Relation Database Service
RI Reserved Instances
S3 Simple Storage Service
SES Simple Email Service
SNS Simple Notification Service
SQS Simple Queue Service
SSM Simple Systems Manager
SWF Simple WorkFlow Service
TAM Technical Account Manager
TCO Total Cost of Ownership
VPC Virtual Private Cloud
VPN Virtual Private Network
WAF Web Application Firewall